Name: Arduino Apprivoisez l'électronique et le codage (3e édition)
Rating: 4.7143 (7 reviews)

Introduction

Vous trouverez ici un récapitulatif des principales fonctions utilisables dans le langage Arduino. Vous pourrez ainsi vous y référer sans avoir à parcourir tout le livre.

Structure d’un sketch

Un programme Arduino valide doit au moins intégrer les fonctions setup et loop. Tous les autres éléments sont facultatifs, mais doivent être placés au bon endroit.

Voilà un exemple de programme Arduino :

#include <mabibliotheque.h>  //Déclaration des bibliothèques 
const int CONSTANTE1 = 10; //Déclaration des constantes 
int variableglobale1 = 1;  //Déclaration des variables globales 
 
void setup() {  // S'exécute une seule fois 
  Serial.begin(9600); // Initialise le moniteur série 
  pinMode(9, OUTPUT); // Définition des entrées/sorties 
} 
 
void loop() {  // Boucle infinie 
int variablelocale1 = 2;  //Déclaration d'une variable locale 
Instruction1;  // Instructions 
fonction1();   // Appel de la fonction1 
} 
 
void fonction1() {  // Définition des fonctions 
  int variablelocale2 = 5;  //Déclaration d'une variable locale 
  Instruction2;     // Instructions de la fonction1 
  Instruction3; 
}

1. Point-virgule

Chaque instruction doit être suivie d’un point-virgule (à part quelques exceptions). Si vous oubliez un point-virgule, cela entraîne une erreur...

Fonctions

1. Fonctions de base

Un sketch Arduino doit obligatoirement comporter ces deux fonctions :

void setup() {  // S'exécute une seule fois 
 
} 
 
void loop() {  // Boucle infinie 
 
}

2. Fonctions personnalisées

Vous pouvez créer vos propres fonctions pour éviter de répéter plusieurs fois le même code.

a. Fonctions sans arguments - void

// ------------------ S'exécute une seule fois -------- 
void setup() { 
} 
// ------------------ Boucle infinie ------------------ 
void loop() { 
  fonction1(); // Appel de la fonction1 
  fonction2(); // Appel de la fonction2 
} 
// ------------------ Mes fonctions ------------------- 
void fonction1() {  // Définition de la fonction1 
  Instruction1;     // Instructions de la fonction1 
  Instruction2; 
} 
void fonction2() {  // Définition de la fonction2 
  Instruction3;     // Instructions de la fonction2 
  Instruction4; 
}

b. Fonctions avec arguments

void setup() { 
  Serial.begin(9600); 
} 
void loop() { 
  int var1 = 5; 
  int var2 = 6; 
  Serial.print("Le resultat est "); 
  Serial.println(addition(var1, var2)); // Affiche le résultat 
} 
int addition(int add1, int add2) { 
  int resultatAddition = add1 + add2; 
  return (resultatAddition);  // Renvoie le résultat 
}

Résultat (dans le moniteur série) :

Le resultat est 11 
Le resultat est 11 
Le resultat est 11

3. Entrées/sorties numériques

L’Arduino Uno possède quatorze entrées/sorties numériques (numérotées de 0 à 13), mais les bornes 0 et 1 sont utilisées par le port série et la borne 13 est reliée à la LED interne.

Les six broches analogiques sont aussi utilisables en tant que sorties numériques sous les numéros suivants :

A0	A1	A2	A3	A4	A5
14	15	16	17	18	19

a. Fonction pinMode

Indique (en général dans la fonction setup) si la broche est utilisée en entrée...

Constantes et variables

1. Types de données

Type de variable	Nombre	Valeurs maximales	Taille SRAM
void	vide	Utilisé seulement pour les fonctions
boolean	entier positif	0 à 1	1 octet
char	entier	-128 à +127	1 octet
unsigned char	entier positif	0 à 255	1 octet
byte	entier positif	0 à 255	1 octet
int	entier	-32 768 à +32 767	2 octets
unsigned int	entier positif	0 à 65 535	2 octets
word	entier positif	0 à 65 535	2 octets
long	entier	-2 147 483 648 à +2 147 483 647	4 octets
unsigned long	entier positif	0 à 4 294 967 295	4 octets
short	entier	-32 768 à +32 767	2 octets
float	Décimal	-3.4 x 1038 à +3.4 x 1 038	4 octets
double	Décimal	-3.4 x 1038 à +3.4 x 1 038	4 octets

2. Portée des variables

a. Variables globales

Les variables déclarées à l’extérieur des fonctions setup et loop sont considérées comme des variables globales. Cela signifie qu’elles peuvent être utilisées n’importe où dans le programme. Il est d’usage de les regrouper au début du programme.

int maVariable = 200; 
enum {var1 = 1, var2 = 5, var3 = 10}; 
int var4, var5, var6, var7, var8; 
void setup(){} 
void loop(){}

b. Variables locales

Il peut être utile d’utiliser des variables locales pour économiser de la mémoire et pouvoir réutiliser le même nom de variable (par exemple dans des boucles qui ne sont pas imbriquées). Pour cela, il suffit de déclarer la variable à l’intérieur d’une fonction. Elle n’existera qu’à l’intérieur des accolades.

int varGlobale;  // Toutes les fonctions voient cette variable 
 
void setup(){ 
} 
void loop(){ 
  int locale1;  // Variable visible seulement dans la boucle loop 
  for (int i = 0; i <100; i++){ 
  // la variable i est visible seulement dans la boucle for 
  } 
}

3. Constantes

a. Constantes prédéfinies

Elles apparaissent en bleu dans l’IDE Arduino.

Constante	Valeur
false	0
true	1 (ou n’importe quel nombre différent de 0)
HIGH (entrée)...

Structures de contrôle

1. if… else

if (x == 10) x = 0; // Si x est égal à 10, alors x = 0; 
//-------------------------------------------------------------- 
if (x > 9){ x = 0;} // Si x est supérieur à 9, alors x = 0; 
//-------------------------------------------------------------- 
if (x >= 8) { // Si x est supérieur ou égal à 8, alors... 
  x = 0; 
  y = x + 3; 
} 
//-------------------------------------------------------------- 
if (x <= 10) { // Si x est inférieur ou égal à 10, alors... 
  x = 0; 
} 
else { // Sinon... 
  y = x + 1; 
} 
//-------------------------------------------------------------- 
if (x < 10) { // Si x est inférieur à 10, alors... 
  y = 0; 
} 
else if (x == 10) { // Sinon et si x est égal à 10, alors... 
  y = 5; 
} 
else { // Sinon... 
  y = 10; 
} 
//-------------------------------------------------------------- 
if (x > 2 && x < 5) { // si x est supérieur à 2 et inférieur à 5 
  y = 2; 
} 
//-------------------------------------------------------------- 
if (x = 1 || y = 5) { // si x est égal à 1 ou si y est égal...

Opérateurs

1. Opérateurs arithmétiques

x = 3;            // Affectation( x prend la valeur de 3) 
x = y;            // Affectation( x prend la valeur de y) 
x = 3 + 2;        // Addition (x = 5) 
x = 3 - 2;        // Soustraction (x = 1) 
x = 3 * 2;        // Multiplication (x = 6) 
x = 6 / 2;        // Division  (x = 3) 
x = 3 % 2;        // Modulo (x = 1 le reste de la division 3/2)

2. Opérateurs composés

Il s’agit d’une version abrégée des opérateurs arithmétiques.

y = ++x;  // Équivaut à x = x + 1; et y = x; 
y = --x;  // Équivaut à x = x - 1; et y = x; 
y = x++;  // Équivaut à y = x; et x = x + 1; 
y = x--;  // Équivaut à y = x; et x = x - 1; 
y += x;  // Équivaut à y = y + x; 
y -= x;  // Équivaut à y = y - x; 
y *= x;  // Équivaut à y = y * x; 
y /= x;  // Équivaut à y = y / x; 
y &= x;  // Équivaut à y = y & x; 
y |= x;  // Équivaut à y = y | x;

3. Opérateurs logiques de comparaison

Ils sont notamment utilisés dans les structures de contrôle.

Est égal à	==
Est différent de	!=
Est strictement inférieur à	<
Est strictement supérieur à	>
Est inférieur ou égal à	<=
Est supérieur ou égal...

Le langage Arduino