Arduino Uno R4 WiFi et Minima : différences avec l'Uno R3

L'Arduino Uno R4 est la quatrième version de l'Uno, la carte de développement la plus utilisée au monde, et le premier Uno doté d'un processeur 32 bits au lieu d'un AVR 8 bits. Il existe en deux modèles : l'Uno R4 Minima, simple et moins cher, et l'Uno R4 WiFi, avec Wi-Fi, Bluetooth et une matrice de LED 12x8. Les deux gardent la taille, le brochage et la tension de fonctionnement de 5 V du R3, si bien que la plupart des shields et des montages se branchent tels quels. En revanche, la mémoire programme est 8 fois plus grande, le processeur 3 fois plus rapide, et on gagne une vraie sortie analogique (DAC), un bus CAN, une horloge intégrée (RTC) et la prise en charge du clavier et de la souris USB.

Dans ce guide, tu verras précisément en quoi le R4 se distingue du R3, comment choisir entre le Minima et le WiFi, quels anciens croquis et bibliothèques fonctionnent sans souci et lesquels ne compilent pas, et pourquoi tu dois respecter la limite de 8 mA par broche. Pour finir, nous réaliserons ton premier projet, qui utilise ensemble la matrice de LED et le Wi-Fi du R4 WiFi et se pilote depuis ton téléphone.

Qu'est-ce que l'Arduino Uno R4 ? Les modèles Minima et WiFi

Au cœur des deux modèles se trouve le microcontrôleur RA4M1 (R7FA4M1AB3CFM) de Renesas : un cœur Arm Cortex-M4 à 48 MHz avec unité de calcul à virgule flottante (FPU). Contrairement à la plupart des cartes 32 bits, cette puce fonctionne en 5 V, et c'est la raison principale pour laquelle Arduino a choisi le RA4M1 pour le R4. Le Minima n'embarque que cette puce. Le modèle WiFi ajoute un module ESP32-S3-MINI-1, qui fournit le Wi-Fi et le Bluetooth et sert aussi de pont pour dialoguer avec ton ordinateur en USB. Comme l'ESP32-S3 fonctionne en 3,3 V, un convertisseur de niveaux est placé entre les deux puces.

Différences entre l'Uno R3 et l'Uno R4

Les lignes les plus importantes du tableau sont la mémoire et la vitesse. Les 2 Ko de SRAM du R3 se remplissent avec quelques variables String et un tampon d'écran ; dans les projets avec écran OLED, longs tableaux ou traitement JSON, la carte se met à se figer ou à redémarrer au hasard. Les 32 Ko du R4 font presque disparaître ce problème. Grâce à la FPU, les calculs en float (étalonnage de capteurs, PID, trigonométrie) sont faits par le matériel et vont bien plus vite que sur le R3. L'alimentation change aussi beaucoup : le régulateur linéaire du R3 chauffe en 12 V, alors que le R4 utilise un convertisseur à découpage (buck) ; la carte accepte donc jusqu'à 24 V et chauffe beaucoup moins.

Le nouveau matériel apporté par le R4

• DAC 12 bits (A0) : contrairement au PWM, il produit une vraie tension analogique ; on l'utilise pour l'audio, les sinusoïdes et un petit générateur de signaux. La bibliothèque analogWave du paquet de la carte génère des ondes sinusoïdales, carrées et en dents de scie en une seule ligne.
• Convertisseur analogique-numérique 14 bits : avec analogReadResolution(14), tu lis des valeurs de 0 à 16383 ; avec une référence de 5 V, un pas vaut environ 0,3 mV, contre 4,9 mV sur le R3. Pour ne pas casser les anciens croquis, la résolution par défaut reste de 10 bits.
• Amplificateur opérationnel intégré : sur les broches A1 (+), A2 (–) et A3 (sortie) ; tu peux amplifier de petits signaux de capteurs sans puce supplémentaire. Pour les bases, consulte Qu'est-ce qu'un amplificateur opérationnel ?
• Bus CAN : le bus de communication robuste des voitures et de l'industrie ; on l'utilise avec un module transceiver comme le SN65HVD230 ou le TJA1050 et la bibliothèque Arduino_CAN du paquet de la carte.
• RTC : garde la date et l'heure sans module supplémentaire (bibliothèque RTC.h). Sur le R4 WiFi, si tu branches une pile de 1,6 à 3,6 V sur la broche VRTC, l'horloge continue de tourner même quand l'alimentation de la carte est coupée.
• USB HID : la carte peut se présenter à l'ordinateur comme un clavier ou une souris ; autrefois, il fallait un Leonardo (clavier USB avec l'Arduino Leonardo).
• Détection tactile capacitive : certaines broches peuvent servir de boutons tactiles sans module supplémentaire grâce à la bibliothèque Arduino_CapacitiveTouch.

Tu peux tester deux de ces fonctions tout de suite. Le croquis ci-dessous envoie des tensions croissantes sur le DAC et relit cette même tension avec le convertisseur 14 bits. Il suffit de relier les broches A0 et A1 avec un fil de liaison et d'ouvrir le Moniteur série à 115200 bauds :

1// A0 (DAC) ile A1'i bir jumper kabloyla bağla / connect A0 (DAC) to A1 with a jumper wire
2
3void setup() {
4  Serial.begin(115200);
5  while (!Serial) {}            // USB seri port açılana kadar bekle / wait for the USB serial port
6  analogWriteResolution(12);    // DAC: 0–4095
7  analogReadResolution(14);     // ADC: 0–16383
8}
9
10void loop() {
11  for (int value = 0; value < 4096; value += 512) {
12    analogWrite(DAC, value);              // A0'dan gerçek analog gerilim / true analog voltage on A0
13    delay(10);
14    int raw = analogRead(A1);             // 14 bit okuma / 14-bit reading
15    float volts = raw * 5.0 / 16383.0;    // 5 V referans / 5 V reference
16    Serial.print("DAC: ");
17    Serial.print(value);
18    Serial.print("  ADC: ");
19    Serial.print(raw);
20    Serial.print("  V: ");
21    Serial.println(volts, 3);
22    delay(500);
23  }
24}

Dans la sortie, tu verras la valeur lue augmenter d'environ 2048 chaque fois que la valeur du DAC augmente de 512 : un pas de la sortie 12 bits correspond à 4 pas de l'entrée 14 bits. Nous avons calculé avec 5,0 V, mais quand la carte est alimentée en USB, la ligne 5 V descend à environ 4,7 V à cause de la diode de protection. Si tu veux des mesures précises, mesure la broche 5V au multimètre et mets cette valeur à la place de 5.0 dans la formule. La ligne while (!Serial) évite de perdre les premières lignes avant l'ouverture du Moniteur série ; si la carte doit fonctionner sans ordinateur, supprime-la, sinon le programme reste bloqué à cet endroit. Tu trouveras les bases de la lecture analogique dans l'article ADC et conversion analogique-numérique.

La limite de courant par broche : pourquoi 8 mA sur le R4 ?

C'est la différence que l'on oublie le plus souvent en passant au R4. L'ATmega328P du R3 fournit sans peine 20 mA par broche (40 mA en maximum absolu), c'est pourquoi la plupart des exemples en ligne branchent une LED directement sur une broche avec une résistance de 220 Ω. Pour le R4, Arduino indique en revanche au maximum 8 mA par broche. Faisons le calcul avec la loi d'Ohm : en alimentant une LED rouge (environ 2 V) depuis une broche 5 V à travers 220 Ω, le courant vaut (5 − 2) / 220 ≈ 13,6 mA, presque le double de la limite du R4. La LED s'allumera très probablement, mais la broche peut s'abîmer avec le temps, et ces dégâts s'accumulent le plus souvent sans qu'on s'en aperçoive.

Les anciens croquis et bibliothèques fonctionnent-ils sur le R4 ?

Réponse courte : la plupart, oui. Les croquis écrits avec les commandes Arduino standard comme digitalWrite, analogRead, millis, Serial, Wire (I2C), SPI, EEPROM, Servo et tone compilent sur le R4 sans modification. Les problèmes apparaissent dans le code qui accède directement au matériel de l'ATmega328P : les manipulations rapides de broches via des registres comme PORTB et DDRD, les réglages du Timer1, les fichiers d'en-tête commençant par avr/ et les bibliothèques qui les utilisent ne compilent pas sur le R4. Par exemple, un croquis qui utilise PORTB échoue avec 'PORTB' was not declared in this scope.

À la compilation, tu verras peut-être un avertissement comme WARNING: library LiquidCrystal I2C claims to run on avr architecture(s) and may be incompatible with your current board which runs on renesas_uno architecture(s). Ce n'est pas une erreur ; l'auteur de la bibliothèque a simplement indiqué uniquement AVR comme architecture prise en charge. Si le croquis se téléverse et fonctionne, tout va bien. Si tu obtiens une vraie erreur, installe d'abord la dernière version de la bibliothèque (ajouter une bibliothèque Arduino) ; si cela ne suffit pas, cherche une alternative compatible avec le R4.

Une autre différence mérite ton attention : le R3 n'a qu'un seul port série, relié à la fois à l'USB et aux broches D0/D1. Sur le R4, Serial correspond uniquement à l'USB, et les broches D0 et D1 fonctionnent séparément sous le nom Serial1. Un ancien croquis qui lit avec Serial un module branché sur D0/D1, comme un Bluetooth HC-05 ou un GPS, ne recevra rien sur le R4. Le croquis passerelle ci-dessous transmet au Moniteur série les données du module, et au module ce que tu tapes dans le Moniteur série :

1// R4'te Serial = USB, Serial1 = D0 (RX) ve D1 (TX) / on the R4, Serial = USB, Serial1 = D0 (RX) and D1 (TX)
2
3void setup() {
4  Serial.begin(115200);   // bilgisayar (Seri Monitör) / computer (Serial Monitor)
5  Serial1.begin(9600);    // D0/D1'e bağlı modül, örn. HC-05 / module on D0/D1, e.g. HC-05
6}
7
8void loop() {
9  if (Serial1.available()) {
10    Serial.write(Serial1.read());   // modülden bilgisayara / module to computer
11  }
12  if (Serial.available()) {
13    Serial1.write(Serial.read());   // bilgisayardan modüle / computer to module
14  }
15}

Installer l'Uno R4 dans l'IDE Arduino

1. Installe ou mets à jour l'IDE Arduino 2 (installer l'IDE Arduino).
2. Ouvre le Gestionnaire de cartes à gauche, tape UNO R4 et installe le paquet Arduino UNO R4 Boards. C'est un paquet officiel, tu n'as donc pas besoin d'ajouter d'URL.
3. Branche la carte avec un câble USB-C qui transmet les données et choisis Arduino UNO R4 Minima ou Arduino UNO R4 WiFi dans Outils > Carte.
4. Choisis le port de la carte dans Outils > Port, ouvre Fichier > Exemples > 01.Basics > Blink et téléverse-le. La LED intégrée sur D13 se met à clignoter.
5. Si aucun port n'apparaît ou si le téléversement s'arrête en cours de route, appuie deux fois rapidement sur le bouton RESET : la carte passe en mode bootloader et le port réapparaît. Pour tous les problèmes de téléversement, consulte le guide le téléversement Arduino échoue.

Uno R4 WiFi : l'ESP32-S3 et la matrice de LED 12x8

Par défaut, l'ESP32-S3 du R4 WiFi exécute un micrologiciel installé par Arduino qui transforme les commandes du RA4M1 en opérations Wi-Fi et Bluetooth. Tu continues à programmer le RA4M1 : pour le Wi-Fi, tu utilises la bibliothèque WiFiS3 fournie avec le paquet de la carte, et pour le Bluetooth la bibliothèque ArduinoBLE. Il y a deux limites importantes : le module ne se connecte qu'aux réseaux 2,4 GHz, et comme le Wi-Fi et le Bluetooth partagent l'antenne, tu ne peux pas utiliser les deux en même temps. Certaines fonctions récentes exigent un micrologiciel ESP32-S3 à jour ; tu peux le mettre à jour depuis Outils > Firmware Updater dans l'IDE.

La matrice sur la face avant de la carte se compose de 96 LED rouges sur 8 lignes et 12 colonnes. À sa sortie de la boîte, elle joue une animation de Tetris. Les LED sont reliées à 11 broches internes du RA4M1 selon une technique appelée charlieplexing ; ces broches ne sont pas sorties sur les connecteurs, donc utiliser la matrice ne te coûte aucune des broches D0–D13 ou A0–A5. La bibliothèque Arduino_LED_Matrix du paquet de la carte accepte une image (frame) sous deux formes : un tableau d'octets 8x12 ou trois nombres de 32 bits. La méthode du tableau est plus lisible, car tu vois directement dans le code la forme dessinée par les 1 :

1#include "Arduino_LED_Matrix.h"   // kart paketiyle gelir / ships with the board package
2
3ArduinoLEDMatrix matrix;
4
5// 8 satır x 12 sütun: 1 = LED yanar / 8 rows x 12 columns: 1 = LED on
6uint8_t kalp[8][12] = {
7  { 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0 },
8  { 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0 },
9  { 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 },
10  { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
11  { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 },
12  { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
13  { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
14  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
15};
16
17void setup() {
18  matrix.begin();
19}
20
21void loop() {
22  matrix.renderBitmap(kalp, 8, 12);          // kendi çizimin / your own drawing
23  delay(1000);
24  matrix.loadFrame(LEDMATRIX_EMOJI_HAPPY);   // kütüphanedeki hazır kare / ready-made frame from the library
25  delay(1000);
26  kalp[7][11] = 1;                           // tek bir LED'i yak: satır 7, sütun 11 / turn on one LED: row 7, column 11
27}

renderBitmap() affiche le tableau que tu as dessiné, tandis que loadFrame() charge des images toutes prêtes de la bibliothèque : LEDMATRIX_HEART_BIG, LEDMATRIX_EMOJI_HAPPY, LEDMATRIX_EMOJI_SAD et LEDMATRIX_DANGER en font partie. Avec loadSequence() et play(), tu peux lancer des animations toutes faites comme LEDMATRIX_ANIMATION_TETRIS ou LEDMATRIX_ANIMATION_WIFI_SEARCH. Pour écrire et faire défiler du texte sur la matrice, tu dois installer la bibliothèque ArduinoGraphics depuis le Gestionnaire de bibliothèques. Si tu veux un affichage plus grand, jette un œil aux articles matrice LED MAX7219 et WS2812B NeoPixel.

Premier projet : piloter la matrice de LED depuis ton téléphone

Combinons maintenant les deux fonctions. Pendant que la carte se connecte à ton réseau domestique, la matrice joue une animation de recherche Wi-Fi ; une fois connectée, elle affiche l'adresse IP en texte défilant. Quand tu ouvres cette adresse dans le navigateur d'un téléphone connecté au même réseau, des boutons te permettent d'afficher un cœur, un visage joyeux ou triste, de refaire défiler l'adresse IP ou d'éteindre la matrice. Tu n'as besoin d'aucun composant en plus de la carte.

1. Installe la bibliothèque ArduinoGraphics depuis le Gestionnaire de bibliothèques ; WiFiS3 et Arduino_LED_Matrix sont fournies avec le paquet de la carte.
2. Remplace le nom du réseau et le mot de passe dans le croquis par les tiens ; attention aux majuscules et minuscules.
3. Choisis Arduino UNO R4 WiFi comme carte, téléverse le croquis et ouvre le Moniteur série à 115200 bauds.
4. Saisis dans le navigateur de ton téléphone l'adresse IP qui défile sur la matrice ou s'affiche dans le Moniteur série.
5. Appuie sur les boutons de la page ; la matrice change instantanément.

1#include "ArduinoGraphics.h"      // Arduino_LED_Matrix'ten ÖNCE eklenmeli / must come BEFORE Arduino_LED_Matrix
2#include "Arduino_LED_Matrix.h"
3#include "WiFiS3.h"
4
5char ssid[] = "AgAdi";            // Wi-Fi adın / your Wi-Fi name
6char pass[] = "Sifre123";         // Wi-Fi şifren / your Wi-Fi password
7
8ArduinoLEDMatrix matrix;
9WiFiServer server(80);
10
11void scrollText(String text) {
12  matrix.beginDraw();
13  matrix.stroke(0xFFFFFFFF);
14  matrix.textScrollSpeed(60);             // her adım 60 ms / 60 ms per step
15  matrix.textFont(Font_5x7);
16  matrix.beginText(0, 1, 0xFFFFFF);
17  matrix.print("   " + text + "   ");
18  matrix.endText(SCROLL_LEFT);            // yazıyı sola kaydır / scroll the text to the left
19  matrix.endDraw();
20}
21
22void sendPage(WiFiClient &client) {
23  client.println("HTTP/1.1 200 OK");
24  client.println("Content-Type: text/html; charset=utf-8");
25  client.println("Connection: close");
26  client.println();
27  client.println("<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width'></head><body>");
28  client.println("<h2>UNO R4 WiFi</h2>");
29  client.println("<p><a href='/kalp'><button>Kalp / Heart</button></a></p>");
30  client.println("<p><a href='/mutlu'><button>Mutlu / Happy</button></a></p>");
31  client.println("<p><a href='/uzgun'><button>Uzgun / Sad</button></a></p>");
32  client.println("<p><a href='/ip'><button>IP</button></a></p>");
33  client.println("<p><a href='/kapat'><button>Kapat / Off</button></a></p>");
34  client.println("</body></html>");
35}
36
37void setup() {
38  Serial.begin(115200);
39  matrix.begin();
40
41  if (WiFi.status() == WL_NO_MODULE) {               // ESP32-S3 yanıt vermiyor / ESP32-S3 not responding
42    Serial.println("WiFi modulu bulunamadi / WiFi module not found");
43    matrix.loadFrame(LEDMATRIX_DANGER);
44    while (true) {}
45  }
46
47  matrix.loadSequence(LEDMATRIX_ANIMATION_WIFI_SEARCH);   // bağlanırken animasyon / animation while connecting
48  matrix.play(true);
49
50  while (WiFi.begin(ssid, pass) != WL_CONNECTED) {
51    Serial.println("Baglaniyor / connecting...");
52    delay(5000);
53  }
54  while (WiFi.localIP() == IPAddress(0, 0, 0, 0)) {   // DHCP adresini bekle / wait for the DHCP address
55    delay(100);
56  }
57
58  server.begin();
59  Serial.print("IP: ");
60  Serial.println(WiFi.localIP());
61  scrollText(WiFi.localIP().toString());     // IP adresini matriste göster / show the IP on the matrix
62  matrix.loadFrame(LEDMATRIX_EMOJI_HAPPY);
63}
64
65void loop() {
66  WiFiClient client = server.available();
67  if (!client) {
68    return;
69  }
70
71  String request = client.readStringUntil('\n');   // ör. "GET /kalp HTTP/1.1" / e.g. "GET /kalp HTTP/1.1"
72  while (client.available()) {
73    client.read();                                 // kalan başlıkları at / discard the remaining headers
74  }
75
76  bool showIp = false;
77  if (request.indexOf("GET /kalp") >= 0) {
78    matrix.loadFrame(LEDMATRIX_HEART_BIG);
79  } else if (request.indexOf("GET /mutlu") >= 0) {
80    matrix.loadFrame(LEDMATRIX_EMOJI_HAPPY);
81  } else if (request.indexOf("GET /uzgun") >= 0) {
82    matrix.loadFrame(LEDMATRIX_EMOJI_SAD);
83  } else if (request.indexOf("GET /kapat") >= 0) {
84    matrix.clear();
85  } else if (request.indexOf("GET /ip") >= 0) {
86    showIp = true;
87  }
88
89  sendPage(client);
90  delay(10);
91  client.stop();                                   // bağlantıyı kapat / close the connection
92
93  if (showIp) {
94    scrollText(WiFi.localIP().toString());         // sayfa gittikten sonra kaydır / scroll after the page is sent
95  }
96}

La logique est simple : WiFi.begin() est relancé jusqu'à ce que la connexion soit établie, puis le croquis attend que le DHCP attribue une adresse IP et démarre un serveur web sur le port 80. Il lit la première ligne de la requête du téléphone (par exemple « GET /kalp HTTP/1.1 »), détermine avec indexOf() quel bouton a été pressé et charge l'image correspondante sur la matrice. endText(SCROLL_LEFT) bloque le programme pendant le défilement du texte ; c'est pourquoi on ne refait défiler l'adresse IP qu'après avoir envoyé la page et fermé la connexion. Si la matrice affiche le symbole de danger et s'arrête, l'ESP32-S3 ne répond pas ; débranche puis rebranche le câble USB de la carte et mets à jour le micrologiciel. Si la connexion ne s'établit jamais, les vérifications sur le 2,4 GHz et le mot de passe de l'article l'ESP32 ne se connecte pas au Wi-Fi s'appliquent aussi ici.

Alimentation : broches VIN, 5V et 3,3 V

Le R4 accepte 6–24 V sur la prise jack ou la broche VIN ; le convertisseur buck de la carte les abaisse à 5 V. D'après la documentation d'Arduino pour le R4 WiFi, on peut tirer environ 1,2 A de la broche 5V quand la carte est alimentée par VIN ; en USB, la carte supporte jusqu'à 2 A, mais la vraie limite dépend du port USB de ton ordinateur. Ce courant est prévu pour des capteurs et de petits modules, pas pour des moteurs et des servos. La broche 3,3 V du Minima est alimentée par le régulateur interne du RA4M1 et ne suffit donc qu'à de petits capteurs ; n'y alimente pas de modules gourmands comme un ESP-01 ou un nRF24L01 avec antenne PA+LNA. Le R4 WiFi possède aussi une broche OFF (reliée à GND, elle coupe l'alimentation 5 V de la carte) et une broche VRTC pour la pile de la RTC. Pour toutes les options d'alimentation, consulte comment alimenter un Arduino.

Idées de projets avec l'Uno R4

• Station météo Wi-Fi : affiche la température mesurée avec un DHT11 en texte défilant sur la matrice et sur une page ouverte sur ton téléphone.
• Jeux sur la matrice : serpent, Tetris ou balle rebondissante sur la matrice 12x8 ; pour d'autres idées, consulte l'article projets de jeux Arduino.
• Horloge internet : récupère l'heure sur internet (NTP), écris-la dans la RTC intégrée et conserve-la pendant les coupures de courant grâce à une pile sur la broche VRTC.
• Clavier de macros USB : fabrique un pavé de quatre boutons qui déclenche des raccourcis sur ton ordinateur ; grâce à la prise en charge HID du R4, pas besoin de Leonardo.
• Du son avec le DAC : génère une sinusoïde sur A0 avec la bibliothèque analogWave et monte un synthétiseur simple avec un amplificateur audio et un haut-parleur.
• Lampe pilotée depuis le téléphone : associe le serveur web de cet article à un module relais et allume une lampe à distance.

Erreurs fréquentes et solutions

Lequel acheter : R3, R4 Minima ou R4 WiFi ?

• Uno R4 WiFi : le meilleur choix si tes projets doivent se connecter à internet, à un téléphone ou en Bluetooth, et si tu veux un afficheur déjà présent sur la carte. Il est aussi amusant pour les débutants, car tu vois tout de suite sur la matrice que ton code fonctionne.
• Uno R4 Minima : convient si tu n'as pas besoin de sans-fil et que tu veux plus de mémoire, de vitesse, un DAC et l'USB-C. Grâce à son connecteur SWD, c'est aussi une bonne option si tu veux brancher un débogueur externe et exécuter ton code pas à pas.
• Uno R3 ou clone compatible : reste pertinent si tu as d'anciens projets avec des bibliothèques propres à l'AVR, si tu veux suivre exactement les exemples d'un livre ou si tu cherches le coût le plus bas ; ses broches supportent 20 mA sans problème.
• ESP32 : si tu veux du Wi-Fi avec plus de broches et pour moins cher, une carte ESP32 mérite aussi réflexion ; n'oublie pas qu'elle fonctionne en 3,3 V (Arduino ou ESP32 ?).

En résumé, l'Uno R4 est une évolution qui garde la simplicité habituelle de l'Uno tout en ajoutant mémoire, vitesse et nouveau matériel ; garde simplement en tête la limite de 8 mA et la différence de Serial1. Pour connaître en détail les broches de la carte, jette un œil à l'article brochage de l'Arduino Uno. Dans l'application BlueGrays, tu trouveras des projets LED, bouton, capteur, LCD et matrice de LED pour l'Arduino Uno avec schémas et code pas à pas ; écrits avec des commandes standard, ils fonctionnent aussi sur le R4, il te suffit de passer les résistances des LED à 470 Ω.