Mise à jour le 08/01/2020.Article expliquant la syntaxe du langage de programmation et l’ensemble des règles d’écriture liées à ce langage .Voici donc les règles qui régissent l’écriture du langage Arduino.
Sommaire :
- La syntaxe du langage .
- Les commentaires .
- La fin des lignes de code .
- La definition et Le contenu d’une fonction.
- Les paramétres d’une fonction .
- Exemple de fonctions et leurs descriptions
- Définition d’une variable numérique.
- Variable du type byte.
- Addition des variables du type byte et int.
- Variable du float ( nombre a virgule flottante ).
- Constantes particulières ( true , false ,HIGH,LOW ).
- Les opérations simples . (addition,soustraction etc .. ).
- Opérateur d’affectation composée .(incrémentation,addition composée …).
- Opérateur de comparaison .( Égal ,Différent , Inférieur, Supérieur , inférieur ou égal , Supérieur ou égal , Affectation ).
- Les chaînes de caractères « string »
- Les conditions ou les instructions de contrôle. ( if , switch ).
- La boucle for .
- Application de la boucle for comptant de 0 à 100 en incrémentant de 1 à chaque passage dans la boucle , avec affichage sur le terminal des valeurs .
- Application de la boucle for comptant de 0 à 100 en incrémentant de 1 à chaque passage dans la boucle puis on décrémente la même valeur de -1 à chaque passage dans la boucle suivante.
- La boucle while .
- Programme la boucle tourne tant que l’expression est vraie dans ce cas pendant 50 passages.
- Comment attendre la validation d’une touche pour continuer l’exécution d’un programme avec while?
- La boucle while et do – while .
- Gestion du temps 4 fonctions sont prévues pour gérer le temps. ( delay , delayMicroseconds ,millis , micro ).
- Pause non bloquante ( fonction millis )
- Fonctions propres à Arduino.
- Configuration du mode d’entrée sortie des broches pinMode.
- Utilisation de la fonction Pullup.
- La mémoire EEPROM.
- Tutoriel vidéo
- Utilisation des boutons poussoirs de type Grove.
- Utilisation de l’interrupteur à led grove 111020049.
- Une application avec la fonction delay pour un clignoteur .
- Programme simulant le battement du cœur par l’incrémentation de la valeur de la luminosité
- Utilisation du capteur de mouvement Sen0202 .Le pilotage d’une tourelle 3 axes.
- Programme d’évaluation d’une rampe d’accélération automatique pour servomoteur à rotation continue.
- Utilisation du moniteur série.
- Utilisation du traceur de courbe ( ou traceur série Arduino )
- Raccourcis clavier pour faciliter votre travail dans l’editeur Arduino.
- Message suite à une erreur de programmation.
- Quelques erreurs à corriger pour les anciens programmes.
- Notes et références
- Retour au menu principal.
Retour au sommaire
La syntaxe du langage |
La syntaxe d’un langage de programmation est l’ensemble des règles d’écriture liées à ce langage .Voici donc les règles qui régissent l’écriture du langage Arduino.
A savoir :
En programmation, Il faut toujours garder à l’esprit ceci. La complexité d’un programme agit directement sur la vitesse de celui-ci. Plus un programme sera compliqué, par exemple en possédant de nombreuses boucles imbriquées, plus le processeur mettra de temps à traiter les informations. En revanche, plus nous utiliserons d’opérations simples ou d’instructions peu complexes, plus les performances du processeur seront à la hausse.
Les commentaires.
Les commentaires sont des lignes de codes qui seront ignorées par le programme .Elles ne servent à rien lors de l’exécution du programme.Il faut savoir qu’il est très important de mettre des commentaires pour l’explication de l’opération effectuée , ou permettre de reprendre le programme les jours suivants ou , simplement pour la maintenance et les modifications futures .
Deux types de syntaxe pour les commentaires.
Sur une ligne syntaxe. ( // )
|
1 |
// Une donnée de type byte est codée sur 8 bits |
Sur plusieurs lignes avec la même syntaxe.
|
1 2 3 4 5 6 7 8 9 10 |
// // ********************************** // * RedOhm * // * * // * variable du type byte * // * et int * // ********************************** // // Une donnée de type byte est codée sur 8 bits // peut donc contenir un nombre compris entre 0 et 255 |
Sur plusieurs lignes avec la syntaxe suivante ( /* ) et se termine par ( */ ).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
/* ********************************** * RedOhm * * * * variable du type byte * * et int * ********************************** Une donnée de type byte est codée sur 8 bits peut donc contenir un nombre compris entre 0 et 255 */ |
Retour au sommaire
–
La fin des lignes de code .
Toute les lignes de code se termine par un point virgule ;
|
1 2 3 4 5 6 7 8 9 10 11 |
// Exemple // je charge la bibliothèque qui permet de gerer // le capteur de geste #include <DFRobot_Gesture.h> // je charge la bibliothèque qui vous permet de communiquer // avec les composants utilisant le protocole I2C #include <Wire.h> // Declare la broche 7 en entier int testPin= 7; |
La definition et Le contenu d’une fonction.
Une fonction est un bloc d’instruction que l’on peut appeler à tout endroit du programme
Le contenu d’une fonction est delimité par des accolades -> { xxxxx xx }
Les paramétres d’une fonction
Les paramétres d’une fonction sont contenus par des parenthéses -> ( cccc xx )
Exemple de fonctions et leurs descriptions :
- analogRead () : Lis la valeur de la broche analogique spécifiée. La carte Arduino contient un convertisseur analogique-numérique 10 bits (8 canaux sur le Mini et Nano, 16 sur le Mega). Cela signifie qu’il va mapper des tensions d’entrée entre 0 et 5 volts dans des valeurs entières comprises entre 0 et 1023. Cela donne une résolution entre les lectures de: 5 volts / 1024 unités ou, 0,0049 volts (4,9 mV) par unité. La plage d’entrée et la résolution peuvent être modifiées en utilisant analogReference ()
- analogReference () : Configure la tension de référence utilisée pour l’entrée analogique (c’est-à-dire la valeur utilisée en haut de la plage d’entrée).
- analogWrite () : Écrit une valeur analogique ( signal PWM ) sur une broche. Peut être utilisé pour allumer une LED à différentes intensités ou conduire un moteur à différentes vitesses. Après un appel analogWrite(), la broche générera une onde carrée régulière du rapport cyclique spécifié jusqu’au prochain appel à analogWrite()(ou à un appel vers digitalRead()ou digitalWrite()) sur la même broche. La fréquence du signal PWM sur la plupart des broches est d’environ 490 Hz. Sur les cartes Uno et similaires, les broches 5 et 6 ont une fréquence d’environ 980 Hz.
Sur la plupart des cartes Arduino (celles avec ATmega168 ou ATmega328P), cette fonction fonctionne sur les broches 3, 5, 6, 9, 10 et 11. Sur l’Arduino Mega, elle fonctionne sur les broches 2 – 13 et 44 – 46. Les cartes avec ATmega8 ne prennent analogWrite()en charge que les broches 9, 10 et 11.
- attachInterrupt () : Le premier paramètre à attacherInterrupt est un numéro d’interruption. Normalement, vous devez utiliser digitalPinToInterrupt (pin) pour traduire la broche numérique réelle en un numéro d’interruption spécifique. Par exemple, si vous vous connectez à la broche 3, utilisez digitalPinToInterrupt (3) comme premier paramètre à attacherInterrupt.
- cos () : Calcule le cosinus d’un angle (en radians). Le résultat sera compris entre -1 et 1.
- delay() : Mets le programme en pause pour la durée (en millisecondes) spécifiée en paramètre. (Il y a 1000 millisecondes par seconde.)
- isControl () : Analyse si un caractère est un caractère de contrôle. Renvoie true si thisChar est un caractère de contrôle.
- millis : Renvoie le nombre de millisecondes écoulées depuis que la carte Arduino a commencé à exécuter le programme en cours. Ce nombre va déborder (revenir à zéro) après environ 50 jours.
- pow () : Calcule la valeur d’un nombre élevé à une puissance. pow () peut être utilisé pour élever un nombre à une puissance fractionnelle. Ceci est utile pour générer un mappage exponentiel des valeurs ou des courbes.
- sq () : Calcule le carré d’un nombre: le nombre multiplié par lui-même.
- sqrt () : Calcule la racine carrée d’un nombre.
Définition d’une variable numérique. |
On peut définir une variable comme une boite ou l’on stock des balles .Une variable est une boite ou l’on stock un nombre ,et comme il existe une multitude de nombres: Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette variable .
Type de variable |
||||
| Type | Type de nombre | Valeur mini et maximale du nombre | Nombre de bits | Nombre d’octets |
| byte | entier | 0 à 255 | 8 bits | 1 octet |
| int | entier | -32768 à 32767 | 16 bits | 2 octets |
| long | entier | –2 147 483 648 à +2 147 483 647 | 32 bits | 4 octets |
| char | entier | -128 à 128 | 8 bits | 1 octets |
| float | décimale | -3.4*10 38 puissance 38 à 3.4*10 puissance 38 | 32 bits | 4 octets |
| double | décimale | -3.4*10 38 puissance 38 à 3.4*10 puissance 38 | 32 bits | 4 octets |
Un microcontrôleur n’est pas un ordinateur. Nous n’avons pas la même capacité de mémoire vive , et la vitesse de la CPU est beaucoup plus lente, 3GHz pour un ordinateur et, 16Mhz pour un microcontrôleur ,il faut donc bien choisir son type de variable .
Syntaxe
int variable = valeur;
- variable : le nom de votre variable de type int
- valeur : la valeur d’initialisation de la variable.
|
1 2 3 4 5 |
// // // exemple d’initialisation d'une variable // int valeur_rotation = 0; |
A savoir :
-
- Une variable déclarée sans aucune valeur affectée est initialisée avec la valeur zéro.
- La valeur prise par une variable peut être modifiée au cours du programme .
- Les constantes entières sont par défaut de type int.
- Choisir le type de variables assez grand pour permettre de stocker un plus grand résultat suite aux calculs.
- Les variables de type float ont seulement 6 à 7 chiffres de précision. Ceci concerne le nombre total de chiffres, pas seulement le nombre à droite de la virgule. Pour avoir un résultat en float , la déclaration n’est pas suffisante . Il faut aussi qu’un terme de l’opération soit exprimé sous forme décimale,( Voir l’exemple )
Exemple de programme :
a). Variable du type byte
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
// // // ********************************** // * RedOhm * // * * // * variable du type byte * // ********************************** // // Une donnée de type byte est codée sur 8 bits // peut donc contenir un nombre compris entre 0 et 255 byte variable_a = 15; byte variable_b = 12; byte variable_resultat =0; void setup() { // initialise la connexion série à 9600 bauds // IMPORTANT : régler le terminal côté PC avec la même valeur de transmission Serial.begin(9600); } void loop() { // addition des variables variable_resultat= variable_a+variable_b; // affichage du texte Serial.println("le resultat est ->"); // Affichage du resultat sur le terminal Serial.println(variable_resultat); delay (1000); } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
// // // ********************************** // * RedOhm * // * * // * variable du type byte * // * et int * // ********************************** // // Une donnée de type byte est codée sur 8 bits // peut donc contenir un nombre compris entre 0 et 255 byte variable_a = 127; byte variable_b = 255; // Pour le resultat de l'operation on choisira une variable // du type int puisque nous dépassons la valeur 255 int variable_resultat =0; void setup() { // initialise la connexion série à 9600 bauds // IMPORTANT : régler le terminal côté PC avec la même valeur de transmission Serial.begin(9600); } void loop() { // addition des variables variable_resultat= variable_a+variable_b; // affichage du texte Serial.println("le resultat est ->"); // Affichage du resultat sur le terminal Serial.println(variable_resultat); delay (1000); } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 |
/* * * * * *********************************************** * RedOhm * * * * Exemple de calcul sur les nombres decimaux * * et affichage du resultat sur le terminal * * * * variable du type float * * float = nombre à virgule flottante * ************************************************* */ //declaration des variables int a ; float b; float c; void setup() { // initialise la connexion série à 9600 bauds // IMPORTANT : régler le terminal côté PC avec // la même valeur de transmission Serial.begin(9600); // Affectation des operations pour chaque variable a=3/2; b=3/2; c=3/2.0; // affichage du texte Serial.println ( " A savoir : "); Serial.println ("Pour avoir un resultat en virgule flottante"); Serial.println ("(float) Il faut aussi qu'un des terme de "); Serial.println ("l'operation soit exprime sous forme decimale ."); Serial.println (" "); Serial.print ("Pour a=3/2 le resultat pour a ="); Serial.println (a); Serial.print ("Pour b=3/2 le resultat pour b ="); Serial.println (b); Serial.println (" "); Serial.println("Seul cette version fonctionne"); Serial.println (" "); Serial.print ("Pour c=3/2.0 le resultat pour c ="); Serial.println (c); } void loop() { // vide } |
Retour au sommaire
Constantes particulière . |
– true et false
Données logiques ( boolean ) qui ne peut contenir que deux valeurs true ( vrai en français ) ou false ( faux en français ) .Elle occupe un octet en mémoire .
– HIGH et LOW
– INPUT et OUTPUT
Les opérations simple . |
Les opérateur arithmétique du C sur Arduino ont la même signification que leurs équivalents en mathématiques:
-L’addition [ + ]
-La soustraction [ – ]
-La multiplication [ * ]
-La division [ / ]
-Modulo [ % ]
Exemple de programme :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// declaration des differentes variables int valeur1= 25; int valeur2= 40; int sommes=0; void setup() { } void loop() { // addition des 2 valeurs sommes = valeur1+valeur2; } |
Opérateur d’affectation composée . |
Le langage C permet d’abréger l’écriture de certaine opération arithmétique comme :
| ++ | incrémentation | x++ équivaut à x=x+1 |
| — | décrémentation | x– équivaut à x=x-1 |
| += | addition composée | x+=y équivaut à x=x+y |
| -= | soustraction composée | x-=y équivaut à x=x*y |
| *= | multiplication composée | x*=y équivaut à x=x*y |
| /= | division composée | x/=y équivaut x=x/y |
Opérateur de comparaison . |
Les opérateur de comparaison du C sur Arduino ont la même équivalence que leurs homologues en mathématique .
- Égal à : [ == ]
- Différent de [ != ]
- Inférieur : [ < ]
- Supérieur : [ > ]
- inférieur ou égal : [ <= ]
- Supérieur ou égal : [ >= ]
- Affectation : [ = ]
Les conditions ou les instructions de contrôle . (IF , switch) |
Le langage Arduino possède plusieurs instructions de contrôle comme
- if
if qui est utilisé avec un opérateur de comparaison vérifie si une certaine condition a été atteinte, telle qu’une entrée étant supérieur à un certain nombre comme ci-dessous.
Exemple de programme :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// declaration des differentes variables int valeur1= 60; void setup() { } void loop() { if (valeur1> 50) { // Faire quelque chose ici } } |
- switch
Comme if/else , l’instruction switch permet de réaliser des branchements conditionnels .L’instruction switch teste la valeur d’une variable par rapport à différentes valeurs.
switch ( variable à teste )
case 1: // option 1
// exécution si la condition est remplie
case 2: // option 2
// exécution si la condition est remplie
Exemple de programme : ( en cours )
Retour au sommaire
La boucle for . |
Présentation des boucles for
Une boucle est une instruction qui permet de répéter un morceau de programme.Arduino nous offre 3 types de boucles différentes qui correspondent en général à l’ensemble de nos besoins.
C’est trois boucles sont : la boucle for , la boucle while , la boucle do / while
-
La boucle for
Syntaxe de la boucle for
for (initialisation ; condition ; incrément )
{
code exécutées dans la boucle ;
}
Exemple de programme pour la boucle du type for :
a) Application de la boucle for comptant de 0 à 100 en incrémentant de 1 à chaque passage dans la boucle , avec affichage sur le terminal des valeurs .
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
/* * * Application de la boucle for * comptant de 0 a 100 en incrementant de 1 * a chaque passage dans la boucle * */ // Declare la variable X // Rappel sur la fonction d'une variable :On peut définir une variable comme // une boite ou l’on stock des balles .Une variable est une boite ou // l’on stock un nombre ,et comme il existe une multitude de nombres: // Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette // variable . int x; // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécuter une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties void setup() { // initialisation de la connexion série // IMPORTANT : le terminal côté PC doit être réglé sur la même valeur. Serial.begin(9600); } // Le programme principal s’exécute par une boucle infinie appelée Loop () void loop() { // Boucle comptant de 0 a 100 avec un increment de 1 // for (initialisation ; condition ; increment) // entre crochet { instructions executees dans la boucle } for (x=0;x<100;x++) { // Affichage du texte -> valeur de x = Serial.print("valeur de x = "); // Affichage de la valeur de x Serial.println(x); } } |
b) Application de la boucle for comptant de 0 à 100 en incrémentant de 1 à chaque passage dans la boucle puis on décrémente la même valeur de -1 à chaque passage dans la boucle suivante.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 |
/* * * Application de la boucle for * comptant de 0 a 100 en incrementant de 1 * a chaque passage dans la boucle puis on * decremmente la meme valeur de -1 a chaque passage * dans la boucle suivante * */ // Declare la variable X // Rappel sur la fonction d'une variable :On peut définir une variable comme // une boite ou l’on stock des balles .Une variable est une boite ou // l’on stock un nombre ,et comme il existe une multitude de nombres: // Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette // variable . int x; // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécuter une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties void setup() { // initialisation de la connexion série // IMPORTANT : le terminal côté PC doit être réglé sur la même valeur. Serial.begin(9600); } // Le programme principal s’exécute par une boucle infinie appelée Loop () void loop() { // Boucle comptant de 0 a 100 avec un increment de 1 // for (initialisation ; condition ; increment) // entre crochet { instructions executees dans la boucle } for (x=0;x<100;x++) { // Affichage du texte -> valeur de x = Serial.print("valeur de x = "); // Affichage de la valeur de x Serial.println(x); //pause de 100 ms soit 0.1 secondes delay (100); } // Boucle comptant de 100 a 0 en decrementant de 1 // for (initialisation ; condition ; decrementant ) // entre crochet { instructions executees dans la boucle } for (x=100;x>0;x--) { // Affichage du texte -> valeur de x = Serial.print("valeur de x = "); // Affichage de la valeur de x Serial.println(x); //pause de 100 ms soit 0.1 secondes delay (100); } |
La boucle While et do-while |
La boucle s’exécute tant que l’expression est vrai .
A savoir : L’expression est testée avant que ne soit exécutée la boucle .Si elle est fausse la boucle ne sera jamais exécutée .
Syntaxe de la boucle while .
int x=0 ;
while (expression ){
code exécutées dans la boucle ;
}
Exemple de programme pour la boucle du type while :
a) Programme pour le fonctionnement de la boucle while . La boucle tourne tant que l’expression est vrai dans ce cas pendant 50 passages .
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
/* * * boucle while RedOhm 001 * Cette boucle tourne tant que l'expression est vrai * dans ce cas pendant 50 passages */ void setup() { // initialisation de la connexion série // IMPORTANT : le terminal côté PC doit être réglé sur la même valeur. Serial.begin(9600); } // Le programme principal s’exécute par une boucle infinie appelée Loop () void loop() { byte x=1; while (x<50) { // Affichage du texte -> valeur de x = Serial.print("valeur de x = "); // Affichage de la valeur de x Serial.println(x); //pause de 100 ms soit 0.1 secondes delay (100); x++; } } |
Gestion du temps . |
1) Présentation .
4 fonctions sont prévues pour gérer le temps ( pour créer des temporisations, des bases de temps pour des incrémentations etc …. ) .Deux de ces fonctions bloquent le programme qui correspondent au délai fixé dans le code ,le microcontrôleur ne s’arrête pas de fonctionner mais ne fait rien d’autre de consommer du temps .Ce sont les codes delay() et delayMicroseconds(). Enfin 2 autres fonctions existent, elles ont pour but de donner le temps qui s’est écoulé depuis le démarrage du programme .Ces deux solutions peuvent être utilisées comme temporisation ou pause non bloquantes du programme .C’est la fonction millis() qui est exprimée en millisecondes ( valeur maximum du compteur une cinquantaine de jours ) et micro() exprimé en microsecondes la valeur max du compteur étant pour cette dernière 70 minutes .
- delay()
Syntaxe de la fonction delay() et utilisation .
Réalise un arrêt dans l’exécution du programme pour la durée (en millisecondes)
Voici une application avec la fonction delay pour un clignoteur
- millis()
Syntaxe de la fonction millis() et utilisation .( Pause dite non bloquante )
unsigned long debut ;
debut = millis();
while(millis()-debut<1000 )
Exemples : Voici un programme qui possède 2 bases de temps différentes une de 1 seconde et l’autre de 5 secondes dans la première on incrémente une valeur de 1 a chaque passage et l’autre , on incrémentera de 5 a chaque passage .
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 |
/* * nom du programme -> * Pause dite non bloquante 001 * * * Voici un programme qui possede 2 bases * de temps differentes une de 1 seconde et * l'autre de 5 secondes dans la premiere on * incremente une valeur de 1 a chaque * passage et l'autre , on incrementera de 5 * a chaque passage * * RedOhm * le 07/09/2016 * */ // Declaration des variables demarrage et demarrage1 // unsigned long-> déclare une variable de type long non signé unsigned long demarrage = millis(); unsigned long demarrage1 = millis(); // Declaration des variables valeur et valeur1 // int -> declare une variable du type int (pour integer, entier en anglais) // elles peuvent stocker des valeurs de - 32 768 à 32 767 int valeur ; int valeur1 ; /* * Un programme Arduino doit impérativement contenir cette fonction * Elle ne sera exécuter une seule fois au démarrage du microcontroleur * Elle sert à configurer globalement les entrées sorties * */ void setup() { // initialisation de la connexion série // IMPORTANT : la fenêtre terminal côté PC doit être réglée sur la même valeur. Serial.begin(9600); } // Le programme principal s’exécute par une boucle infinie appelée Loop () void loop() { // valeur de la base de temps 1 -> 1000ms soit 1 seconde // la ligne if effectue la difference entre le temps actuel et le // temps de debut de boucle .Cette derniere n'est interrompue que lorsque // cette difference = 1000 millisecondes soit 1 seconde if (millis()-demarrage>1000) { demarrage=millis(); // incrementation de la variable valeur de 1 soit -> valeur = valeur+1 valeur++; // affiche sur le terminal le texte ci-dessous // valeur de la premiere base de temps -------------> Serial.print("valeur de la premiere base de temps ------------->"); // affiche sur le terminal la valeur de la base de temps -> demarrage Serial.println(demarrage); // affiche sur le terminal le texte ci-dessous Serial.print("valeur de l'incrementation de la premiere base de temps ---------------->"); // affiche la valeur incrementée Serial.println(valeur); // a vous de coder ce que vous voulez } // valeur de la base de temps 2 -> 5000ms soit 5 secondes // la ligne if effectue la difference entre le temps actuel et le // temps de debut de boucle .Cette derniere n'est interrompue que lorsque // cette difference = 5000 millisecondes soit 5 secondes if (millis()-demarrage1>5000) { demarrage1=millis(); // incrementation de la variable valeur1 de 5 soit -> valeur1 = valeur1+5 valeur1=valeur1+5; // affiche sur le terminal le texte ci-dessous Serial.print("valeur de la base de temps 2 -->"); // affiche sur le terminal la valeur de la base de temps -> demarrage1 Serial.println(demarrage1); // affiche sur le terminal le texte ci-dessous Serial.print("valeur de l'incrementation de la base 2 -->"); // affiche la valeur incrementée Serial.println(valeur1); // a vous de coder ce que vous voulez } } |
Programme ci-dessus à telecharger.
Téléchargement -> pause_dite_non_bloquante_001
- micros()
Syntaxe de la fonction micros()
unsigned long temps ;
temps=micros();
while(micros()-temps<1000)
Cette fonction est proche de la précédente. Elle a pour but de donner comme résultat le temps qui s’est écoulé depuis le démarrage du programme mais exprimé en microsecondes .
A savoir : elle ne peut atteindre un maximum de 70 minute
Retour au sommaire
Fonctions propres à Arduino |
Configuration du mode d’entrée sortie des broches pinMode
Les broches numériques des cartes Arduino sont par défaut configurées en entrée au démarrage, et par conséquent elles ne nécessitent pas d’être explicitement déclarées en ENTREE à l’aide de l’instruction pinMode().
La broche à configurer doit être précisée dans les paramètres de la fonction sous la forme d’un nombre .Celui-ci est représenté par un numéro qui est gravé sur la carte .
Arduino Uno exemple de marquage de broche
Ci-dessous un tableau récapitulatif des cartes avec leurs nombres d ‘entrées sorties .
| Arduino Micro | 20 entrées ou sorties(dont 7 fournissent la sortie PWM ) |
| Genuino MICRO (Hors USA) | 20 entrées ou sorties(dont 7 fournissent la sortie PWM ) |
| Arduino Uno | 20 entrées ou sorties |
| Arduino ZERO ( USA) | 20 entrées ou sorties |
| Genuino ZERO (Hors USA) | 20 entrées ou sorties |
| Arduino LEONARDO | 20 entrées ou sorties(dont 6 fournissent la sortie PWM) |
| Arduino Mega 2560 | 54 entrées ou sorties (dont 14 fournissent la sortie PWM) |
| Arduino DUE | 54 entrées ou sorties (dont 12 fournissent la sortie PWM) |
| Arduino Yun | 20 broches d’E/S dont (dont 6 fournissent la sortie PWM |
| Arduino M0 | 14 broches d’E/S dont (dont 12 fournissent la sortie PWM) |
Exemple d’utilisation de la fonction pinMode()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// // Exemple d'utilisation de la fonction // pinMode ( ) // On affecte un numéro de broche à une variable, // dans l’exemple ci-dessous la variable bouton int bouton = 2; void setup() { // initialise la broche comme entrée: pinMode(bouton, INPUT); } void loop() { } |
.
Retour au sommaire
Entrée Pullup
1) Présentation .
Avec cette fonction, il est possible d’utiliser un interrupteur ou un bouton-poussoir sans résistance de tirage ou même de piloter une entrée avec un simple fils sans pour autant créer des états électriques parasites .
Principe de la résistance pullup . En utilisant la commande pinMode() et intégrant la fonction INPUT_PULLUP, il est possible d’utiliser un interrupteur ou simplement un fil pour piloter une entrée. La seule difficulté c’est de bien intégrer que le comportement du mode de l’entrée fonctionnera en inverse , voir l’exemple 29_09–001
.
Retour au sommaire2) Syntaxe de la fonction pullup
pinMode(2,INPUT_PULLUP);
.
3) Programme d’exemple d’utilisation de la fonction pullup
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
/* * * * RedOhm * le 29/09/2016 * Herve Mazelin * * Programme exemple code : 29_09-001 * Rappel: * Principe de la résistance pullup . En utilisant la commande * pinMode() et intégrant la fonction INPUT_PULLUP, il est possible * d’utiliser un interrupteur ou simplement un fil pour piloter une * entrée. La seule difficulté c’est de bien intégrer que le comportement * du mode de l’entrée fonctionnera en inverse */ // fil sur l'entree 14 int fil_14=14 ; // variable pour enregistrer l'etat de l'entrée int entree_14 ; // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécuter une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties void setup() { // initialise la connexion série à 9600 bauds // IMPORTANT : régler le terminal côté PC avec la même valeur de transmission Serial.begin(9600); //Initialise la broche numérique 14 comme entrée avec la résistance //interne pull-up activé: pinMode (fil_14,INPUT_PULLUP); } // Le programme principal s’exécute par une boucle infinie appelée Loop () void loop() { // Lit l"état de la broche 14 en entrée numérique, et renvoie la valeur // dans la variable entree_14 entree_14=digitalRead(fil_14); // effectue le teste if (entree_14==HIGH) { // affiche la valeur de la variable sur votre ecran suivant le teste Serial.println("Etat de l'entree --->"); Serial.println(entree_14); } else { Serial.println("Etat de l'entree --->"); Serial.println(entree_14); } } |
Programme ci-dessus à télécharger.
Téléchargement ->entree_avec_input_pullup
Moniteur série |
Affichage de nombres décimaux non entier sur le moniteur série.
Rappel: Un nombre décimal entier s’écrit sous forme décimale sans virgule.
Exemple : 888 , 1254 , 5 etc.
Rappel: Un nombre décimal non entier, s’écrit sous la forme suivante
Exemple : 172.3 , 6.254 , 15.6654 etc.
Syntaxe pour l’affichage : Serial.print(données, nombre de chiffres après la virgule )
A savoir : à défaut de paramètres le chiffre s’affichera avec 2 décimales derrière la virgule.
Pour les nombres à virgules (float), le paramètre précise le nombre de chiffres après la virgule à utiliser.
Exemple d’affichage :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
/* * * * RedOhm * * Affichage sur la moniteur serie d'un nombre a virgule * * 30/05/2017 * H.Mazelin */ // déclaration d'une variable à virgule appelée nombre // // float -> Déclare des variables de type "virgule-flottante" // en faite des nombres à virgules float nombre; // -------------------------------------------------------------------- // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécuter une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties // // ou un morceau de code une seule fois comme ci-dessous // -------------------------------------------------------------------- void setup() { // initialisation de la connexion série // IMPORTANT : le terminal côté PC doit être réglé sur la même valeur. Serial.begin (9600); // Affectation d'une valeur à la variable nombre nombre = 2.541285; // ***************************************************************** // affiche la valeur de la variable de depart nombre sur le moniteur Serial.print("- affiche la valeur de la variable de depart -> " ); Serial.print("Serial.println(nombre,6); ---> " ); Serial.print(nombre,6); Serial.println (" "); Serial.println (" ** "); // une petite tempo de 1 seconde ( 1000 ms = 1s ) delay (1000); // ***************************************************************** // affiche la valeur entiere arrondi Serial.print("- affiche la valeur entiere arrondi de la meme variable " ); Serial.print(" avec la fonction -> " ); Serial.print(" Serial.println(nombre,0); ---> " ); // Pour les nombres à virgules (float), le paramètre précise le nombre de // décimales après la virgule à utiliser. // Exemple : Serial.print(nombre,parametre ); Serial.print(nombre,0); Serial.println (" "); Serial.println (" ** "); // une petite tempo de 1 seconde ( 1000 ms = 1s ) delay (1000); // ***************************************************************** // affiche la valeur de la meme variable mais avec // 2 chiffres derriere la virgule Serial.print("- affiche la valeur de la meme variable mais avec 2 "); Serial.print(" avec la fonction -> Serial.println(nombre,2); ---> " ); // Pour les nombres à virgules (float), le paramètre précise le nombre // de décimales après la virgule à utiliser. // Exemple : Serial.print(nombre,parametre ); Serial.print(nombre,2); // la valeur est arrondi quand meme Serial.println (" la valeur est arrondi quand meme "); Serial.println (" ** "); // une petite tempo de 1 seconde ( 1000 ms = 1s ) delay (1000); // **************************************************************** // affiche la valeur de la meme variable mais avec 3 chiffres // derriere la virgule Serial.print("- affiche la valeur de la meme variable mais avec " ); Serial.print(" 3 chiffres derriere la virgule "); Serial.print(" avec la fonction -> Serial.println(nombre,3); ---> " ); // Pour les nombres à virgules (float), le paramètre précise le nombre // de décimales après la virgule à utiliser. // Exemple : Serial.print(nombre,parametre ); Serial.print(nombre,3); // la valeur est arrondi mais sur le troisieme chiffre Serial.println (" la valeur est arrondi mais sur le troisieme chiffre"); Serial.println (" ** "); // une petite tempo de 1 seconde ( 1000 ms = 1s ) delay (1000); } // ---------------------------------------------------------------------- // Le programme principal s’exécute par une boucle infinie appelée Loop () // ---------------------------------------------------------------------- void loop() { } |
Copie d’écran du résultat du code ( cliquez sur l’image pour agrandir )
Affichage de nombres décimaux non entier sur le moniteur série.–
.
Retour au sommaire
Raccourcis clavier pour faciliter votre travail dans l’editeur Arduino |
Ctrl+C, Ctrl+X, Ctrl+V
Ctrl+C est utilisé pour copier, Ctrl+X pour couper et Ctrl+V pour coller un élément sélectionné. Il peut s’agir d’une partie de texte, d’un fichier ou d’un dossier.
Copier un élément laisse l’original intact et en effectue une copie dans le “presse-papier” qui peut être collée (autrement dit placée) à l’endroit désiré avec le raccourci Ctrl+V.
Ctrl+X va couper l’élément, c’est-à-dire qu’il retire la version originale et la déplace dans le presse-papier pour être collée ailleurs, également avec Ctrl+V.
Ctrl+Z et Ctrl+Y
Ctrl+Z va annuler la dernière action qui a été effectuée et Ctrl+Y va la refaire.
Par exemple, disons que tu rédiges un texte et que tu n’es pas satisfait des derniers mots. Tu peux les annuler en utilisant Ctrl+Z à quelques reprises. Si tu changes d’idée et veux revoir les mots ou la phrase annulée, Ctrl+Y te permet de revenir en arrière.
Ces deux raccourcis sont un peu comme une façon de te déplacer d’avant en arrière dans l’historique des changements que tu apportes à un fichier (que ce soit du texte ou, par exemple, des retouches sur une image)
Ctrl+S
Ce raccourci permet de sauvegarder rapidement un document. Peu importe qu’on soit sur Word, Photoshop ou autre, c’est le raccourci que la très grande majorité des programmes reconnaissent pour la sauvegarde rapide.
Ctrl+P
Utiliser le raccourci Ctrl+P va ouvrir la fenêtre d’impression du document en cours. C’est l’équivalent, mais en plus rapide, d’aller sélectionner l’onglet “fichier” et l’option “imprimer”.
Ctrl+F
Ctrl+F va ouvrir la barre de recherche d’à peu près n’importe quel programme/application.
C’est très utile, par exemple, si tu veux chercher une information précise dans un long texte. En utilisant ce raccourci, tu peux entrer un mot clef et le rechercher rapidement dans la page ou le document.
C’est aussi très pratique pour la correction ou l’uniformisation de textes. Disons que tu écris un texte et que tu te rends compte qu’un mot n’est pas écrit avec une graphie uniforme au travers du document. En utilisant le raccourci Ctrl+F, tu peux rechercher le mot en question pour passer en revue les endroits où il apparaît dans le texte.
Retour au sommaire.
Message suite à une erreur de programmation |
Erreurs trouvées : exit status 1
missing terminating » character
Dans notre cas,l’IDE arduino nous signale par le bandeau où se trouve l’erreur. Vous pourrez remarquer que nous ouvrons les guillemets mais nous ne les fermons pas. Quand on écrit une chaîne alphanumérique,on doit ouvrir et fermer les guillemets.
.
Quelques erreurs à corriger pour les anciens programmes. |
.
Erreurs trouvées : In file included from essai.cpp:1:
/essai.h:5:22: error: WProgram.h: No such file or directory
WProgram.h a été remplacé par Arduino.h, il faut donc mettre à jour tous vos programmes. Il faut écrire un code qui teste la version pour être compatible avec plusieurs environnements .
|
1 2 3 4 5 6 7 8 9 10 11 12 |
// // // correctif #if defined(ARDUINO) && ARDUINO >= 100 #include "Arduino.h" #else #include "WProgram.h" #endif // // |
.
Erreurs trouvées : As of Arduino 1.0, the Wire.send() function was renamed to Wire.write() for con
Dans ce cas c’est très simple, puisque Arduino nous explique la cause et la solution. Mais ce n’est pas si simple, car la bibliothèque I2C (TwoWire ou Wire) hérite de Print, et il y a donc ambiguité lorsqu’on écrit :
Wire.write(0x09);
Il faut alors écrire :Wire.write((byte)0x09);
.
Retour au sommaire
Notes et références |
Fournisseur :
Information technique :
- Le site Pobot pour quelques articles dans la rubrique erreur
.
Retour au sommaire.
Un probléme que faire ? |
.
Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .