Go Down

Topic: Tutoriel Arduino (Read 2 times) previous topic - next topic

yalefe

un petit up pour ce post

car je suis tombé là-dessus

certes c'est en Anglais,  mais c'est très très bien fait

et en constante évolution


http://earthshinedesign.co.uk/ASKManual/

madrang

#6
Jul 23, 2009, 06:19 pm Last Edit: Jul 23, 2009, 06:23 pm by madrang Reason: 1
L'utilité du premier exercice est tout à fait contestable. Nous avons dû écrire plusieurs lignes de code, les compiler, puis exécuter le programme qui en résulte simplement une simple phrase, écrite sur l'écran comme résultat. Il aurait certainement été beaucoup plus rapide de taper la phrase sortie par nous-mêmes. Toutefois, la programmation ne se limite pas seulement à écrire du texte. Pour aller un peu plus loin et devenir capable d'écrire des programmes qui exécutent des tâches utiles qui vont vraiment faire un travail utile, nous avons besoin d'introduire le concept de variable.

Imaginons que vous conserver le numéro 5 dans votre mémoire, et puis je vous demande de mémoriser le numéro 2 en même temps. Vous avez deux valeurs différentes stockés dans votre mémoire. Maintenant, si je vous demande d'ajouter 1 pour le premier numéro, vous devriez conserver les numéros 6 (qui est 5 +1) et 2 dans votre mémoire. Des valeurs que nous pourrions par exemple soustraire et obtenir comme résultat 4.

L'ensemble du processus que vous venez de faire avec votre mental est une comparaison de ce que peut faire un Arduino avec deux variables. Le même processus peut être exprimé en C++ avec le jeu d'instructions suivantes :
Code: [Select]
a = 5;
b = 2;
a = a + 1;
result = a - b;

De toute évidence, il s'agit d'un exemple très simple, puisque nous avons seulement utilisé deux petites valeurs, mais que votre arduino peut en stocker des centaines de ces nombres en même temps et mener des opérations mathématiques avec eux.

Chaque variable a besoin d'un identificateur qui le distingue des autres, par exemple, dans le code précédent les variables identifiants sont a, b et résultat, mais nous pourrions les avoir appelé les noms que nous avons voulu inventer, dans la mesure où ils sont de valables identifiants.

Identifiant :

Un identifiant valide est une séquence d'une ou de plusieurs lettres, chiffres ou caractères de soulignement (_). Ni les espaces, ni signes de ponctuation ou les symboles peuvent faire partie d'un identifiant. Seules les lettres, chiffres et caractères de soulignement simple est valide. En outre, les identificateurs de variables doivent toujours commencer par une lettre. Ils peuvent aussi commencer par un soulignement (_), mais dans certains cas, certain peuvent être réservé aux mots-clés spécifiques ou compilateur externe. En aucun cas, ils peuvent commencer par un chiffre.

Une autre règle que vous avez à prendre en compte lors d'inventer vos propres identifiants est qu'ils ne peuvent pas correspondre à un mot clé du langage C++, ni de votre compilateur spécifiques, qui sont des mots-clés réservés. Les mots clés réservés sont Ex : bool, char, class, const, double, else,   extern, false, float, for, if, int, long, return, short, signed, sizeof, true, void, volatile, while

Très important : Le langage C++ est "case sensitive". Cela signifie que l'identifiant écrit en lettres capitales n'est pas équivalente à une autre avec le même nom mais écrit en minuscules. Ainsi, par exemple, la variable Resultat n'est pas le même que resultat ou la variable RESULTATS. Ces trois variables sont des identifiants.


Les types de données fondamentaux :


Lors de la programmation, nous stockons les variables dans la mémoire de notre arduino, mais l'arduino se doit de savoir quel type de données que nous voulons conserver, car il ne va pas occuper la même quantité de mémoire pour stocker un nombre simple que de stocker une simple lettre ou un grand nombre, et ils ne seront pas interprétés de la même façon.

La mémoire des ordinateurs et du arduino est organisée en octets. Un octet est le montant minimum de la mémoire que nous pouvons gérer en C++. Un octet peut stocker une quantité relativement faible de données: un seul caractère ou d'un petit entier (généralement un entier compris entre 0 et 255). En outre, l'arduino peut manipuler plus de types de données complexes qui des regroupement de plusieurs octets, comme les numéros ou les non-entiers.

Ci-dessous, vous avez un résumé des types de données fondamentales en C++, ainsi que la gamme de valeurs qui peuvent être représentés avec chacun d'eux :

*Les valeurs de la taille et des valeur maximum et minimum dépend du système que le programme est compilé pour. Les valeurs indiquées ci-dessus sont ceux trouvés sur les systèmes Atmel. Mais pour d'autres systèmes, la spécification est que les int a la taille naturelle suggérée par l'architecture du système et les trois types entier char, int et long chacun doit être au moins aussi grande que la précédente, avec char étant toujours 1 octet en taille. La même chose s'applique à la virgule flottante de type float.

Déclaration de variables :

Pour utiliser une variable en C++, il faut d'abord la déclarer en précisant le type de données qui nous voulons qu'elle soit. La syntaxe pour déclarer une nouvelle variable est d'écrire le spécificateur de type de données voulu (comme int, bool, float ...), suivi par un identificateur de variable valide. Par exemple :
Code: [Select]
int a;
float mynumber;

Il s'agit de deux déclarations de variables valides. Le premier déclare une variable de type int avec l'identifiant a. Le second déclare une variable de type float avec l'identifiant MyNumber. Une fois déclarée, l'une des variables MyNumber et a peut être utilisé dans le reste de leur champ d'application dans le programme.

Si vous allez à déclarer plus d'une variable du même type, vous pouvez déclarer la totalité d'entre eux dans une seule déclaration par la séparation de leur identifiant par des virgules. Par exemple :
Code: [Select]
int a, b, c;
Cette déclare trois variables (a, b et c), tous de type int, et a exactement le même sens que :
Code: [Select]
int a;
int b;
int c;

Les entiers de type char, short, int et long peuvent être signées ou non, en fonction de la gamme de numéros nécessaires pour être représentés. Signé peuvent représenter deux types de valeurs positives et négatives, alors que les types non signés peuvent seulement représenter des valeurs positives (et zéro). Cela peut être spécifié en utilisant le spécificateur soit signed ou unsigned le spécificateur avant le nom du type. Par exemple:
Code: [Select]
unsigned int A;
signed int B;

Par défaut, si l'on ne précise pas signé ou non signé la plupart des compilateur prendront le type signé, donc au lieu de la deuxième déclaration ci-dessus on aurait pu écrire :
Code: [Select]
int B;
avec exactement le même sens (avec ou sans le mot-clé signed)

Pour voir a quoi ressemblent des déclarations de variables en action dans un programme, nous allons voir le code de l'exemple sur votre mémoire proposé au début de cette section :
Code: [Select]
// Utiliser des variables

void setup()
{
  Serial.begin(9600);
 delay(1000);
 
 // declarer les variables:
 int a, b;  
 int result;

 // calcul:
 a = 5;
 b = 2;
 a = a + 1;
 result = a - b;

 // envoie le résultat:
 Serial.println(result);
}

void loop(){
}

Ne vous inquiétez pas si quelque chose d'autre que la déclarations de variable semble un peu étrange pour vous. Vous allez voir le reste en détail dans les prochaines sections.

Une variable peut être soit de portée globale ou locale. Une variable globale est une variable déclarée dans le corps principal du code source, en dehors de toutes les fonctions, tandis qu'une variable locale est déclarée dans le corps d'une fonction ou d'un bloc.

Les variables globales peuvent être utiliser à partir de n'importe où dans le code, même à l'intérieur de fonctions.

La portée des variables locales est limitée au bloc ci-joint en accolades ({}), où elles sont déclarées. Par exemple, si elles sont déclarées au début du corps d'une fonction (comme dans la fonction setup()), leur champ d'application est le point entre sa déclaration et la fin de cette fonction. Dans l'exemple ci-dessus, les variables locales déclarer dans setup() ne pourait être accessible à partir de loop().

Initialisation de variables

Lors de la déclaration d'une variable, sa valeur est par défaut
indéterminée. Mais si vous voulez une variable pour stocker une valeur concrète au même moment où elle est déclarée. Pour ce faire, vous pouvez initialiser la variable. Il y a deux façons de le faire en C + +:

La première, connue sous le nom de c-like, se fait en ajoutant un signe égal suivie de la valeur à laquelle la variable sera initialisée:

type identifiant = valeur_initiale;

Par exemple, si nous voulons déclarer une variable int appelée a initialisé d'une valeur de 0 à l'instant où elle est déclarée, nous pouvons écrire :
Code: [Select]
int a = 0;
L'autre façon d'initialiser des variables, connu en tant que constructeur d'initialisation, est fait en joignant la valeur initiale entre parenthèses(()) :

type identifiant(valeur_initiale);

Par exemple :
Code: [Select]
int a(0);
Les deux manières d'initialiser des variables sont valides et équivalent en C++.
Code: [Select]
// Utiliser des variables

void setup()
{
 Serial.begin(9600);
 delay(1000);

 // declarer les variables:
 int a = 5;
 int b(2);  
 int result;

 // calcul:
 a = a + 3;
 result = a - b;

 // envoie le résultat:
 Serial.println(result);
}

void loop(){
}

Go Up