Main

Toutes les instructions de la référence "mini" sur une seule page


STRUCTURE


1.  Fonctions de base


1.1  setup()


Description

La fonction setup() est appelée au démarrage du programme. Cette fonction est utilisée pour initialiser les variables, le sens des broches, les librairies utilisées. La fonction setup n'est exécutée qu'une seule fois, après chaque mise sous tension ou reset (réinitialisation) de la carte Arduino.

Syntaxe

void setup()
{

}

Exemple


int buttonPin = 3; // déclaration d'une variable globale

void setup() // fonction setup - début de l'exécution du programme
{
  Serial.begin(9600);
  pinMode(buttonPin, INPUT);
}

void loop() // fonction loop - est exécutée en boucle
               // une fois que la fonction setup a été exécutée
{
  // ...
}
 

Commentaires utilisateurs

La fonction setup() , même vide, est obligatoire dans tout programme Arduino.

Pour comprendre : les habitués du C seront surpris de ne pas trouver la classique fonction main() obligatoire dans tout programme C. En fait, la fonction setup() et la fonction loop() sont implémentées au sein de la fonction main() (Voir dans le répertoire arduino le fichier \hardware\cores\arduino\main.cxx) qui est appelée en premier lors de l'exécution de tout programme en C, langage sur lequel est basé le langage Arduino.


1.2  loop()


Description

Après avoir créé une fonction setup(), qui initialise et fixe les valeurs de démarrage du programme, la fonction loop () (boucle en anglais) fait exactement ce que son nom suggère et s'exécute en boucle sans fin, permettant à votre programme de s'exécuter et de répondre. Utiliser cette fonction pour contrôler activement la carte Arduino.

Syntaxe

void loop()
{

}

Exemple


int buttonPin = 3;

// la fonction setup initialise la communication série
// et une broche utilisée avec un bouton poussoir

void setup()
{
  Serial.begin(9600);
  pinMode(buttonPin, INPUT);
}

// la fonction loop teste l'état du bouton à chaque passage
// et envoie au PC une lettre H si il est appuyé, L sinon.

void loop()
{
  if (digitalRead(buttonPin) == HIGH)
    Serial.write('H');
  else
    Serial.write('L');

  delay(1000);
}
 

Commentaires utilisateurs

La fonction loop() est obligatoire, même vide, dans tout programme.

Pour comprendre : les habitués du C seront surpris de ne pas trouver la classique fonction main() obligatoire dans tout programme C. En fait, la fonction setup() et la fonction loop() sont implémentées au sein de la fonction main() (Voir dans le répertoire arduino le fichier \hardware\cores\arduino\main.cxx) qui est appelée en premier lors de l'exécution de tout programme en C, langage sur lequel est basé le langage Arduino.

2.  Syntaxe de base


3.  ; point-virgule


3.1  Description

Utilisé (et obligatoire) à la fin d'une instruction.

3.2  Exemple


int a = 13; // le point virgule indique la fin de l'instruction

3.3  Conseil

Oublier le point virgule en fin de ligne donnera une erreur de compilation. Le texte d'erreur pourra être évident, et se référer à un point-virgule oublié, mais parfois çà sera moins évident. Si une erreur de compilation incompréhensible et apparemment illogique survient, la première chose à vérifier est l'oubli d'un point-virgule, dans le voisinage immédiat, précédent la ligne à laquelle le compilateur signale le problème.

3.4  Commentaires

Pour le compilateur, les sauts de lignes n'ont pas de signification : c'est le point virgule qui marque la fin de ligne.

En cas d'erreur de compilation, le plus souvent la dernière instruction précédent la ligne en cause, qui est parfois plusieurs lignes plus haut en raison des commentaires.

A noter que l'on peut séparer plusieurs instructions sur une même ligne à l'aide de virgule, le point-virgule devant être alors mis à la fin, selon :

digitalWrite(pin1,HIGH), digitalWrite(pin2,LOW), digitalWrite(pin3,HIGH); // plusieurs instructions à la suite

3.5  Commentaires utilisateurs

Aucun commentaire


3.6  {} Accolades


Description

Les accolades sont un élément majeur de la programmation en langage C. Elles sont utilisées dans plusieurs constructions différentes, décrites ci-dessous, et cela peut parfois entraîner la confusion chez les débutants.

Toute ouverture d'une accolade d'ouverture "{" doit obligatoirement être accompagnée dans le code d'une accolade de fermeture "}" correspondante. On dit souvent qu'il faut que les accolades soient équilibrées (càd autant de"{" que de "}"). L'EDI ( Environnement de Développement Intégré = l'éditeur de programmes) Arduino inclut une fonctionnalité pratique pour vérifier la correspondance des accolades entre elles. Il suffit de sélectionner une accolade, ou même de cliquer juste après l'accolade, et son compagnon logique sera mis en surbrillance. Actuellement cette fonctionnalité bogue légèrement à savoir que l'IDE prend souvent en compte de façon incorrecte les accolades incluses dans les commentaires.

Les programmeurs débutants, et les programmeurs passant du BASIC au langage C trouvent souvent que l'utilisation des accolades porte à la confusion ou est intimidant. Après tout, les mêmes accolades remplace aussi bien l'instruction RETURN dans une routine (ou fonction), que l'instruction ENDIF dans un test de condition ou encore l'instruction NEXT dans une boucle FOR.

En raison de l'utilisation variée des accolades, c'est bonne habitude à prendre que de fermer systématiquement l'accolade avec "}" immédiatement après l'avoir ouverte avec "{" quand on insère une structure qui requiert des accolades. Insérer ensuite quelques retours à la ligne entre les deux accolades et commencer à y insérer vos instructions. Ainsi, vos accolades (et votre attitude...) ne seront jamais déséquilibrées.

Des accolades déséquilibrées (càd non symétriques, chaque "{" n'étant pas accompagnée de son pendant "}") peuvent donner lieu à des messages d'erreur de compilation énigmatiques et incompréhensibles, difficile à résoudre dans de long programme. A cause de leur utilisation très variées, les accolades sont incroyablement importante dans la syntaxe d'un programme et déplacer une accolade d'une ou deux lignes peuvent souvent perturber profondément la signification d'un programme.

Les principales utilisation des accolades

Fonctions


void myfunction(datatype argument){ // ouverture de la fonction
    // vos instructions ici
  } // fermeture de la fonction

Boucles



while (boolean expression)
  { // accolade d'ouverture du code de la boucle while - noter que le saut à la ligne n'a pas de valeur ici
     // vos instructions ici
  } // fermeture de la boucle

  do
  { // accolade d'ouverture du code de la boucle do
     // vos instructions
  } while (boolean expression); // fermeture de la boucle

  for (initialisation; termination condition; incrementing expr)
  { // ouverture du code de la boucle for
    //instructions
  } // fermeture de la boucle
 

Conditions



  if (boolean expression)
  { // ouverture du code de la condition if
     // vos instructions
  } // fermeture du code de la condition if

  else if (boolean expression)
  { // ouverture du code de l'instruction else if
     // vos instructions
  } // fermeture du code de l'instruction else if

  else
  { // ouverture du code de l'instruction else
     // vos instructions
  } // fermeture du code de l'instruction else
 

Commentaires utilisateurs

Aucun commentaire


3.7  // et /* */ Commentaires


Description

Les commentaires sont des lignes de texte incluses dans le programme et qui ont pour but de vous informer vous-même ou les autres de la façon dont le programme fonctionne. Ces lignes ajoutées sont ignorées par le compilateur, et ne sont pas programmées dans le microcontrôleur, et par conséquent elles ne n'occupent aucun espace mémoire dans le microcontrôleur ATmega.

Les commentaires ont pour seul but de vous aider à comprendre (ou à vous rappeler) comment votre programme fonctionne ou d'en informer les autres. Il y a deux façons de créer des lignes de commentaires :

Syntaxe



// Commentaire sur une seule ligne : tout ce qui suit les "//" est ignoré par le compilateur
 



/* Commentaire multilignes :
    Tout le texte compris...
    ... entre le /* et le */

    ... est ignoré par le compilateur */
 

Exemple



 x = 5;  // Commentaire sur une seule ligne : tout ce qui suit les "//" est ignoré par le compilateur


/* Ceci est un commentaire multiligne - utilisez le pour mettre en commentaire des blocs entiers de texte

if (gwb == 0){   // ligne de commentaire est possible à l'intérieur du commentaire multiligne
x = 3;           /* mais un autre bloc de commentaire multilignes n'est pas autorisé */

}
// Ne pas oublier de fermer les commentaires multilignes. Le /* doit avoir son */ associé

*/ // fermeture du commentaire multiligne
 

Conseil

Quand vous essayez ou mettez au point votre code, mettre en commentaire des parties ou des lignes de votre programme est une façon pratique de retirer du code les lignes qui peuvent être la source d'une erreur. Ces lignes restent dans le code (pas besoin de les réécrire...), mais en les passant en commentaire, le compilateur les ignore. Cette technique est très pratique et utile lorsque vous essayez de localiser un problème, ou quand un programme refuse de compiler et que le message d'erreur de compilation est énigmatique ou peu informatif.

Commentaires utilisateurs

Aucun commentaire

4.  Opérateurs arithmétiques

4.1  = opérateur d'assignement (signe égal unique)


Description

Stocke la valeur à droite du signe égal dans la variable à gauche du signe égal.

Le signe égal dans le langage de programmation C est appelé opérateur d'assignement. Il a un sens différent de celui qu'il a en algèbre où il indique une équivalence ou une égalité. L'opérateur d'assignement indique au micrcontrôleur d'évaluer la valeur ou l'expression qui se trouve à droite du signe égal et de la stocker dans la variable à gauche du signe égal.

Syntaxe

variable = valeur ;

Exemple

int sensVal;                 // declare une variable entière de 16 bits nommée senVal
 senVal = analogRead(0);       // mémorise la valeur de la conversion analogique numérique dans la variable

Conseils de programmation

La variable à gauche de l'opérateur d'assignement (le signe =) nécessite d'être capable de stocker la valeur qu'on lui attribue. Si la variable n'est pas assez grande pour stocker la valeur, la valeur stockée dans la variable sera incorrecte ou tronquée.

Ne pas donfondre l'opérateur d'assignement = (signe égal unique) avec l'opérateur de comparaison == (double signe égal), qui lui évalue si deux expressions ou variables sont égales.

Commentaires utilisateurs

Aucun commentaire

Voir également

4.2  Addition + , Soustraction - , Multiplication * , et Division /


Description

Ces opérateurs renvoient respectivement la somme, la différence, le produit ou le quotient entre deux opérandes (= entre deux termes). Cette opération est réalisée en utilisant le type des données des opérandes. Ainsi par exemple, 9 / 4 donne 2 dès lors que 9 et 4 sont de type int. Cela signifie cependant que l'opération peut déborder si le résultat est plus grand que ce que le type de donnée utilisé peut contenir (càd qu'en additionnant 1 en tant que int avec la valeur 32 767 cela donne -32 768 en raison du débordement).

Si les opérandes sont de deux types de donnée différents, le plus "grand" est utilisé pour le calcul.

Si un des nombres (opérandes) est du type float ou double, le calcul dit "en virgule flottante" est utilisé pour le calcul (càd que 9/4 donne 2.25).

Syntaxe

result = value1 + value2;
result = value1 - value2;
result = value1 * value2;
result = value1 / value2;

Paramètres :

  • value1: tout type de variable ou constante numérique
  • value2: tout type de variable ou constante numérique

Exemples

y = y + 3;
x = x - 7;
i = j * 6;
r = r / 5;

Conseils de programmation :

  • Il faut savoir que les constantes entières sont par défaut de type int, et dès lors certains calcul entre constantes peuvent déborder (càd 60*1000 donnera un résultat négatif).
  • Choisir des tailles de variables assez grandes pour permettre de stocker les plus grands résultats issus des calculs.
  • Savoir à quel moment votre variable débordera et ce qui se passe dans chaque sens du débordement (càd 0=>1 ou 0 => - 32768)
  • Pour les mathématiques qui nécessitent des décimales ou des fractions, utiliser les variables de type float, mais rester conscient de leurs inconvénients : large taille de mémoire, vitesse d'exécution des calculs plus lente.
  • Utiliser un opérateur de conversion de type, par exemple int(myFloat), pour convertir une variable d'un type en un autre type "à la volée".

Commentaires utilisateurs

Aucun commentaire


>>center green bgcolor=#ffffcc border='1px dotted red' padding=5px<< VARIABLES ET CONSTANTES


Les variables sont des expressions que vous pouvez utilisez dans les programmes pour stocker des valeurs numériques.

5.  Les constantes Arduino prédéfinies


Description

Dans le langage Arduino, les constantes sont des variables prédéfinies. Elles sont utilisées pour rendre les programmes plus faciles à lire. Nous les avons classées ici en groupes.

Définition de niveaux logiques, true (vrai) et false (faux) (Constantes de type bouléen= binaire)

Il existe deux constantes utilisées pour représenté le VRAI et le FAUX dans le langage arduino : true et false.

false (= FAUX)

la constante false est la plus facile des deux à définir. false est définie comme le 0 (zéro).

true (=VRAI)

La constante true est souvent défini comme étant le 1, ce qui est correct, mais la constante true a une définition plus large. Tout entier qui n'est pas zéro est VRAI dans un sens booléen. Ainsi -1, 2 et -200 sont tous définis comme VRAI, toujours dans un sens booléen. Noter que les constantes true et false sont écrites en minuscule à la différence des constantes HIGH, LOW, INPUT et OUTPUT.

Définition des niveaux de broche, HIGH (HAUT) et LOW (BAS)

Lorsqu'on lit ou on écrit sur une broche numérique, seuls deux états distincts sont possible, la broche ne peut prendre/être qu'à deux valeurs : HIGH (HAUT) ou LOW (BAS).

HIGH

La signification de la constante HIGH (en référence à une broche) est quelque chose de différent selon que la broche est définie comme une ENTREE ou comme une SORTIE.

Si la broche est configurée en ENTREE avec l'instruction pinMode, et lue avec l'instruction digitalRead, le microcontrôleur renverra HIGH (=HAUT) si une tension de 3V ou + est présente sur la broche.

Dans le cas d'une broche qui est configurée en ENTREE avec l'instruction pinMode, et secondairement mise au niveau HIGH avec l'instruction digitalWrite, cela active une résistance interne de 20 Kohms, dite de "rappel au plus" (ou pullup en anglais), qui maintiendra la broche en entrée au niveau HIGH (=HAUT) tant qu'un circuit externe (un bouton poussoir par exemple) ne la mettra au niveau LOW (=BAS).

Quand une broche est configurée en SORTIE avec l'instruction pinMode, et mise au niveau HAUT avec l'instruction digitalWrite, la broche est mise à 5V. Dans cet état, la broche peut fournir une certaine intensité (jusqu'à 40 mA par broche, sans dépasser 200 mA pour l'ensemble des broches), par exemple pour allumer une LED qui est connectée sur cette broche en série avec une résistance à la masse (0V), ou à une autre broche configurée en sortie et maintenue au niveau LOW (=BAS).

LOW

Cela signifie que la constante LOW a également une signification différente selon que la broche est configurée en ENTREE ou en SORTIE. Quand une broche est configurée en ENTREE avec l'instruction pinMode, et lue avec l'instruction digitalRead, le microcontrôleur renverra un niveau BAS si une tension de 2V ou moins est présente sur la broche.

Quand la broche est configurée en SORTIE avec l'instruction pinMode, et est mise au niveau LOW avec l'instruction digitalWrite, la broche est à 0 volts. Dans cet état, elle peut fournir un courant, par exemple pour allumer une LED qui est connectée en série avec une résistance au +5 volts, ou sur une autre broche configurée en sortie et mise au niveau HIGH.

Définition des constantes de broches numériques, INPUT and OUTPUT

Les broches numériques peuvent être utilisées soit en mode INPUT (= en entrée), soit en mode OUTPUT (= en sortie). Modifier le mode de fonctionnement d'une broche du mode INPUT (=ENTREE) en mode OUTPUT(=SORTIE) avec l'instruction pinMode() change complètement le comportement électrique de la broche.

Broches configurées en entrée (INPUT)

Les broches d'une carte Arduino (basée sur un microcontrôleur Atmega) configurées en mode INPUT (=en entrée) à l'aide de l'instruction pinMode() sont dites en état de "haute-impédance" (en état de "haute résistance" en quelque sorte). Une façon d'expliquer cela est qu'une broche configurée en ENTREE ne consomme qu'une toute petite intensité (de l'ordre du microampère ce qui est très faible...) sur le circuit sur laquelle elle est connectée, autrement dit comme si une résistance en série de 100 Mégaohms (100 millions de Ohms) était connectée devant la broche. Ceci est très utile pour lire un capteur, mais par pour allumer une LED.

Broches configurées en sortie (SORTIE)

Les broches configurées en mode OUTPUT (= en sortie) avec l'instruction pinMode() sont en état dit de "basse-impédance" (en état de "basse résistance" en quelque sorte). Cela veut dire qu'elle peuvent fournir une quantité significative de courant aux autres circuits. Chaque broche de la carte Arduino (basée sur un microcontrôleur Atmega) peuvent fournir (courant positif) ou absorber (courant négatif) jusqu'à 40 mA (milliampères) d'intensité aux autres circuits ou composants . Cela les rend très utiles pour allumer des LEDs mais moins pour lire des capteurs. Les broches configurés en sortie peuvent cependant être endommagées ou détruites si un court-circuit se produit entre la masse (0V) et le 5 volts. L'intensité fournie par une broche de microcontrolleur Atmega n'est pas suffisante non plus pour alimenter des relais ou des moteurs, et des circuits d'interface de puissance sont alors requis.

Commentaires utilisateurs

ATTENTION : bien qu'une broche en sortie puisse supporter 40mA d'intensité, l'intensité cumulée fournie par les broches de la carte ne doit cependant pas dépasser les 200mA ! Dans le cas d'une utilisation de plusieurs LEDs par exemple sur des broches en sortie, limiter l'intensité entre 10 et 15 mA par broche, ce qui est obtenu en connectant une résistance de 200 à 300 Ohms en série avec la LED connectée sur chaque broche utilisée avec une LED. Ainsi, même si l'on utilise 20 LEDs, on restera dans les "clous"...

Un moteur à courant continu va nécessiter selon les cas de 200mA à 600mA, et même parfois beaucoup plus : une interface dite "de puissance" est donc nécessaire pour le commander à l'aide d'une broche en sortie. Des cartes et circuits intégrés sont prévus à cet effet.

Voir également

6.  Les expressions numériques entières


Description

Les expressions numériques entières sont des nombres utilisés directement dans un programme, tel que 123. Par défaut, ces nombres sont traités comme des variables de type int mais vous pouvez changer cela avec les "modificateurs" U et L (voir ci-dessous).

Normalement, les expressions numériques entières sont traitées comme des entiers en base 10 (base décimale càd notre façon spontanée d'exprimer les nombres), mais des notations spéciales (ou "formateurs") peuvent être utilisé pour saisir des nombres dans d'autres bases.

BaseExemple"Formateur"Commentaire
10 (decimal)123aucun 
2 (binaire)B1111011Bfonctionne uniquement avec des valeurs 8 bits (0 to 255) et seuls les caractères 0 et 1 sont valides
8 (octal)01730seuls les caractères de 0-7 sont valides
16 (hexadecimal)0x7B0xles caractères 0-9, A-F et a-f sont valides

Format décimal

Le format decimal correspond à la base 10. C'est les mathématiques du sens commun avec lesquels vous êtes habitués. Les expressions numériques entières sans autre préfixe sont considérées comme étant au format decimal.

Exemple:

101     // pareil que 101 decimal   ((1 * 100) + (0 * 10) + 1)

Format binaire

Le format binaire correspond à la base 2. Seuls les caractères 0 et 1 sont valides.

Exemple:

B101    // vaut 5 en décimal   ((1 * 2^2) + (0 * 2^1) + 1)

Le formateur binaire ne fonctionne uniquement sur des octets (soit 8 bits) entre 0 (B0) et 255 (B11111111). Si c'est nécessaire de saisir un int (16 bits) au format binaire, vous pouvez le faire en deux temps de la façon suivante :

myInt = (B11001100 * 256) + B10101010;    // B11001100 est l'octet de poids fort

Format octal

Le format octal correspond à la base 8. Seuls les caractères de 0 à 7 sont valides. Les valeurs octales sont indiquées par le préfix "0"

Exemple:

0101    // vaut 65 en décimal   ((1 * 8^2) + (0 * 8^1) + 1)

ATTENTION : Il est possible de générer un bogue très difficile à détecter en incluant (par inadvertance) un 0 devant une expression numérique que le compilateur interprétera comme une expression numérique de type octal.

Format hexadécimal

Le format hexadécimal (or hex) correspond à la base 16. Les caractères valides sont de 0 à 9 ainsi que les lettres A à F; A a la valeur 10, B la valeur 11, jusqu'à F qui a la valeur 15. Les valeurs hexadécimales sont indiquées par le préfix "0x". Noter que les lettres A-F peuvent être écrites en majuscules(A-F) ou en minuscules (a-f).

Exemple:

0x101   // vaut 257 décimal   ((1 * 16^2) + (0 * 16^1) + 1)

Les modificateurs U et L

Par défaut, une constante entière est traitée commune une variable int avec les limitations inhérentes à ces valeurs. Pour utiliser une constante entière dans un autre type de données, on la fait suivre par :

  • un 'u' ou 'U' pour forcer à traiter la constante dans le format de donnée non signé (unsigned). Exemple: 33u
  • un 'l' ou 'L' pour forcer à traiter la constante dans le format de donnée de type long. Exemple: 100000L
  • un 'ul' ou 'UL' pour forcer à traiter la constante dans le format de donnée de type unsigned long (long non signé). Exemple: 32767ul

Commentaires utilisateurs

Aucun commentaire

Voir également

7.  Types des données

7.1  int


Description

Déclare une variable de type int (pour integer, entier en anglais). Les variables de type int sont votre type de base pour le stockage de nombres, et ces variables stockent une valeur sur 2 octets. Elles peuvent donc stocker des valeurs allant de - 32 768 à 32 767 ( valeur minimale de -2 exposant 15 et une valeur maximale de (2 exposant 15) -1).

Les variables int stocke des nombres négatifs avec la technique mathématique appelée du "deuxième complément" math. Le bit de poids le plus fort, parfois aussi appelé le bit de signe, détermine le signe du nombre (négatif si ce bit=0, positif si ce bit est à 1). Le reste des bits sont inversés et le nombre 1 est ajouté.

L'Arduino s'occupe des nombres négatifs pour vous, de façon à ce que les opérations mathématiques fonctionne de façon transparente et de la façon attendue. Il peut cependant exister des complications inattendures avec l'opérateur de décalage de bits vers la droite (>>).

Syntaxe

int var = val;
  • var : le nom de votre variable de type int
  • val : la valeur d'initialisation de la variable

Exemple

int ledPin = 13; // déclare une variable de type int appelée LedPin et valant 13

Conseils de programmation

Quand les variables dépassent la valeur maximale de leur capacité, elles "débordent" et reviennent à leur valeur minimale, et ceci fonctionne dans les 2 sens. Illustration :

int x   // déclaration de la variable de type int appelée x    
   x = -32,768;  // x prend la valeur -32 768
   x = x - 1;       // x vaut maintenant 32 767, car déborde dans le sens négatif

   x = 32,767;  // x prend la valeur 32 767
   x = x + 1;       // x vaut maintenant la valeur - 32 768, car déborde dans le sens positif

Commentaires utilisateurs

Aucun commentaire

Voir également

7.2  void


Description

Le mot-clé void est utilisé uniquement pour les déclarations de fonctions. Il indique au compilateur que l'on s'attend à ce que la fonction ne retourne aucune donnée à la fonction qui l'a appelée.

Exemple

// des actions sont exécutées dans les fonctions "setup" et "loop"
// mais aucune information n'est renvoyée au programme principal

void setup()
{
  // ...
}

void loop()
{
  // ...
}
 

Commentaires utilisateurs

Aucun commentaire

Voir également

8.  Entrées/Sorties Numériques

8.1  pinMode()


Description

Configure la broche spécifiée pour qu'elle se comporte soit en entrée, soit en sortie. Voir la description des broches numériques pour plus de détails.

Syntaxe

pinMode(broche, mode)

Paramètres

broche: le numéro de la broche de la carte Arduino dont le mode de fonctionnement (entrée ou sortie) doit être défini.

mode: soit INPUT (entrée en anglais) (=0) ou OUTPUT (sortie en anglais) (=1)

Valeur retournée

Aucune

Exemple

int ledPin = 13;                 // LED connectée à la broche numérique 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // met la broche numérique en sortie
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // allume la LED
  delay(1000);                  // attend une seconde
  digitalWrite(ledPin, LOW);    // éteint la LED
  delay(1000);                  // attend une seconde
}

Note

Les broches analogiques peuvent être utilisées en tant que broches numériques, représentées par les nombres 14 (entrée analogique 0) à 19 (entrée analogique 5).

NOTE : La broche numérique 13 est plus difficile à utiliser que les autres en tant qu'entrée numérique car elle est associée à une résistance et sa LED soudées sur le circuit imprimé de la carte sur la plupart des cartes. Si vous activez la résistance interne de rappel au plus de 20K, cela mettra la borche à 1,7V au lieu des 5V théoriques car la LED et la résistance associées à la broche abaisse la tension, qui est toujours considérée au niveau BAS (LOW). Ainsi, si vous devez utiliser la broche 13 en tant qu'entrée numérique, utiliser une résistance de rappel au plus externe.

Commentaires utilisateurs

Aucun commentaire

Voir également :

  • les constantes
  • l'instruction digitalWrite()
  • l'instruction digitalRead()
  • Tutoriel: Description des broches d'une carte Arduino

8.2  digitalWrite()


Description

Met un niveau logique HIGH (HAUT en anglais) ou LOW (BAS en anglais) sur une broche numérique. Si la broche a été configurée en SORTIE avec l'instruction pinMode(), sa tension est mise à la valeur correspondante : 5V (ou 3.3V sur les cartes Arduino 3.3V) pour le niveau HAUT, 0V (masse) pour le niveau BAS.

Syntaxe


digitalWrite(broche, valeur)
 

Paramètres

  • broche: le numéro de la broche de la carte Arduino
  • valeur : HIGH ou LOW (ou bien 1 ou 0)

Valeur retournée

Aucune

Exemple


int ledPin = 13;                 // LED connectée à la broche numérique n° 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // met la broche utilisée avec la LED en SORTIE
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // allume la LED
  delay(1000);                  // pause 1 seconde
  digitalWrite(ledPin, LOW);    // éteint la LED
  delay(1000);                  // pause 1 seconde
}
 

Ce programme met la broche 13 au niveau HAUT (=1), fait une pause de 1 seconde, puis met la broche au niveau BAS (=0), fait une nouvelle pause d'une seconde, puis le programme boucle.

Remarque

Les broches analogiques peuvent être utilisées en tant que broches numériques, représentées par les nombres 14 (entrée analogique 0) à 19 (entrée analogique 5).

Si la broche est configurée en ENTREE, écrire un niveau HAUT sur cette broche a pour effet d'activer la résistance interne de 20K de "rappel au plus" (pullup) sur cette broche (voir le tutoriel sur les broches numériques). A l'inverse, mettre un niveau BAS sur cette broche en ENTREE désactivera le pullup interne. Exemple :


pinMode(pin, INPUT);           // configure la broche en entrée
digitalWrite(pin, HIGH);       // écrit la valeur HIGH (=1) sur la broche en entrée
                             // ce qui active la résistance de "rappel au +" (pullup) au plus de la broche

Commentaires utilisateurs

Cette instruction met la valeur 0/1 dans le bit de donnée qui est associé à chaque broche, ce qui explique qu'on puisse le mettre à 1, même si la broche est en entrée.

Ne pas oublier qu'une broche numérique ne peut fournir que 40mA (milliampères) tant en entrée qu'une sortie, et que l'ensemble des broches de la carte Arduino ne peut fournir que 200mA. Par conséquent, limiter l'intensité utilisée pour chaque broche à une dizaine de mA. par des résistances adaptées : 270 Ohms pour une LED par exemple (ce qui fait environ 13mA sur la broche).

Voir également :

8.3  digitalRead()


Description

Lit l"état (= le niveau logique) d'une broche précise en entrée numérique, et renvoie la valeur HIGH (HAUT en anglais) ou LOW (BAS en anglais).

Syntaxe

digitalRead(broche)

Paramètres

  • broche : le numéro de la broche numérique que vous voulez lire. (int)

Valeur retournée

  • Renvoie la valeur HIGH (HAUT en anglais) ou LOW (BAS en anglais)

Exemple


int ledPin = 13; // LED connectée à la broche n°13
int inPin = 7;   // un bouton poussoir connecté à la broche 7
                    // avec une résistance de pulldown
int val = 0;     // variable pour mémoriser la valeur lue

void setup()
{
  pinMode(ledPin, OUTPUT);      // configure la broche 13 en SORTIE
  pinMode(inPin, INPUT);      // configure la broche 7 en ENTREE

  digitalWrite(inPin, HIGH);       // écrit la valeur HIGH (=1) sur la broche en entrée
                             // ce qui active la résistance de "rappel au +" (pullup) au plus de la broche
}

void loop()
{
  val = digitalRead(inPin);   // lit l'état de la broche en entrée
                                    // et met le résultat dans la variable

  digitalWrite(ledPin, val);    // met la LED dans l'état du BP
                                     // (càd allumée si appuyé et inversement)
}
 

Dans ce programme, la broche 13 reflète fidèlement l'état de la broche 7 qui est une entrée numérique.

Remarque

Si la broche numérique en entrée n'est connectée à rien, l'instruction digitalRead() peut retourner aussi bien la valeur HIGH (HAUT en anglais) ou LOW (BAS en anglais) ( et cette valeur peut changer de façon aléatoire)

Les broches analogiques peuvent être utilisées en entrée et sont désignées par les numéro 14 (entrée analogique 0) à 19 (entrée analogique 5).

NOTE : La broche numérique 13 est plus difficile à utiliser que les autres en tant qu'entrée numérique car elle est associée à une résistance et sa LED soudées sur le circuit imprimé de la carte sur la plupart des cartes. Si vous activez la résistance interne de rappel au plus de 20K, cela mettra la borche à 1,7V au lieu des 5V théoriques car la LED et la résistance associées à la broche abaisse la tension, qui est toujours considérée au niveau BAS (LOW). Ainsi, si vous devez utiliser la broche 13 en tant qu'entrée numérique, utiliser une résistance de rappel au plus externe.

Commentaires utilisateurs

Pour pouvoir lire une broche en tant qu'entrée numérique :

  • configurer cette broche en entrée avec l'instruction pinMode(broche, INPUT);
  • activer le "rappel au plus" interne dans le cas d'un bouton poussoir avec l'instruction digitalWrite(broche, HIGH)
pinMode(pin, INPUT);           // configure la broche en entrée
digitalWrite(pin, HIGH);       // écrit la valeur HIGH (=1) sur la broche en entrée 
                             // ce qui active la résistance de "rappel au +" (pullup) au plus de la broche

Voir également :

9.  Entrées/Sorties Avancées

9.1  tone()

Description

Génère une onde carrée (onde symétrique avec "duty cycle" (niveau haut/période) à 50%) à la fréquence spécifiée (en Hertz (Hz), ou nombre de périodes par seconde) sur une broche. La durée peut être précisée, sinon l'impulsion continue jusqu'à l'appel de l'instruction noTone(). La broche peut être connectée à un buzzer piézoélectrique ou autre haut-parleur pour jouer des notes (les sons audibles s'étendent de 20Hz à 20 000Hz).

Une seule note peut être produite à la fois. Si une note est déjà jouée sur une autre broche, l'appel de la fonction tone() n'aura aucun effet (tant qu'une instruction noTone() n'aura pas eu lieu). Si la note est jouée sur la même broche, l'appel de la fonction tone() modifiera la fréquence jouée sur cette broche.

Syntaxe

tone(broche, frequence)
tone(broche, frequence, durée)

Paramètres

  • broche: la broche sur laquelle la note est générée.
  • frequence: la fréquence de la note produite, en hertz (Hz)
  • durée: la durée de la note en millisecondes (optionnel)

Valeur renvoyée

Aucune

Commentaires utilisateurs

Aucun commentaire

Voir également

9.2  noTone()


Description

Stoppe la génération d'impulsion produite par l'instruction tone(). N'a aucun effet si aucune impulsion n'est générée.

Syntaxe

noTone(broche)

Paramètres

  • broche: la broche sur laquelle il faut stopper la note.

Valeur renvoyée

aucune

Commentaires utilisateurs

Aucun commentaire

Voir également

10.  Temps

10.1  delay(ms)


Description

Réalise une pause dans l'exécution du programme pour la durée (en millisecondes) indiquée en paramètre. (=Pour mémoire, il y a 1000 millisecondes dans une seconde...!

Syntaxe

delay (ms);

Paramètres

  • ms (unsigned long): le nombre de millisecondes que dure la pause

Valeur renvoyée

Aucune

Exemple

int ledPin = 13;                 // Une LED est connectée à la broche 13

void setup() // la fonction setup() est exécutée 1 seule fois
{
  pinMode(ledPin, OUTPUT);      // met la broche numérique en sortie
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // allume la LED
  delay(1000);                  // attendre 1 seconde
  digitalWrite(ledPin, LOW);    // éteint la LED
  delay(1000);                  // attendre une seconde
} // la fonction loop() boucle sans fin
 

Avertissement

Bien qu'il soit facile de faire clignoter une LED avec l'instruction delay(), et de nombreux programmes utilisent de courtes pauses pour de nombreuses tâches telles que la commutation, l'utilisation de l'instruction delay() a des inconvénients non négligeables. Aucune autre lecture de valeur sur un capteur, opération mathématique ou manipulation de bits ne peut avoir lieu durant une instruction delay(), et en effet, cela fait stopper toute autre activité le temps de l'exécution de la pause. Pour une autre approche du contrôle des temporisations, voir l'instruction millis() et les programmes d'exemples cités à la suite. Les programmeurs avancés évitent habituellement d'utiliser l'instruction delay() pour des pauses supérieures à 10 millisecondes, à moins que le programme Arduino ne soit très simple.

Certaines chose se font cependant même lorsque l'instruction delay() est exécutée et contrôle le microcontrôleur ATmega, car l'instruction delay() ne désactive pas les interruptions. Les communications série qui arrivent sur la broche RX sont prises en compte, la génération d'impulsion PWM (analogWrite) et l'état des broches stables sont maintenus, et les interruptions fonctionnent comme elles le doivent.

Commentaires utilisateurs

  • Il semble qu'au contraire de ce que dit la référence officielle, les interruptions sont stoppées par la fonction delay(), de même que par les fonctions millis() et micros() (cf fichier wiring.cpp) (Note faite pour la version Arduino 18). La fonction delayMicroseconds() ne stoppe pas les interruptions à priori.
  • cette fonction est basée sur le Timer 0

Voir également