Matlab for Controls

MATLAB for Controls:

youtube playlist

url here

for more information please like our page on Fb 

Geeks-electronics

دورة الالكترونيات العملية

دورة الالكترونيات العملية

افضل دورة عربية لاحتراف الالكترونيات من اعداد المهندس وليد عيسى 

انتاج              موقع eletorial 

روابط الدورة :

رابط الدورة الرئيسي :        here

رابط اليوتيوب:                     here

للمزيد من المعلومات زورو موقع المهندس ,

كتاب السي الشامل

افضل كتاب لتعلم لغة السي بابسط طريقة ممكنة 

كتاب تطبيقي 100%

تاليف :  خليل اونيس

رابط الكتاب:

من هنا

apprendre à développer en C

  les coures videos pour debutez le programmation en C

lien des videos:  (youtube)

apprendre à développer en C

lesson 3: les operations

Les Opérations:

Dans beaucoup de programmes C, il y a, à un moment ou un autre, besoin d'effectuer des calculs plus ou moins importants. C'est pour cela qu'il me semble nécessaire que nous apprenions a faire des maths depuis notre programme.

Expressions

Qu'est ce qu'une expression ?

2 + 3
ageUtilisateur

Voila deux expressions. Fondamentalement toutes représentations de valeur en C est une expression La variable ageUtilisateur( pour reprendre l'exemple du dessus ) représente bien une valeur : cette valeur sera sans doute un âge.

D'ailleurs on peut afficher cela avec un code tout simple :

Code c:

int main ()
{
 printf(" 2 + 3 = %ld", 2 + 3);
 return 0;
}

On suppose ici que le résultat est de type long , Normalement on voit apparaitre :

Code console:

2 + 3 = 5

explication:

Les additions

Vous savez tous, enfin j'espère, comment fonctionne une addition. Et bien en C, c'est pareil.   On additionne deux nombres, deux variables, grâce à l'opérateur arithmétique " + ". Et de la même manière qu'au dessus on affiche le résultat dans un printf.

Comme un bon code vaut mieux qu'un long discours, voici un code dans lequel on trouve en premier :

• - une variable dont la valeur est le résultat d'une addition toute simple
• - une autre variable dont la valeur vaut celle de la précédente à laquelle on ajoute deux.
• - une variable dont la valeur vaut la somme des valeurs des deux variables précédentes.

Code c:

int main ()
{
 long chiffre = 1 + 1;
 long chiffre2 = chiffre + 2;
 long chiffre3 = chiffre + chiffre2;
 
 printf ("Chiffre vaut : %ld, chiffre2 vaut : %ld et l addition des deux vaut : %ld", chiffre, chiffre2, chiffre3);
 return 0;
}

Attention il est important d'initialiser en premier " chiffre ", puis " chiffre2 " et enfin " chiffre3 " sinon le compilateur plante ... Je tenais à vous faire écrire ce code pour vous faire part de cette erreur assez répandue chez les débutants en C. Mais pas de panique on comprend très vite.

On peut aussi faire une addition de variables directement dans le printf. Mais j'avoue ça devient illisible quand on utilise trop de valeur. Il vaut donc mieux faire le calcul en dehors du printf.

Un petit code pour montrer ça :

Code c:

int main ()
{
 long chiffre = 1 + 1;
 long chiffre2 = chiffre + 2;
 printf ("L addition vaut %ld", chiffre + chiffre2);
 return 0;
}

Tiens ...

Maintenant que nous savons additionner pourquoi ne pas créer une petite calculette ?
Voila comment on va se dérouler le programme

• - On demande deux nombres entiers à l'utilisateur.
• - On les stocke dans deux variables
• - On additionne ces variables et on stocke le résultat dans une troisième variable
• - On affiche le résultat

Voici la solution :

Code c:

int main ()
{
 long premierNombre = 0;
 long deuxiemeNombre = 0;
 long resultat = 0;

 /* \t équivaut à une tabulation */
 printf("\t\tMa super calculette\n\n");
 printf("Ce programme additionne 2 nombres entiers !!!\n");
 printf("Entrez le premier nombre svp : ");
 scanf("%ld", &premierNombre);
 printf("Deuxieme ombre svp : ");
 scanf("%ld", &deuxiemeNombre);

 resultat = premierNombre + deuxiemeNombre;

 printf("\nResultat : %ld", resultat);
 return 0;
}

Ce qui nous donne :

Code console:

Entrez le premier nombre svp : 21 Deuxieme nombre svp : 56 Resultat : 77

C'est simple, c'est simple ...

Les soustractions

Et bien il s'agit exactement du même principe que l'addition si ce n'est qu'on utilise l'opérateur " - " et que le programme réalise une soustraction ... Que dire d'autre ? Rien ... Un petit code quand même pour illustrer :

Code c:

int main ()
{
 long chiffre = 2;
 long chiffre2 = 3;
 long chiffre3 = chiffre - chiffre2;
 long chiffre4 = 10 - 8;

 printf("chiffre3 vaut : %ld, chiffre4 vaut %ld.", chiffre3, chiffre4);
 return 0;
}

Code console:

chiffre3 vaut : -1, chiffre4 vaut 2.

Les multiplications

Toujours le même principe que l'addition, sauf que l'opérateur n'est pas " x " mais " * ". Et bien entendu il s'effectue non plus une addition mais une multiplication. Le code fournie avec le produit .

Code c:

int main ()
{
 long chiffre = 2;
 long chiffre2 = 4;
 long chiffre3 = chiffre * chiffre2;
 long chiffre4 = 10 * 0;

 printf("chiffre3 vaut : %ld, chiffre4 vaut %ld.", chiffre3, chiffre4);
 return 0;
}

Code console:

chiffre3 vaut : 8, chiffre4 vaut 0.

Les divisions et modulos

Toujours le même principe que l'addition sauf que l'opérateur de le division est " / " et celui du modulo est " % ".

Quel différence entre les deux ?

Et bien la division est un peu complexe, en effet on ne prend pas en compte la possible virgule, ce qui fait que le résultat d'une division telle que 2 / 4 ne sera pas égale à 0.5 mais à 0 ! C'est un petit peu le principe des divisions à reste. On ne s'occupe que du quotient et pas du reste.

Le modulo quand à lui s'occupe du reste. Si vous tapez dans un programme 2 % 4 alors le résultat sera égale au reste ( 2 ).

!!!!!!! ATTENTION !!!!!! UNE DIVISION PAR 0 EST INTERDITE !!!!

Le code qui résume :

Code c:

int main ()
{
 long chiffre = 2 % 4;
 long chiffre2 = 2 / 4;

 printf("chiffre vaut : %ld, chiffre2 vaut %ld.", chiffre, chiffre2);
 return 0;
}

Code console:

chiffre vaut : 2, chiffre2 vaut 0.

à la fin "enjoy !".

LESSON 2 : les variables et les constants

1-Les variables:

Le concept de variable

Une variable est un objet repéré par son nom, pouvant contenir
des données, qui pourront être modifiées lors de l'exécution du programme.
Les variables en langage C sont typées, c'est-à-dire que les données
contenues dans celles-ci possèdent un type, ainsi elles sont donc stockées dans la mémoire
et occupent un nombre d'octets dépendant du type de donnée stockée.

En langage C, les noms de variables peuvent être aussi long que l'on désire, toutefois
le compilateur ne tiendra compte que des 32 premiers caractères.
De plus, elles
doivent répondre à certains critères :

• un nom de variable doit commencer par une lettre (majuscule ou minuscule) ou un « _ » (pas par un chiffre)
• un nom de variable peut comporter des lettres, des chiffres et le caractère   

       « _ » (les espaces ne sont pas autorisés !)

• les noms de variables ne peuvent pas être les noms suivants (qui sont des noms réservés) :
  • auto
  • break
  • case, char, const, continue
  • default, do, double
  • else, enum, extern
  • float, for
  • goto
  • if, int
  • long
  • register, return
  • short, signed, sizeof, static, struct, switch
  • typedef
  • union, unsigned
  • void, volatile
  • while

Les noms de variables sont sensibles à la casse (le langage C fait la différence entre
un nom en majuscules et un nom en minuscules), il faut donc veiller à

utiliser des noms comportant la même casse !

La déclaration de variables

       Pour pouvoir utiliser une variable, il faut la définir, c'est-à-dire lui  donner un nom, mais surtout un type de donnée à stocker afin qu'un  espace mémoire conforme au type de donnée qu'elle contient lui soit réservé.

Une variable se déclare de la façon suivante :

 type Nom_de_la_variable;

ou bien s'il y a plusieurs variables du même type :

 type Nom_de_la_variable1, Nom_de_la_variable2, ...;

Affectation d'une donnée à une variable

Pour stocker une donnée dans une variable que l'on a initialisée, il faut faire une affectation, c'est-à-dire préciser la donnée qui va être stockée à l'emplacement mémoire qui a été réservé lors de l'initialisation.

Pour cela on utilise l'opérateur d'affectation « = » :

Nom_de_la_variable = donnée;

Pour stocker le caractère B dans la variable que l'on a appelée Caractere,
il faudra écrire :

 Caractere = 'B';

Ce qui signifie stocker la valeur ASCII de « B » dans la variable nommée «caractere».
Il est bien évident qu'il faut avoir préalablement déclaré la variable en lui affectant
le type char :

 char Caractere;

Initialisation d'une variable

La déclaration d'une variable ne fait que « réserver » un emplacement mémoire où stocker la variable. Tant que l'on ne lui a pas affecté une donnée celle-ci contient ce qui se trouvait précédemment à cet emplacement, que l'on appelle garbage (en français détritus).

On peut donc affecter une valeur initiale à la variable lors de sa déclaration, on parle
alors d'initialisation :

 type Nom_de_la_variable = donnee;

Par exemple :

 float Toto = 125.36;

Portée (visibilité) des variables

Selon l'endroit où on déclare une variable, celle-ci pourra être accessible (visible) de partout dans le code ou bien que dans une portion confinée de celui-ci (à l'intérieur d'une fonction par exemple), on parle de portée (ou visibilité) d'une variable.

Lorsqu'une variable est déclarée dans le code même, c'est-à-dire à l'extérieur de toute fonction ou de tout bloc d'instruction, elle est accessible de partout dans le code (n'importe quelle fonction du programme peut faire appel à cette variable). On parle alors de variable globale.

Lorsque l'on déclare une variable à l'intérieur d'un bloc d'instructions (entre des accolades), sa portée se confine à l'intérieur du bloc dans lequel elle est déclarée.

• Une variable déclarée au début du code, c'est-à-dire avant tout bloc de donnée, sera globale, on pourra alors l'utiliser à partir de n'importe quel bloc d'instruction.
• Une variable déclarée à l'intérieur d'un bloc d'instructions (dans une fonction ou une boucle par exemple) aura une portée limitée à ce seul bloc d'instruction, c'est-à-dire qu'elle est inutilisable ailleurs ,on parle alors de variable locale. 

Les différents types de variables, leurs modificateurs, et leurs limites

En C, il existe deux familles de variables concernées par ce chapitre : les entiers, et les réels (souvent appelés "nombres en virgule flottante", communément abrégé en "flottants"). Ces deux familles sont découpées en plusieurs tailles, permettant de stocker des nombres plus ou moins grands.

A: Les entiers

1: Ce que dit la norme

Tout d'abord, précisons que l'écriture suivante :

sizeof(type)

renvoie la taille, en octets, que prend une variable du type précisé ; cela pourra nous servir dans la suite de ce chapitre. Je vous encourage d'ailleurs, lorsque vous avez besoin d'utiliser le nombre d'octets que fait un type de variables, à toujours employer sizeof plutôt que la taille que vous pensez que fait une variable. Ainsi, votre code sera plus facilement portable sur d'autres machines. (d'autant plus que la taille, en octet de chaque type n'est pas fixé par la norme !).
Sachez aussi que sizeof n'est pas réservé aux variables entières seulement.
La taille en octets des types de variables entières n'est pas fixé par la norme ANSI, ni par la norme GNU.
La seule chose qui est précisée, c'est que sizeof(char) doit être inférieure ou égale à sizeof(short), qui doit être inférieure à sizeof(int), qui doit être inférieure ou égale à sizeof(long), qui doit elle-même être inférieure ou égale à sizeof(long long), sachant que int correspond généralement au mot-machine.

2: Ce qu'il en est pour nos calculatrices

Maintenant que nous avons vu ce que dit la norme, voyons ce qu'il en est pour nos calculatrices, et ce que signifie les différents types énoncés ci-dessus.

Écriture complète	Écriture concise, généralement utilisée	Taille, avec les options par défaut	Intervalle de valeurs
signed char	char	8 bits, 1 octet	de –128 à 127
unsigned char	unsigned char	8 bits, 1 octet	de 0 à 255
signed short int	short	16 bits, 2 octets	de -32 768 à 32 767
unsigned short int	unsigned short	16 bits, 2 octets	de 0 à 65 535
signed int	int	16 bits, 2 octets	de -32 768 à 32 767
unsigned int	unsigned int	16 bits, 2 octets	de 0 à 65 535
signed long int	long	32 bits, 4 octets	de -2 147 483 648 à 2 147 483 647
unsigned long int	unsigned long	32 bits, 4 octets	de 0 à 4 294 967 296
long long int	long long	64 bits, 8 octets	de -9223372036854775808 à 9223372036854775807
unsigned long long int	unsigned long long	64 bits, 8 octets	de 0 à 18446744073709551615

B: Les flottants

Pour ce qui est des nombres flottants, la norme définit ceci : sizeof(float) doit être inférieure ou égale à sizeof(double), qui doit elle même être inférieure ou égale à sizeof(long double).

2-Les constants:

Définition de constantes

Une constante est une variable dont la valeur est inchangeable lors de l'exécution
d'un programme. En langage C, les constantes sont définies grâce à la directive du préprocesseur #define, qui permet de remplacer toutes les occurrences du mot qui le suit par la valeur immédiatement derrière elle. Par exemple la directive :

#define _Pi 3.1415927

Toutefois, avec cette méthode les constantes ne sont pas typées, il faut donc
utiliser la directive #define avec parcimonie...

Il est ainsi préférable d'utiliser le mot clef const, qui permet de déclarer des constantes typées :

const int dix = 10; 

débutez avec langage c

Un premier programme : «Hello, World!»

1-Introduction:

Pour illustrer les contextes et le cycle de développement présentés ci-avant, on prend un premier exemple de programme très connu : afficher «Hello, World!» à l'écran.
La «mise au point» de ce programme simpliste sert aussi à prendre en main les outils de la chaîne de développement.

2-Codes source

Voici le code source du premier programme    hello.c   sous sa forme «usuelle».

2-1-#include <stdio.h> : 

inclusion des prototypes de sous-programmes de la bibliothèque standard d'entrée-sortie (stdio ou standard input output).D'une manière générale, pour que l'on puisse utiliser les fonctions d'une bibliothèque, il faut que les prototypes (ou en-têtes) de ces fonctions soient parcourus par le pré-processeur . Si cette condition est satisfaite, le pré-processeur «connaît» la liste des paramètres possibles d'une fonction et leurs types. Il peut ensuite contrôler que les appels à ces fonctions sont conformes.
Cet exemple de programme utilise la fonction printf qui appartient à la bibliothèque stdio.h

2-2-int main() { :

début du programme principal.
En C, le programme principal peut être assimilé à une «fonction comme les autres» à qui on peut passer des paramètres (entre les parenthèses) .

L'accolade '{':
 est le délimiteur de début des instructions du programme principal.

2-3-printf ("Hello, World!\n"); : 

appel de la fonction printf de la bibliothèque standard d'entrée-sortie.

Une chaîne de caractères est délimitée par des guillemets et les caractères spécifiques sont précédés par '\'. On parle de caractères d'échappement. Dans cet exemple, '\n' correspond au saut de ligne.
Les instructions sont séparées par le caractère ';'.

2-4- return 0; :

    valeur renvoyée au système d'exploitation (via le Shell) en fin de programme.
La valeur 0 correspond à une sortie «sans erreur» du programme.

3-Compilation & exécution sur Windows

pour savez comment compiler un programme c  visitez la page suivante:

http://geeks-electronique.blogspot.com/2014/11/dev-c-try-with-simple-c-program.html

Pour que le résultat de l'exécution du programme soit «visible», on a ajouté l'instruction system("pause"); qui demande à l'utilisateur d'appuyer sur une touche. Sans cette instruction, le Shell serait refermé dès la fin de l'exécution du programme et le message ne serait pas visible.



bon courage .