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.

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ées | Taille d'un élément (Uno) | Taille d'un élément (ESP32 / Pico, C++) | Tableau de 100 éléments (Uno) |
|---|---|---|---|
| byte / uint8_t | 1 octet | 1 octet | 100 octets |
| char | 1 octet | 1 octet | 100 octets |
| int | 2 octets | 4 octets | 200 octets |
| unsigned int | 2 octets | 4 octets | 200 octets |
| long | 4 octets | 4 octets | 400 octets |
| float | 4 octets | 4 octets | 400 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 :
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éclaration | Signification |
|---|---|
| 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 |
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.
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 Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| LED 1 (ledPinleri[0]) | D2 | GPIO 13 | GP14 |
| LED 2 (ledPinleri[1]) | D3 | GPIO 14 | GP13 |
| LED 3 (ledPinleri[2]) | D4 | GPIO 27 | GP12 |
| LED 4 (ledPinleri[3]) | D5 | GPIO 26 | GP11 |
| LED 5 (ledPinleri[4]) | D6 | GPIO 25 | GP10 |
| LED 6 (ledPinleri[5]) | D7 | GPIO 33 | GP9 |
| Cathode (patte courte) | GND via 220 Ω | GND via 220 Ω | GND via 220 Ω |
- Place les LED dans l'ordre sur la breadboard ; relie les pattes courtes (cathodes) à la ligne GND via des résistances de 220 Ω.
- Relie les pattes longues aux broches 2 à 7 de l'Arduino, dans l'ordre du tableau.
- É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.
- Dans setup(), mets toutes les broches en OUTPUT avec une seule boucle for.
- Dans loop(), crée l'effet Knight Rider avec deux boucles, l'une aller et l'autre retour, puis téléverse le code.
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) :
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}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.
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.
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 :
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
| Erreur | Symptôme | Solution |
|---|---|---|
| Utiliser inférieur ou égal dans la condition de boucle | Au dernier tour, lecture ou écriture hors du tableau ; valeurs absurdes, réinitialisations | Mets la condition i < ADET |
| Commencer l'index à 1 | Le premier élément est sauté et il y a un dépassement au dernier tour | Les index vont de 0 à N-1 |
| Prendre le résultat de sizeof(tableau) pour le nombre d'éléments | Avec un tableau d'int, la boucle tourne deux fois trop sur Uno, quatre fois trop sur ESP32 | Utilise sizeof(tableau) / sizeof(tableau[0]) |
| Utiliser sizeof dans une fonction | Le tableau est passé comme adresse ; sizeof renvoie 2 ou 4 | Envoie le nombre d'éléments en paramètre séparé |
| Garder la somme dans une variable int | Moyenne négative quand 32 767 est dépassé sur Uno | Utilise long pour la somme |
| Ne pas initialiser un tableau dans une fonction | Valeurs initiales aléatoires dans un tableau local | Remets à zéro avec int a[10] = {0}; |
| Affecter un tableau à un autre avec = | Erreur de compilation : invalid array assignment | Copie avec une boucle for ou avec memcpy |
| Déclarer un très gros tableau sur l'Uno | Avertissement de mémoire faible, blocages et réinitialisations | Utilise byte, déplace les tables constantes dans PROGMEM |
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.
Projets à réaliser après cet article
Voir tous les projets
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…

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…

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

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.

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…

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.

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.

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Ω.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

