Bases · 12 min de lecture

Tableau Arduino : déclarer un array, boucle for et exemples

Tableau Arduino pas à pas : déclarer un array, index, parcours avec for, tableaux 2D, broches de LED, moyenne de capteur et mélodie avec buzzer.

Utiliser un tableau Arduino est une compétence de base : tu regroupes de nombreuses valeurs du même type sous un seul nom et tu accèdes à chacune par son numéro (son index). Au lieu d'écrire les broches de six LED, les dix dernières mesures d'un capteur ou les notes d'une chanson dans des variables séparées comme led1, led2, led3, tu les ranges dans un seul tableau et tu les traites toutes en quelques lignes avec une boucle for. Ton code devient plus court, tu fais moins d'erreurs, et pour ajouter une LED au montage il suffit d'ajouter un nombre à la liste.

Dans ce guide, tu vas voir comment un tableau est stocké en mémoire, comment le déclarer, pourquoi l'index commence à zéro et comment calculer le nombre d'éléments avec sizeof. Ensuite, nous ferons trois vrais exemples : un effet Knight Rider avec des LED, une moyenne glissante qui lisse les mesures bruitées d'un capteur, et une mélodie jouée sur un buzzer. Enfin, tu construiras une table d'états de feu tricolore avec un tableau à deux dimensions, tu verras les différences sur ESP32 et Raspberry Pi Pico, et tu apprendras à repérer les dépassements qui cassent ton programme sans message d'erreur. Si tu débutes complètement, commence par les bases de la programmation Arduino.

LED utilisées dans un exemple de tableau Arduino
Gérer six LED avec un seul tableau de broches plutôt qu'une par une est l'usage le plus classique des tableaux.

Qu'est-ce qu'un tableau (array) et comment fonctionne-t-il ?

Un tableau est un bloc d'éléments placés côte à côte en mémoire, tous du même type de données. Imagine une armoire de tiroirs numérotés : l'armoire a un seul nom et chaque tiroir a un numéro. Dans le langage Arduino, basé sur C et C++, cette numérotation commence à 0 : un tableau de 5 éléments a les index 0, 1, 2, 3 et 4, donc le dernier index est toujours le nombre d'éléments moins un. Le compilateur connaît l'adresse de départ du tableau ; quand tu écris tableau[3], il ajoute 3 × la taille d'un élément à cette adresse et va directement à la case voulue. L'accès est donc très rapide, mais pour la même raison le compilateur ne vérifie pas si tu sors des limites. La mémoire occupée par un tableau est le nombre d'éléments multiplié par la taille d'un élément :

Type de donnéesTaille d'un élément (Uno)Taille d'un élément (ESP32 / Pico, C++)Tableau de 100 éléments (Uno)
byte / uint8_t1 octet1 octet100 octets
char1 octet1 octet100 octets
int2 octets4 octets200 octets
unsigned int2 octets4 octets200 octets
long4 octets4 octets400 octets
float4 octets4 octets400 octets

L'Arduino Uno n'a que 2 Ko (2048 octets) de RAM : un tableau de 1000 int à lui seul mangerait presque toute la mémoire. Il est donc bon de prendre l'habitude d'utiliser byte pour les valeurs entre 0 et 255 (numéros de broches, luminosité PWM, jour ou heure), int pour les résultats d'analogRead et long pour les grosses sommes. Choisir le bon type, c'est pouvoir stocker deux fois plus de données dans la même mémoire.

Comment déclarer un tableau sur Arduino ?

Pour déclarer un tableau, tu écris d'abord le type de données, puis le nom du tableau, puis le nombre d'éléments entre crochets. Tu peux donner les valeurs tout de suite entre accolades, ou laisser la taille vide et laisser le compilateur compter. Le programme ci-dessous montre les formes les plus courantes et affiche les résultats dans le moniteur série :

C++ (Arduino IDE)
1int notlar[5] = {90, 75, 60, 85, 100};   // boyut ve değerler / size and values
2int pinler[] = {2, 3, 4, 5, 6, 7};       // boyutu derleyici sayar / compiler counts the size
3float olcumler[10] = {1.5, 2.0};         // kalan 8 eleman 0.0 / remaining 8 are 0.0
4int bos[5];                              // global dizi: hepsi 0 / global array: all zeros
5char isim[] = "Arduino";                 // 7 harf + '\0' = 8 bayt / 7 letters + '\0' = 8 bytes
6
7void setup() {
8  Serial.begin(9600);
9  Serial.println(notlar[0]);             // ilk eleman: 90 / first element: 90
10  Serial.println(notlar[4]);             // son eleman: 100 / last element: 100
11  notlar[2] = 65;                        // üçüncü elemanı değiştir / change the third element
12  Serial.println(notlar[2]);             // 65
13  Serial.println(olcumler[5]);           // 0.00
14  Serial.println(bos[3]);                // 0
15  Serial.println(sizeof(isim));          // 8
16  Serial.println(sizeof(pinler) / sizeof(pinler[0]));  // eleman sayısı: 6 / element count: 6
17}
18
19void loop() {
20}
DéclarationSignification
int a[5];Tableau de 5 éléments ; s'il est global tout vaut 0, dans une fonction les valeurs initiales sont aléatoires
int a[5] = {1, 2, 3, 4, 5};La taille et toutes les valeurs sont données ensemble
int a[] = {2, 3, 4};Le compilateur compte la taille (ici 3)
float a[10] = {1.5, 2.0};Les éléments sans valeur sont mis à 0
int a[5] = {0};Raccourci pour tout mettre à zéro
char s[] = "Arduino";Chaîne de caractères ; un caractère invisible '\0' termine la chaîne (8 octets au total)
const byte a[] = {2, 3, 4};Tableau constant, non modifiable dans le programme
L'index commence à 0. Dans un tableau int a[5] de 5 éléments, l'élément a[5] n'existe pas ; le dernier est a[4]. Le compilateur ne détecte le plus souvent pas cette erreur : en écrivant dans a[5], tu écrases une autre variable placée juste derrière le tableau. Le résultat n'est pas un message d'erreur, mais des valeurs absurdes, un Arduino qui se réinitialise tout seul ou une panne mystérieuse que tu cherches pendant des heures.

Parcourir un tableau avec une boucle for

La vraie puissance des tableaux apparaît quand on les combine avec une boucle for. La variable de boucle i part de 0 et monte jusqu'au nombre d'éléments moins un, et à chaque tour tu accèdes à l'élément suivant avec tableau[i]. Au lieu d'écrire le nombre d'éléments à la main, le plus sûr est de le calculer avec la formule sizeof(tableau) / sizeof(tableau[0]) : sizeof(tableau) donne le nombre total d'octets, sizeof(tableau[0]) la taille d'un élément. Par exemple, sur l'Uno, un tableau de 7 int fait 14 octets et 14 / 2 = 7. Quand tu ajoutes un élément, cette formule met le nombre à jour toute seule. Le code ci-dessous calcule la moyenne, le minimum et le maximum des températures d'une semaine. La somme des mesures est 161, la moyenne 23,0 degrés ; la valeur minimale est 19 et la maximale 27. Fais attention à la condition de boucle i < ADET : si tu mets inférieur ou égal, la boucle fait un tour de trop et lit la mémoire en dehors du tableau.

C++ (Arduino IDE)
1int sicakliklar[] = {22, 24, 19, 27, 25, 21, 23};   // bir haftalık ölçüm / one week of readings
2const int ADET = sizeof(sicakliklar) / sizeof(sicakliklar[0]);   // 7
3
4void setup() {
5  Serial.begin(9600);
6  long toplam = 0;                       // taşmasın diye long / long to avoid overflow
7  int enKucuk = sicakliklar[0];
8  int enBuyuk = sicakliklar[0];
9
10  for (int i = 0; i < ADET; i++) {       // 0'dan 6'ya / from 0 to 6
11    toplam += sicakliklar[i];
12    if (sicakliklar[i] < enKucuk) enKucuk = sicakliklar[i];
13    if (sicakliklar[i] > enBuyuk) enBuyuk = sicakliklar[i];
14  }
15
16  Serial.print("Ortalama / Average: ");
17  Serial.println((float)toplam / ADET);  // 23.00
18  Serial.print("En dusuk / Min: ");
19  Serial.println(enKucuk);               // 19
20  Serial.print("En yuksek / Max: ");
21  Serial.println(enBuyuk);               // 27
22}
23
24void loop() {
25}

Exemple 1 : gérer les broches de LED avec un tableau

L'usage le plus classique des tableaux sur Arduino est la gestion de plusieurs LED. Pour contrôler six LED sans tableau, il faut écrire six pinMode distincts et des lignes digitalWrite séparées pour chaque étape ; avec un tableau, une seule boucle suffit. Branche la longue patte (anode) de chaque LED sur une broche numérique et la courte patte à GND via une résistance de 220 Ω. Si tu veux calculer la valeur de la résistance toi-même, utilise l'outil calculateur de résistance de LED.

LED (index du tableau)Arduino UnoESP32Raspberry Pi Pico
LED 1 (ledPinleri[0])D2GPIO 13GP14
LED 2 (ledPinleri[1])D3GPIO 14GP13
LED 3 (ledPinleri[2])D4GPIO 27GP12
LED 4 (ledPinleri[3])D5GPIO 26GP11
LED 5 (ledPinleri[4])D6GPIO 25GP10
LED 6 (ledPinleri[5])D7GPIO 33GP9
Cathode (patte courte)GND via 220 ΩGND via 220 ΩGND via 220 Ω
  1. Place les LED dans l'ordre sur la breadboard ; relie les pattes courtes (cathodes) à la ligne GND via des résistances de 220 Ω.
  2. Relie les pattes longues aux broches 2 à 7 de l'Arduino, dans l'ordre du tableau.
  3. Écris les numéros de broches dans le tableau ledPinleri selon l'ordre physique des LED ; l'ordre du tableau détermine le sens de défilement de la lumière.
  4. Dans setup(), mets toutes les broches en OUTPUT avec une seule boucle for.
  5. Dans loop(), crée l'effet Knight Rider avec deux boucles, l'une aller et l'autre retour, puis téléverse le code.
C++ (Arduino IDE)
1const byte ledPinleri[] = {2, 3, 4, 5, 6, 7};   // LED'lerin fiziksel sırası / physical order of LEDs
2const byte LED_SAYISI = sizeof(ledPinleri) / sizeof(ledPinleri[0]);   // 6
3const int BEKLEME = 100;                         // adım süresi ms / step time in ms
4
5void setup() {
6  for (byte i = 0; i < LED_SAYISI; i++) {
7    pinMode(ledPinleri[i], OUTPUT);              // tüm pinler çıkış / all pins as output
8  }
9}
10
11void loop() {
12  // ileri: 0'dan 5'e / forward: 0 to 5
13  for (byte i = 0; i < LED_SAYISI; i++) {
14    digitalWrite(ledPinleri[i], HIGH);
15    delay(BEKLEME);
16    digitalWrite(ledPinleri[i], LOW);
17  }
18  // geri: 4'ten 1'e, uçlar tekrar yanmaz / backward: 4 to 1, ends are not repeated
19  for (int i = LED_SAYISI - 2; i > 0; i--) {
20    digitalWrite(ledPinleri[i], HIGH);
21    delay(BEKLEME);
22    digitalWrite(ledPinleri[i], LOW);
23  }
24}

La boucle aller allume et éteint chaque LED pendant 100 ms, de 0 à 5. La boucle retour part de 4 et s'arrête à 1 ; comme elle n'allume pas une seconde fois les LED des extrémités, la lumière repart sans marquer de pause aux bouts. Dans la boucle retour, nous avons utilisé int comme compteur, car byte est non signé et ne peut pas descendre sous 0 ; si tu utilises un byte dans une boucle qui attend un compteur négatif, il repasse de 0 à 255 et la boucle ne se termine jamais. Pour changer l'ordre de l'effet, il suffit de permuter les nombres dans le tableau sans toucher au reste du code. Pour d'autres effets écrits avec la même logique, consulte l'article Knight Rider et LED chenillard.

Exemple 2 : moyenne de capteur avec un tableau (moyenne glissante)

Les valeurs lues sur des capteurs analogiques comme un potentiomètre, une LDR ou un capteur d'humidité du sol oscillent en permanence de quelques unités. Le moyen le plus simple de réduire ce bruit est de faire la moyenne des N dernières lectures. Tu gardes les 10 dernières lectures dans un tableau et, à chaque nouvelle mesure, tu retires la plus ancienne de la somme et tu ajoutes la nouvelle. Comme on revient à l'index 0 quand on arrive à la fin du tableau, cette structure s'appelle un tampon circulaire (ring buffer). Mettre la somme à jour par soustraction-addition plutôt que de la recalculer à chaque fois garde le calcul rapide, même si la fenêtre monte à 100 éléments. Pendant les 10 premières lectures, le tableau n'est pas encore plein : la moyenne monte donc depuis zéro et se stabilise sur la vraie valeur après environ une demi-seconde. Branche la sortie du capteur sur A0 (par exemple la broche centrale du potentiomètre) et observe le résultat en deux courbes dans le traceur série (Serial Plotter) :

C++ (Arduino IDE)
1const byte PENCERE = 10;            // ortalama alınacak okuma sayısı / number of readings to average
2int okumalar[PENCERE];              // global dizi sıfırla başlar / global array starts at zero
3byte indeks = 0;                    // sıradaki hücre / next slot
4long toplam = 0;                    // taşmasın diye long / long to avoid overflow
5
6void setup() {
7  Serial.begin(9600);
8}
9
10void loop() {
11  int yeni = analogRead(A0);
12  toplam -= okumalar[indeks];       // en eski okumayı çıkar / remove the oldest reading
13  okumalar[indeks] = yeni;          // yerine yenisini yaz / store the new one
14  toplam += yeni;                   // toplama ekle / add to the total
15  indeks++;
16  if (indeks >= PENCERE) {          // sona gelince başa dön / wrap around at the end
17    indeks = 0;
18  }
19  int ortalama = toplam / PENCERE;
20  Serial.print(yeni);               // ham değer / raw value
21  Serial.print(" ");
22  Serial.println(ortalama);         // yumuşatılmış değer / smoothed value
23  delay(50);
24}
Sur l'Uno, un int peut contenir au maximum 32 767. La somme de 64 lectures analogiques allant jusqu'à 1023 fait 65 472 : une variable int déborde et repasse en nombre négatif. Utilise toujours long pour les sommes et les moyennes. Plus la fenêtre est grande, plus la sortie est lisse, mais plus elle réagit lentement aux changements ; 10 lectures espacées de 50 ms, soit une fenêtre d'une demi-seconde, sont un bon point de départ pour la plupart des capteurs. Pour des méthodes plus avancées, lis l'article filtrage des données de capteur.

Exemple 3 : stocker les notes d'une mélodie dans un tableau

Une mélodie se compose en fait de deux listes : quelle note jouer (la fréquence) et combien de temps elle dure. Tu stockes ces deux informations dans deux tableaux parallèles de même longueur : melodi[i] et sureler[i] correspondent toujours à la même note. Branche le plus (+) d'un buzzer passif sur la broche 8 et le moins (−) sur GND. Le code ci-dessous joue les deux premiers vers de « Twinkle Twinkle Little Star » et laisse un silence d'un tiers de la durée entre les notes pour bien les séparer. Pour ajouter une nouvelle chanson, il suffit de remplir les deux tableaux ; la boucle de lecture ne change pas. Si les deux tableaux n'ont pas le même nombre d'éléments, la boucle dépasse la fin du plus court, donc écris le même nombre d'éléments sur chaque ligne pour éviter l'erreur. Si de longues mélodies commencent à saturer la RAM de l'Uno, tu peux déplacer les tableaux dans la mémoire flash avec PROGMEM. Si tu ne connais pas la différence entre buzzer actif et passif, lis qu'est-ce qu'un buzzer.

C++ (Arduino IDE)
1#define NOTA_DO  262   // Hz
2#define NOTA_RE  294
3#define NOTA_MI  330
4#define NOTA_FA  349
5#define NOTA_SOL 392
6#define NOTA_LA  440
7
8const byte BUZZER_PIN = 8;   // pasif buzzer / passive buzzer
9
10// notalar ve süreler aynı sırada / notes and durations in the same order
11const int melodi[] = {NOTA_DO, NOTA_DO, NOTA_SOL, NOTA_SOL, NOTA_LA, NOTA_LA, NOTA_SOL,
12                      NOTA_FA, NOTA_FA, NOTA_MI, NOTA_MI, NOTA_RE, NOTA_RE, NOTA_DO};
13const int sureler[] = {400, 400, 400, 400, 400, 400, 800,
14                       400, 400, 400, 400, 400, 400, 800};
15const int NOTA_SAYISI = sizeof(melodi) / sizeof(melodi[0]);   // 14
16
17void setup() {
18  for (int i = 0; i < NOTA_SAYISI; i++) {
19    tone(BUZZER_PIN, melodi[i], sureler[i]);   // notayı çal / play the note
20    delay(sureler[i] + sureler[i] / 3);         // nota + kısa boşluk / note + short gap
21  }
22  noTone(BUZZER_PIN);
23}
24
25void loop() {
26}

Tableaux multidimensionnels : stocker des données sous forme de table

Un tableau à deux dimensions est une table de lignes et de colonnes. int tablo[4][3] est un tableau de 12 éléments, 4 lignes et 3 colonnes ; tu accèdes à un élément avec tablo[ligne][colonne], et les deux index commencent à 0. En mémoire, les lignes sont placées les unes après les autres : cette table occupe donc 4 × 3 × 2 = 24 octets sur l'Uno. Les motifs de matrice de LED 8x8, les cartes de touches d'un clavier matriciel et les tables d'états sont des usages typiques des tableaux à deux dimensions. Dans l'exemple ci-dessous, nous avons écrit chaque état du feu tricolore sur une ligne : les trois premières colonnes indiquent si la LED rouge, jaune et verte doit s'allumer, et la quatrième colonne donne la durée de cet état en millisecondes. Tu peux brancher les LED sur les trois premières broches du tableau de brochage (D2 rouge, D3 jaune, D4 vert). Nous avons calculé le nombre de lignes avec sizeof(durumlar) / sizeof(durumlar[0]) ; ici sizeof(durumlar[0]) donne la taille d'une ligne entière. Pour ajouter un état au feu, il suffit d'écrire une ligne dans la table, le code de loop() reste identique. Cette approche qui sépare la logique des données te servira aussi plus tard pour construire une machine à états.

C++ (Arduino IDE)
1const byte trafikPinleri[3] = {2, 3, 4};   // kırmızı, sarı, yeşil / red, yellow, green
2
3// her satır bir durum: {kırmızı, sarı, yeşil, süre ms} / each row: {red, yellow, green, time ms}
4const unsigned int durumlar[4][4] = {
5  {1, 0, 0, 5000},   // kırmızı / red
6  {1, 1, 0, 1500},   // kırmızı + sarı / red + yellow
7  {0, 0, 1, 5000},   // yeşil / green
8  {0, 1, 0, 1500}    // sarı / yellow
9};
10const byte DURUM_SAYISI = sizeof(durumlar) / sizeof(durumlar[0]);   // 4 satır / 4 rows
11
12void setup() {
13  for (byte i = 0; i < 3; i++) {
14    pinMode(trafikPinleri[i], OUTPUT);
15  }
16}
17
18void loop() {
19  for (byte d = 0; d < DURUM_SAYISI; d++) {          // satırları gez / walk the rows
20    for (byte led = 0; led < 3; led++) {              // sütunları gez / walk the columns
21      digitalWrite(trafikPinleri[led], durumlar[d][led] ? HIGH : LOW);
22    }
23    delay(durumlar[d][3]);                            // durumun süresi / duration of the state
24  }
25}

Les tableaux sur ESP32 et Raspberry Pi Pico

Sur ESP32, les tableaux s'écrivent avec la même syntaxe C++ que sur l'Arduino Uno et les exemples ci-dessus compilent sans modification ; il suffit d'adapter les numéros de broches. Pour l'exemple des LED, remplace la ligne du tableau par {13, 14, 27, 26, 25, 33} ; les broches 6 à 11 sont réservées à la mémoire flash interne, ne les mets donc pas dans le tableau. Sur ESP32, un int fait 4 octets et plus de 300 Ko de RAM sont disponibles pour tes programmes ; un tableau de 10 000 mesures, impossible sur l'Uno, y tient sans problème. Les lectures analogiques de l'ESP32 vont de 0 à 4095, donc les nombres seront plus grands dans l'exemple de moyenne glissante, mais la logique est la même. Si tu utilises le Raspberry Pi Pico avec MicroPython, tu emploies des listes à la place des tableaux : la taille n'est pas fixe, tu peux ajouter des éléments avec append() et connaître la longueur avec len(). Les index négatifs sont aussi valides dans une liste ; ledler[-1] donne le dernier élément. Mettre directement des objets Pin dans la liste simplifie beaucoup le code :

MicroPython
1from machine import Pin
2import time
3
4led_pinleri = [14, 13, 12, 11, 10, 9]            # GP14 -> GP9 sırası / order
5ledler = [Pin(p, Pin.OUT) for p in led_pinleri]  # Pin nesnelerinden liste / list of Pin objects
6print("LED sayisi / LED count:", len(ledler))
7
8while True:
9    for led in ledler:                           # ileri / forward
10        led.on()
11        time.sleep_ms(100)
12        led.off()
13    for i in range(len(ledler) - 2, 0, -1):      # geri, uçlar hariç / backward, ends skipped
14        ledler[i].on()
15        time.sleep_ms(100)
16        ledler[i].off()

Erreurs de dépassement et erreurs courantes avec les tableaux

ErreurSymptômeSolution
Utiliser inférieur ou égal dans la condition de boucleAu dernier tour, lecture ou écriture hors du tableau ; valeurs absurdes, réinitialisationsMets la condition i < ADET
Commencer l'index à 1Le premier élément est sauté et il y a un dépassement au dernier tourLes index vont de 0 à N-1
Prendre le résultat de sizeof(tableau) pour le nombre d'élémentsAvec un tableau d'int, la boucle tourne deux fois trop sur Uno, quatre fois trop sur ESP32Utilise sizeof(tableau) / sizeof(tableau[0])
Utiliser sizeof dans une fonctionLe tableau est passé comme adresse ; sizeof renvoie 2 ou 4Envoie le nombre d'éléments en paramètre séparé
Garder la somme dans une variable intMoyenne négative quand 32 767 est dépassé sur UnoUtilise long pour la somme
Ne pas initialiser un tableau dans une fonctionValeurs initiales aléatoires dans un tableau localRemets à zéro avec int a[10] = {0};
Affecter un tableau à un autre avec =Erreur de compilation : invalid array assignmentCopie avec une boucle for ou avec memcpy
Déclarer un très gros tableau sur l'UnoAvertissement de mémoire faible, blocages et réinitialisationsUtilise byte, déplace les tables constantes dans PROGMEM
Sur l'Uno, les tables qui ne changent pas (notes de mélodie, motifs de caractères, valeurs de calibration) sont copiées en RAM au démarrage, même si tu écris const. Déplace les gros tableaux constants dans la mémoire flash avec le mot-clé PROGMEM et lis-les avec des fonctions comme pgm_read_word() ; tu utilises ainsi les 32 Ko de flash et tu protèges les 2 Ko de RAM. Sur ESP32 et Pico, les tableaux const restent déjà en flash. Si tu soupçonnes que la mémoire est pleine, lis l'article Arduino mémoire insuffisante.

Idées de projets à faire avec des tableaux

  • Pack d'effets LED : garde les motifs dans un tableau à deux dimensions et joue chaque ligne comme une image d'animation ; gère les effets Knight Rider et LED chenillard avec une seule boucle.
  • Jeu de mémoire Simon : stocke la séquence de couleurs générée au hasard dans un tableau et compare-la aux boutons appuyés par le joueur ; pour des idées similaires, regarde les projets de jeux Arduino.
  • Serrure à code : garde le bon code dans un tableau de char, écris les touches saisies sur un clavier matriciel dans un second tableau et compare-les élément par élément.
  • Animations de matrice LED : stocke des motifs 8x8 dans des tableaux d'octets et affiche-les sur une matrice de LED MAX7219.
  • Enregistreur de données quotidien : garde les températures de chaque heure dans un tableau de 24 éléments et calcule le minimum, le maximum et la moyenne de la journée ; tu peux utiliser un DHT11 comme capteur.
  • Boîte à musique : stocke plusieurs chansons dans des tableaux séparés et passe de l'une à l'autre avec un bouton.

Les tableaux sont la brique de base qui entre en jeu dès que tu manipules plus de quelques variables en programmation Arduino : listes de broches, historique de mesures, mélodies et motifs sont tous gérés avec des tableaux. Pour comprendre la différence entre les tableaux de char et la classe String quand tu travailles avec du texte, continue avec l'article utiliser String sur Arduino. Dans l'application BlueGrays, tu peux étudier pas à pas les projets de LED chenillard, Knight Rider, feu tricolore et hymne joué au buzzer, avec le code prêt à l'emploi écrit avec des tableaux et les schémas de montage.

Questions fréquentes

Comment trouver le nombre d'éléments d'un tableau Arduino ?

Sur Arduino, il n'existe pas de fonction length() toute faite pour les tableaux. Tu obtiens le nombre d'éléments avec la formule sizeof(tableau) / sizeof(tableau[0]) : la première partie donne le nombre total d'octets, la seconde la taille d'un élément. Cette formule ne fonctionne correctement qu'à l'endroit où le tableau est déclaré ; pour un tableau passé à une fonction, elle renvoie la taille d'un pointeur.

L'index d'un tableau Arduino commence-t-il à 0 ou à 1 ?

Dans le langage Arduino, basé sur C et C++, l'index d'un tableau commence toujours à 0. Dans un tableau de 10 éléments, le premier est tableau[0] et le dernier tableau[9]. Accéder à tableau[10] ne provoque pas d'erreur de compilation, mais corrompt la mémoire située en dehors du tableau.

Peut-on changer la taille d'un tableau Arduino après coup ?

Non, la taille d'un tableau normal est fixée à la compilation et ne peut pas être agrandie pendant l'exécution. La solution pratique est de déclarer un tableau de la taille maximale dont tu pourrais avoir besoin et de garder dans un compteur à part le nombre d'éléments remplis. Allouer de la mémoire dynamique avec malloc ou new est possible, mais déconseillé sur un Uno de 2 Ko de RAM à cause de la fragmentation mémoire.

Comment déclarer un tableau de chaînes de caractères sur Arduino ?

Pour stocker plusieurs textes, on utilise un tableau de pointeurs de la forme const char* renkler[] = {"Kirmizi", "Sari", "Yesil"}; et on accède au texte "Sari" avec renkler[1]. Un texte seul est un tableau de caractères de la forme char isim[] = "Arduino"; qui se termine par un caractère invisible '\0'. Tu peux aussi écrire des tableaux d'objets String, mais ils consomment la RAM plus vite sur l'Uno.

Combien d'éléments un tableau peut-il contenir au maximum sur Arduino Uno ?

La limite est fixée par la RAM : l'Uno a 2048 octets de RAM au total, dont une partie est utilisée par Serial et les autres variables. En pratique, un tableau d'environ 1500 octets, soit 1500 byte ou 750 int, est proche de la limite. Si tu déplaces les tables constantes en mémoire flash avec PROGMEM, tu peux stocker beaucoup plus de données ; l'ESP32 et le Pico disposent de centaines de Ko de RAM.

Comment copier un tableau dans un autre sur Arduino ?

En C++, on ne peut pas copier un tableau en écrivant cible = source; le compilateur renvoie une erreur. Tu peux copier les éléments un par un avec une boucle for ou utiliser la commande memcpy(cible, source, sizeof(source));. Assure-toi que les deux tableaux ont le même type et la même taille ; si la cible est plus petite, memcpy provoque aussi un dépassement.

Voir tous les projets
Feu de circulation
AR-3Débutant

Feu de circulation

Une copie miniature du feu tricolore que tu vois chaque jour dans la rue. Le rouge reste allumé deux secondes, l'orange brille un court instant, le vert reste deux secondes, puis on revient au rouge…

4.8(137)
440
Chenillard à LED
AR-5Intermédiaire

Chenillard à LED

Des lumières qui s'allument l'une après l'autre, comme si elles couraient. L'Arduino allume six LED une par une ; chacune brille un court instant puis s'éteint, et la lumière parcourt la rangée du…

4.6(87)
218
Chenillard K2000 à LED
AR-6Intermédiaire

Chenillard K2000 à LED

Le fameux balayage lumineux : un point de lumière glisse d'un bout à l'autre de six LED, puis revient.

4.8(107)
214
Chenillard à LED à vitesse réglable
AR-7Intermédiaire

Chenillard à LED à vitesse réglable

Six LED s'allument l'une après l'autre et la lumière semble courir d'un bout à l'autre.

4.6(72)
148
Chenillard K2000 à vitesse réglable
AR-8Intermédiaire

Chenillard K2000 à vitesse réglable

Une lumière court d'un bout à l'autre de six LED, fait demi-tour et repart. En tournant le bouton du potentiomètre, tu changes aussitôt la vitesse de sa course : bouton d'un côté, la lumière file…

4.5(60)
124
Hymne national turc avec un buzzer
AR-15Intermédiaire

Hymne national turc avec un buzzer

Appuie sur le bouton et un petit buzzer se met à jouer l'hymne national turc, note après note.

4.8(114)
235
LED Chenillard ESP32 (Knight Rider)
ES-6Débutant

LED Chenillard ESP32 (Knight Rider)

6 LED se déplaçant séquentiellement de gauche à droite et de droite à gauche (style Knight Rider). Exemple de base de l'utilisation d'une boucle for et d'un tableau. Enseigne la logique du changement de direction.

4.5(19)
33
Raspberry Pi Pico Chenillard LED (6 LEDs)
PI-7Débutant

Raspberry Pi Pico Chenillard LED (6 LEDs)

L'animation classique du chenillard avec le Pico, en version 6 LED ! Six LED s'allument l'une après l'autre de gauche à droite, comme si la lumière marchait le long de la rangée. Tu apprends les listes Python (LED_PINS = [14, 13, 12, 11, 10, 9]), les compréhensions de liste, le contrôle des broches avec une boucle for et enumerate(). Six LED sur les broches GP9-GP14, chacune avec une résistance de limitation de 220Ω.

5.0(1)
9