arduiblog

Cet article avait déjà été publié en octobre 2023 dans la Bibliothèque Numérique des éditions ENI.

Mais il était réservé aux abonés. Alors, après avoir laissé l’exclusivité aux Editions ENI pendant 2 mois, je peux désormais le republier sur mon blog (disons donc que c’est votre cadeau de Noël).

Uno R3, l’actuel roi Arduino

Depuis sa sortie en 2011, l’Arduino Uno (R3) est devenu la référence dans le monde des cartes de développement. Non seulement la fondation Arduino a réussi à en vendre 10 millions d’exemplaire, mais si l’on ajoute les innombrables clones et contrefaçons (vendus parfois à des prix très attractifs), il faut certainement multiplier ce chiffre par 3, 4 (ou même peut être beaucoup plus…).

Une telle longévité est extrêmement rare dans le milieu de la tech où d’habitude les objets sont rapidement obsolètes. Mais, après 13 ans l’Arduino se vend encore très bien. Pourtant la fondation Arduino ne cesse pas d’innover :

• L’Arduino Leonardo possède le même format. Il est commercialisé (à peu près au même prix) depuis 2012 et en plus il peut être reconnu par l’ordinateur comme un périphérique USB (ce qui permet par exemple imiter un clavier et/ou une souris).
• D’autres déclinaisons de l’Arduino Uno (également au même format) se sont succédé avec de nouvelles fonctions (WiFi, Ethernet) ou des microcontrôleurs plus puissants.
• L’Arduino Mega surpasse l’Arduino Uno (R3) dans tout les domaines (microcontrôleurs plus puissants, plus de connecteurs), tout en restant assez compact et en conservant une compatibilité avec les cartes d’extensions (shield) de son petit frère.
• Il existe également des cartes plus compactes (Arduino Mini, Nano, Micro, MKR…), parfois plus puissantes et offrant de nouvelles fonctions (Wifi, GSM…).
• Et de nombreuses cartes répondant à des besoins plus spécifiques (Arduino Robot, Esplora, LilyPad…). Je n’en parlerai pas cette fois-ci mais elles mériteraient certainement un jour que je leur consacre un article…

Alors comment expliquer qu’en 2023, l’Arduino Uno (R3) reste toujours (et de très loin) le modèle le plus utilisé ?

• Il est fiable et robuste (en cas d’utilisation « normale », il est très rare qu’un Arduino tombe en panne).
• Bien sûr, il existe des modèles mieux équipés ou plus puissant, mais il reste suffisant pour réaliser de nombreux projet.
• Il est modulable, en cas de besoin, il est très facile d’ajouter de nouvelle fonctions (LED, Buzzer, moteurs, WiFi…).
• Son prix est raisonnable (pour un produit fabriqué en Europe). Une vingtaine d’Euros, c’est le prix d’un repas dans une pizzeria.
• Avec plusieurs dizaines de millions d’utilisateurs, sa communauté a atteint un masse critique, l’immense majorité de la documentation disponible lui est consacrée. Les débutants n’osent pas s’aventurer en terrain inconnu et ceux qui l’utilisent déjà n’éprouvent pas le besoin de le remplacer puisqu’il en sont satisfait.

Mais depuis quelques années, les concurrents ne se contentent plus de fabriquer de simples clones de l’Arduino. Ils innovent en proposant des cartes de développement plus performantes et beaucoup moins chères (notamment avec les microcontrôleurs ESP8266, ESP32 ou RP2040).

La fondation Arduino devait donc réagir et c’est ce qu’elle a fait en proposant, non pas un mais deux successeurs pour l’Arduino Uno R3. L’Arduino Uno R4 Minima et L’Arduino Uno R4 Wifi.

Arduino Uno R4 Minima

Le modèle de base semble plutôt proche de l’Arduino Uno R3. Tout a été fait pour que la transition entre l’ancien et le nouveau modèle soit la plus douce possible. L’Arduino Uno R4 Minima possède la même taille, les mêmes connecteurs (situés exactement au même endroit).

Il fonctionne même sous 5V, alors que la plupart des microcontrôleurs récent sont passés au 3,3V. Vous ne devriez donc rencontrer pas rencontrer de problèmes (au niveau matériel) en insérant une carte d’extension (shield) conçue à la base pour l’Arduino Uno R3.

Niveau logiciel, ça dépend. Les bibliothèques officielles de la fondation Arduino sont déjà compatible et les plus courantes devrait l’être rapidement. Mais si vous utilisez une bibliothèque propriétaire ou qui n’est pas souvent mise à jour, il est possible qu’elle ne fonctionne plus avec l’Arduino Uno R4. Vous trouverez à l’adresse suivante la liste (non exhaustive) des cartes shields compatible : https://docs.arduino.cc/tutorials/uno-r4-minima/shield-compatibility

L’IDE Arduino vérifie automatiquement que vous utilisez bien la dernière version des bibliothèques et des cartes, alors s’il vous demande de les mettre à jour, prenez le temps de le faire.

Prix et disponibilités

Depuis le 26 juin 2023, vous pouvez commander les versions Minima et WiFi sur le site officiel de la fondation. Les autres boutiques ont été approvisionnées plus tard (J’ai dû attendre un mois de plus pour recevoir mes cartes précommandées chez MC Hobby).

Comme vous pouvez le constater, l’Arduino Uno R4 Minima coûte beaucoup moins cher que l’Arduino Un R3.

Les prix ci dessus ne tiennent pas compte de la TVA et des frais de port (comptez environ 10 € de plus).

Premières constatations

En comparant visuellement les 2 cartes, nous remarquons déjà quelques différences.

Contrairement à l’Arduino Uno R3 qui laisse encore le choix entre la version DIP (microcontrôleur grand format et amovible) et la version SMD (microcontrôleur plus petit et soudé à la surface de la carte), l’Arduino Uno R4 existe seulement en version SMD. Cela explique peut être la différence de prix entre les 2 versions (puisque cela coûte moins cher à fabriquer).

Apparemment, le microcontrôleur RA4M1 n’existe pas en version DIP. Ce qui est bien dommage pour les plus bricoleurs. Dans certains cas, il peut être intéressant d’enlever le microcontrôleur pour le reprogrammer ou construire un clone d’Arduino Uno en utilisant un autre Arduino (sans microcontrôleur) comme contrôleur USB.

J’explique cela dans mon livre sur l’Arduino : Arduino, apprivoisez l’électronique et le codage (3e édition) – Chapitre 10 Autres cartes Arduino – Construire un clone de l’Arduino Uno

Bonne nouvelle, le vieillissant port USB (de type B) a enfin été remplacé par un port USB C. Une prise plus compacte, plus pratique à utiliser et maintenant beaucoup plus courante.

Il y a encore beaucoup de surface disponible sur le dessus de l’Arduino Uno R4 Minima. Le quadrillage dessiné permet de l’habiller en évoquant subtilement le milieu scolaire (qui sera certainement l’un des principaux débouché de cette carte). Bien sûr, j’aurais préféré un peu plus de fantaisie, mais la sobriété à aussi son charme et elle est quand même très belle.

Par contre je suis un peu déçu par le retour au bleu cobalt (une couleur un peu trop classique). La fondation Arduino nous avait habitué à sa couleur, le bleu canard (ou bleu Arduino) qui permettait de distinguer facilement les cartes officielles des clones. Alors pourquoi changer ce qui faisait pourtant sa spécificité ?

Caractéristiques techniques

Comme vous pouvez le voir sur ce tableau comparatif, le nouveau microcontrôleur de l’Arduino est beaucoup plus performant. Il fonctionnement plus rapidement et dispose de plus de mémoire. La gestion électrique de la carte a également été améliorée puisqu’elle accepte désormais une alimentation pouvant aller jusqu’à 24 V.

Cependant, le microcontrôleur Renesas RA4M1 semble un peu moins robuste que l’ATmega328P puisque le courant maximum utilisable sur une des sorties baisse de 20 mA à seulement 8 mA.

Attention, le dépassement de cette limite risquerait d’endommager l’Arduino, alors, pour alimenter une LED, je vous conseille vivement de remplacer la résistance habituelle (220 Ω) par une plus grosse (par exemple 470 ou 1000 Ω).

Arduino	Uno R3	Uno R4 Minima
Microcontrôleur	ATmega328P	Renesas RA4M1
Connecteur USB	USB-B	USB-C
Tension d’entrée (alimentation)	7 V à 12 V	6 V à 24 V
Tension de fonctionnement	5 V	5 V
Fréquence	16 MHz	48 MHz
Entrées analogiques	6	6
Sorties analogiques virtuelles (PWM)	6	6
Sortie analogique (DAC)	0	1
Entrées/sorties numériques	14	14
Courant maximum d’une sortie	20 mA	8 mA
EEPROM ou Data Flash	1 Ko	8 Ko
SRAM	2 Ko	32 Ko
FLASH	32 Ko	256 Ko
Horloge RTC	non	oui

Blink, le premier programme

Rien de tel qu’un programme aussi simple pour vérifier que la communication entre l’IDE et l’Arduino se déroule parfaitement (vous trouverez plus de détails sur le programme Blink dans mon livre).

Le sketch Blink se contente de faire clignoter la LED interne de l’Arduino. Pour l’ouvrir, allez dans Fichier – Exemples – 01.Basics – Blink

Avec l’IDE Arduino 1.8

Avant d’utiliser votre Arduino Uno R4 (Minima ou WiFi), vous devez ajouter ses paramètres dans l’IDE. Pour cela, allez dans Outils – Type de carte – Gestionnaire de carte, tapez simplement « r4 » dans le champ de recherche, sélectionnez Arduino UNO R4 Boards et cliquez sur le bouton Installer.

Allez ensuite dans Outils – Type de Carte – Arduino Renesas UNO R4 Boards et sélectionner la carte Arduino UNO R4 Minima.

Puis, reliez l’Arduino à l’ordinateur et sélectionnez le bon port COM (COM46 dans cet exemple).

Maintenant, vous pouvez lancer le téléversement, n’hésitez pas à modifier la valeur de la fonction delay pour faire clignoter plus ou moins vite la LED.

Avec l’IDE Arduino 2.1

Pour ajouter les paramètres de l’Arduino Uno R4 Minima ou WiFi, allez dans Outils -Carte – Gestionnaire de carte, (ou cliquez simplement sur l’icône correspondante dans la barre latérale), tapez « r4 » dans le champ de recherche, sélectionnez Arduino UNO R4 Boards et cliquez sur le bouton Installer.

Reliez l’Arduino à l’ordinateur, cliquez sur Selectionner une carte, le modèle d’Arduino (avec son port COM) est automatiquement reconnu, il suffit simplement de le sélectionner.

Modifiez éventuellement la valeur de la fonction delay (pour faire clignoter plus ou moins vite la LED) et lancer le téléversement.

La résolution des entrées analogiques

Par défaut, les entrées analogiques de l’Arduino Uno R4 renvoient une valeur comprise entre 0 et 1023 (définie sur 10 bits). Mais il est possible d’augmenter la résolution pour passer à 12 ou 14 bits. Pour tester cette possibilité, je vous propose de reproduire le branchement suivant (ou d’utiliser un module Grove) pour relier le potentiomètre à l’entrée A0 de l’Arduino.

Téléverser le code suivant dans l’Arduino et ouvrez le moniteur série.

// R4_entree_analogique_10_bits
const int POTENTIOMETRE = A0;
void setup() {
  // Déclaration des entrées et des sorties
  pinMode(POTENTIOMETRE, INPUT);
  // Moniteur série
  Serial.begin(9600);
}
void loop() {
  // Affichage de la valeur mesurée
  Serial.println(analogRead(POTENTIOMETRE));
  // Pause d'une seconde
  delay(1000);
}

Lorsque vous manipulez le potentiomètre la valeur change de 0 et 1023 (10 bits).

Pour augmenter la résolution, ajoutez simplement l’instruction :

analogReadResolution(12); // Résolution à 12 Bits (0-4096)

ou

analogReadResolution(14); // Résolution à 14 Bits (0-16383)

dans la fonction setup(). Voilà par exemple le code complet pour obtenir une résolution de 14 bits :

// R4_entree_analogique_14_bits
const int POTENTIOMETRE = A0;
void setup() {
// Déclaration des entrées et des sorties
pinMode(POTENTIOMETRE, INPUT);
// Résolution à 14 Bits (0-16383)
analogReadResolution(14);
// Moniteur série
Serial.begin(9600);
}
void loop() {
// Affichage de la valeur mesurée
Serial.println(analogRead(POTENTIOMETRE));
// Pause d'une seconde
delay(1000);
}

Maintenant, la valeur est comprise entre 0 et 16383 (14 bits).

Si vous le souhaitez, vous pouvez aussi essayer avec une résolution de 12 bits (entre 0 et 4096). Et bien sûr, cela fonctionne également avec les autres entrées analogiques.

Convertisseur numérique-analogique (DAC)

Les pseudo sorties analogiques de l’Arduino Uno R3 (PWM) sont en fait des sorties numériques qui passent très rapidement de l’état haut (5V) à l’état bas. Ce qui fait qu’en moyenne la tension de sortie varie entre 0 et 5V (je résume rapidement, mais ce principe est expliqué beaucoup plus en détail dans mon livre).

Les sorties PWM (Pulse Width Modulation) sont identifiées par ce symbole ~. Elles sont aussi disponibles sur l’Arduino Uno R4, cependant il possède également sur le port A0, un véritable convertisseur numérique-analogique (Digital-to-Analog Converter ou DAC) qui génère une onde sinusoïdale.

Pour modifier l’intensité lumineuse d’une LED ou la vitesse d’un moteur, les sorties PWM fonctionnent très bien, mais lorsqu’il s’agit de jouer de la musique l’utilisation du DAC devrait être une meilleure solution.

Bien sûr, tout cela c’est plutôt théorique, alors tentons l’expérience pour voir comment ça se passe dans la réalité. Dans sa documentation officielle (disponible à l’adresse https://docs.arduino.cc/tutorials/uno-r4-minima/dac ) la fondation Arduino utilise un buzzer, alors nous allons faire de même.

Au clair de la lune avec la sortie PWM

Reproduisez ce schéma (bien sûr, vous pouvez utiliser une autre sortie PWM, mais il faudra en tenir compte dans le programme) :

Et téléversez le code suivant dans l’Arduino :

// R4_Buzzer_PWM
// Au clair de la lune (début)
const int BUZZER = 6;
const int TEMPS = 200;
const int SOL3 = 392;
const int LA3 = 440;
const int SI3 = 494;
void setup(){
  pinMode(BUZZER, OUTPUT);  
}
void loop() {
  tone(BUZZER, SOL3, TEMPS); // Noire
  delay(TEMPS*2); // Durée de la note + Durée du silence
  tone(BUZZER, SOL3, TEMPS); // Noire
  delay(TEMPS*2);
  tone(BUZZER, SOL3, TEMPS); // Noire
  delay(TEMPS*2);
  tone(BUZZER, LA3, TEMPS); // Noire
  delay(TEMPS*2);
  tone(BUZZER, SI3, TEMPS*2); // Blanche
  delay(TEMPS*4);
  tone(BUZZER, LA3, TEMPS*2); // Blanche
  delay(TEMPS*4);
  tone(BUZZER, SOL3, TEMPS); // Noire
  delay(TEMPS*2);
  tone(BUZZER, SI3, TEMPS); // Noire
  delay(TEMPS*2);
  tone(BUZZER, LA3, TEMPS); // Noire
  delay(TEMPS*2);
  tone(BUZZER, LA3, TEMPS); // Noire
  delay(TEMPS*2);
  tone(BUZZER, SOL3, TEMPS*4); // Ronde
  delay(TEMPS*8);
}

L’Arduino joue le début de la chanson « Au clair de la lune ». Ecoutez plusieurs fois cette musique pour mémoriser le son.

Au clair de la lune avec la sortie DAC

Maintenant, branchez le buzzer sur la fameuse sortie DAC (port A0).

Et bien sûr, téléversez le programme correspondant dans l’Arduino :

// R4_Buzzer_DAC
// Au clair de la lune (début)
// Appel de la bibliothèque
#include "analogWave.h"
// Création de l'objet "wave"
analogWave wave(DAC);
const int TEMPS = 200;
const int SOL3 = 392;
const int LA3 = 440;
const int SI3 = 494;
void setup(){
  // démarrage du générateur d'onde sinusoïdale
  wave.sine(10);
}
void loop() {
  joueNote(SOL3, TEMPS); // Noire
  delay(TEMPS); // Durée du silence
  joueNote(SOL3, TEMPS); // Noire
  delay(TEMPS);
  joueNote(SOL3, TEMPS); // Noire
  delay(TEMPS);
  joueNote(LA3, TEMPS); // Noire
  delay(TEMPS);
  joueNote(SI3, TEMPS*2); // Blanche
  delay(TEMPS*2);
  joueNote(LA3, TEMPS*2); // Blanche
  delay(TEMPS*2);
  joueNote(SOL3, TEMPS); // Noire
  delay(TEMPS);
  joueNote(SI3, TEMPS); // Noire
  delay(TEMPS);
  joueNote(LA3, TEMPS); // Noire
  delay(TEMPS);
  joueNote(LA3, TEMPS); // Noire
  delay(TEMPS);
  joueNote(SOL3, TEMPS*4); // Ronde
  delay(TEMPS*4);
}

// Fonction personnalisée
void joueNote(int note, int duree) {
  wave.freq(note);
  delay(duree);
  wave.stop();  
}

Il faut rapprocher l’oreille parce que sans amplificateur, la musique est beaucoup moins forte et avec le son médiocre du buzzer, il est vraiment difficile de remarquer une quelconque amélioration de la qualité sonore. Je vous conseille donc d’utiliser plutôt un haut parleur (avec un système d’amplification), comme par exemple ce module Grove.

Il serait intéressant de brancher un oscilloscope pour voir la différence entre les sorties PWM et DAC (mais je n’en possède pas) ou d’utiliser un amplificateur plus puissant. Alors si cela vous amuse, à vous de jouer…

Horloge (RTC)

L’Arduino Uno R4 intègre une horloge en temps réel ou RTC (Real-Time Clock). Il faut simplement indiquer la date et l’heure dans le programme et ensuite, il est capable de décompter le temps qui passe.

Contrairement à la version WiFi , l’Arduino Uno R4 Minima ne possède pas de connecteurs pour brancher une pile, il ne peut donc pas conserver l’heure lorsqu’il est éteint.

Je vous propose de tester la fonction RTC en fabriquant une pendule qui indique la date et l’heure sur un afficheur Grove LCD.

Installez la bibliothèque Grove – LCD RGB Backlight et branchez simplement l’afficheur sur l’un des bus I2C de la carte Shield Grove. Téléversez ensuite le programme suivant dans l’Arduino.

// R4_Horloge_temps_reel
// Appel des bibliothèques
#include <Wire.h>
#include "rgb_lcd.h"
#include "RTC.h"

rgb_lcd lcd;

void setup() {
  // Configuration de l'afficheur LCD
  lcd.begin(16, 2);
  lcd.setRGB(25, 25, 10);
  // Démarrage de l'horloge
  RTC.begin();
  // Indiquez la date et l'heure
  RTCTime startTime(31, Month::JULY, 2023, 21, 52, 00, DayOfWeek::MONDAY, SaveLight::SAVING_TIME_ACTIVE);
  RTC.setTime(startTime);
}
void loop() {
  RTCTime currentTime;
  // Récupération de la date et de l'heure
  RTC.getTime(currentTime);
  lcd.clear();
  // Affichage de la date (DD/MM//YYYY)
  lcd.setCursor(0, 0);
  lcd.print(currentTime.getDayOfMonth());
  lcd.print("/");
  lcd.print(Month2int(currentTime.getMonth()));
  lcd.print("/");
  lcd.print(currentTime.getYear());
  // Affichage de l'heure (HH/MM/SS)
  lcd.setCursor(0, 1);
  lcd.print(currentTime.getHour());
  lcd.print(":");
  lcd.print(currentTime.getMinutes());
  lcd.print(":");
  lcd.print(currentTime.getSeconds());
  delay(1000);
}

Si vous ne possédez pas ce type d’afficheur LCD, vous pouvez adapter le code à votre matériel (ou utiliser simplement le moniteur série avec le programme disponible à l’adresse suivante : https://docs.arduino.cc/tutorials/uno-r4-minima/rtc )

Émulation Clavier/Souris (HID)

Comme l’Arduino Leonardo et quelques autres (Zero, Due, MKR…), l’Arduino Uno R4 peut être reconnu par l’ordinateur comme un périphérique USB. Vous pouvez donc l’utiliser pour fabriquer un clavier, une manette de jeu, une souris, un dispositif de pointage, etc…

Vous trouverez de nombreux exemples d’utilisation dans mon livre sur l’Arduino, mais pour cet article, je vous en propose un nouveau, il s’agit d’un programme qui empêche l’ordinateur de se mettre en veille en bougeant automatiquement la souris toutes les 5 minutes. Vous pouvez également l’utiliser pour faire une petite blague à un ami, puisqu’à intervalle régulier, la souris deviendra « folle ».

Par mesure de sécurité la souris ne bouge pas avant 10 secondes. En cas d’erreur dans le programme, cela permet de reprogrammer quand même l’Arduino (sans être gêné par les mouvement incontrôlés de la souris).

Téléversez le code suivant dans l’Arduino et laissez-le branché à l’ordinateur (n’hésitez pas à adapter à vos besoins, le délai entre les mouvements de la souris).

// R4_Souris
// Appel de la bibliothèque "Mouse"
#include <Mouse.h>

void setup() {
  Mouse.begin();
  // Délai de 10 secondes (par sécurité)
  delay(10000);
}

void loop() {
  for (int i=0; i <= 1; i++){
    int axeX = random(-10, 10);
    int axeY = random(-10, 10);
    for (int j=0; j <= 10; j++){
      Mouse.move(axeX,axeY);
      delay(30);
    }
    delay(200);
  }
// Délai entre les mouvements de souris (5 min)
  delay(300000); 
}

Arduino Uno R4 WiFi

Puisqu’il possède le même microcontrôleur (Renesas RA4M1), l’Arduino Uno R4 WiFi peut faire la même chose que l’Arduino Uno R4 Minima (résolution analogiques, DAC, horloge, émulation de périphérique USB…).

Mais cette fois-ci, il n’y a plus tellement de place disponible à la surface de la carte. Le quadrillage a disparu et le nom de la carte est écrit plus petit. Comme son nom l’indique, ce nouvel Arduino intègre une puce WiFi (ESP32-S3-MINI-1-N8) mais également une matrice de 12 x 8 = 96 LED et un connecteur QWIIC.

Prix et disponibilités

Actuellement, l’Arduino Uno R4 WiFi ne coûte qu’un euro de plus que l’Arduino Uno R3.

Ces prix ne tiennent pas compte de la TVA et des frais de port (il faut rajoutez une dizaine d’euros).

Matrice de LED

La matrice est constituée de 12 X 8 LED rouges. Elle fonctionne parfaitement à l’intérieur, mais dehors (en plein jour), les LED sont très peu visibles.

Afficher un symbole

A vous de Laisser libre cours à votre créativité pour inventer les symboles qui montrent qu’il fait chaud, froid, qu’il est heure de manger, de partir à l’école, d’aller se coucher, etc…

Il existe plusieurs méthodes pour afficher une image mais la plus simple est de la définir pixel par pixel dans un tableau de ce type (1 le pixel est allumé, 0 le pixel est éteint).

byte coeur[8][12] = {
  { 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0 },
  { 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0 },
  { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0 },
  { 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 },
  { 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

Voilà un petit exemple d’animation (constituée de 2 images).

// R4_Coeur
// Appel de la bibliothèque
#include "Arduino_LED_Matrix.h"
// Création de l'objet "matrix"
ArduinoLEDMatrix matrix;

void setup() {
  // Démarrage de la matrice
  matrix.begin();
}

// Définition de l'image n°1
byte coeur1[8][12] = {
  { 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0 },
  { 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0 },
  { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0 },
  { 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 },
  { 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

// Définition de l'image n°2
byte coeur2[8][12] = {
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0 },
  { 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0 },
  { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
  { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0 },
  { 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 }  
};

void loop(){
  // Affichage de l'image "coeur1"
  matrix.renderBitmap(coeur1, 8, 12);
  delay(500);
  // Affichage de l'image "coeur2"
  matrix.renderBitmap(coeur2, 8, 12);
  delay(1000);
}

Afficher du texte

Il est également possible d’afficher un texte (fixe ou défilant), mais vous devez installer la bibliothèque correspondante. Pour cela, allez dans Croquis – Importer une bibliothèque – Gérer les bibliothèques, (avec l’IDE Arduino 2.1, cliquez simplement sur l’icône correspondante dans la barre latérale). Tapez « ArduinoGraphics » dans la barre de recherche, sélectionnez la bibliothèque et cliquez sur Installer

Voilà un petit exemple de texte qui défile avec une variable. Ici c’est un simple compteur, mais je compte sur vous pour trouver d’autres utilisations (date, heure, température, taux de CO2, adresse IP, etc…)

// R4_Texte_defilant
// Appel des bibliothèques
#include "ArduinoGraphics.h"
#include "Arduino_LED_Matrix.h"

// Déclaration des variables
int compteur = 0;
String texteMatrice;

// Création de l'objet "matrix"
ArduinoLEDMatrix matrix;

void setup() {
  // Démarrage de la matrice
  matrix.begin();
  // Taille des caractères
  matrix.textFont(Font_5x7);
  // Vitesse de défilement
  matrix.textScrollSpeed(70);
  // Emplacement de départ (et couleur par défaut)
  matrix.beginText(0, 1, 0xFFFFFF);
}

void loop() {
  // Texte à afficher
  texteMatrice = "    Arduiblog " + String(compteur) + "    ";
  matrix.println(texteMatrice);
  // Sens de défilement
  matrix.endText(SCROLL_LEFT);
  // Pause d'une seconde
  delay(1000);
  compteur = compteur + 1;
}

Il est également possible d’utiliser des caractères un peu plus petit :

matrix.textFont(Font_4x6);

De faire défiler le texte dans l’autre sens :

matrix.endText(SCROLL_RIGHT);

Ou d’afficher un texte court sans défilement :

matrix.endText();

Si cela vous intéresse, vous trouverez un tuto plus détaillé à cette adresse : https://docs.arduino.cc/tutorials/uno-r4-wifi/led-matrix

Wi-Fi

Le microcontrôleur ESP32-S3 qui assure la connexion WiFi de l’Arduino est bien plus performant que le Renesas RA4M1 (le microcontrôleur principal). Il pourrait donc avantageusement le remplacer, c’est le cas, par exemple de l’Arduino Nano ESP32. Mais cela poserait certainement des problèmes de compatibilité puisque les ESP32 fonctionnent sous 3,3 V (au lieu de 5 V).

L’Arduino Uno R4 WiFi est capable de se connecter à un réseau existant ou de créer un point d’accès. Pour tester cela, je vous propose de fabriquer un thermomètre connecté qui crée une page Web pour afficher la température.

J’ai choisi le capteur DHT22 au format Grove, parce qu’il est précis et très facile à utiliser. En adaptant légèrement le code, vous pourrez le remplacer par le modèle DHT11 (qui est un peu moins performant, mais coûte également moins cher).

Pour installer la bibliothèque DHT, allez dans Croquis – Importer une bibliothèque – Gérer les bibliothèques, (avec l’IDE Arduino 2.1, cliquez simplement sur l’icône correspondante dans la barre latérale). Tapez « dht grove » dans la barre de recherche, sélectionnez Grove Temperature And Humidity Sensor et cliquez sur Installer

Acceptez aussi d’installer les dépendances si l’IDE Arduino vous le propose.

Reliez ensuite le capteur DHT22 (ou DHT11) à l’Arduino. Attention, il existe d’autres types de modules, il est donc possible que la bibliothèque ou l’ordre des connecteurs soient différents (par exemple, la bibliothèque Adafruit ne fonctionne pas correctement avec le capteur Grove). Fiez-vous plutôt à la documentation ou aux inscriptions et retenez simplement qu’il faut reliez le port de données au port D12 et l’alimentation du module aux ports GND et 5V de l’Arduino.

Puis, vous pouvez téléverser le code suivant dans l’Arduino :

// R4_Temperature_WiFi
// Appel des bibliothèques
#include "WiFiS3.h"
#include <DHT.h>
#include "Arduino_LED_Matrix.h"

// Constances et variables
const int CAPTEUR_TEMP = 12;
int t, h;

// Sélectionnez votre capteur
//DHT dht(CAPTEUR_TEMP, DHT11);
DHT dht(CAPTEUR_TEMP, DHT22);

// Paramètres du réseau Wifi
const char NOM_DU_RESEAU[] = "ARDUIBLOG";
const char MOT_DE_PASSE[] = "Azerty123";

// Création de l'objet "matrix"
ArduinoLEDMatrix matrix;

// Clé réseau (nécessaire pour WEP)
int keyIndex = 0;
int status = WL_IDLE_STATUS;

// Création de l'objet serveur (port 80)
WiFiServer server(80);

// Définition de l'image wifi
byte wifi[8][12] = {
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0 },
  { 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1 },
  { 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1 },
  { 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1 },
  { 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1 },
  { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }
};

// Matrice vide
byte vide[8][12] = {
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

void setup() {
  // Démarrage de la matrice
  matrix.begin();
  Serial.begin(9600);
  delay(500);
  // Capteur température DHT
  dht.begin();
  // Vérifier le module Wi-Fi
  if (WiFi.status() == WL_NO_MODULE) {
    Serial.println("La communication avec le module WiFi a échoué !");
    // Le programme se bloque (boucle infinie)
    while (true);
  }

  // Connexion au réseau
  while (status != WL_CONNECTED) {
    Serial.print("Tentative de connexion au réseau : ");
    Serial.print(NOM_DU_RESEAU);
    // Connectez-vous au réseau WPA/WPA2.
    // (Modifiez la ligne si vous utilisez un réseau ouvert ou WEP)
    status = WiFi.begin(NOM_DU_RESEAU, MOT_DE_PASSE);
    // wait 10 seconds for connection:
    for (int i=0; i<= 9; i++){
      clignotementWiFi();
      Serial.print(" .");
    }
  }

  // Démarrage du serveur web (port 80)
  server.begin();
  // Afficher l'adresse de la page :
  IPAddress ip = WiFi.localIP();
  Serial.println(" Connexion réussie");
  Serial.print("Ouvrez votre navigateur à l'adresse http://");
  Serial.println(ip);
}

void loop() {
  // Attends les clients entrants
  WiFiClient client = server.available();
  if (client) {
    // Une requête HTTP se termine par une ligne vide
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        // Si la requête HTTP est terminée, envoi de la réponse
        if (c == '\n' && currentLineIsBlank) {
          // Code HTML de la page
          t = round(dht.readTemperature());
          h = round(dht.readHumidity());  
          String codeHTML = "<!DOCTYPE html>";
          codeHTML += "<head>";
          codeHTML += "<meta http-equiv='refresh' content='30'>";
          codeHTML += "<title>Arduino Uno R4 WiFi</title>";
          codeHTML += "</head>";
          codeHTML += "<body style='background-color: rgb(4, 139, 154);'>";
          codeHTML += "<div style='text-align: center;'>";
          codeHTML += "<h1 style='font-style: italic; text-decoration: underline;'>";
          codeHTML += "Serveur Arduino Uno R4 WiFi</h1><font size='+3'>";
          codeHTML += "Temp&eacute;rature : ";
          codeHTML += t;
          codeHTML += "&deg;<br>Humidit&eacute; : ";
          codeHTML += h;
          codeHTML += " %</span></font></div></body></html>";
          client.println(codeHTML);
          break;
        }

        if (c == '\n') {
          currentLineIsBlank = true;
        } else if (c != '\r') {
          currentLineIsBlank = false;
        }
      }
    }

    // Laisser au navigateur le temps de recevoir les données
    delay(1);
    clignotementWiFi();

    // Arret de la connexion
    client.stop();
  }
}

void clignotementWiFi() {
  // Clignotement de l'image "wifi"
  delay(500);
  matrix.renderBitmap(vide, 8, 12);
  delay(500);
  matrix.renderBitmap(wifi, 8, 12);
}

Au démarrage de l’Arduino, le symbole WiFi clignote sur la matrice de LED et l’adresse IP est indiquée dans le moniteur série. Si vous avez raté le moment où l’adresse est communiquée, il suffit simplement de redémarrer la carte.

Pour connaître la température et le taux d’humidité (mesurés par le capteur DHT), ouvrez votre navigateur et rendez-vous l’adresse indiquée (192.168.1.39 dans cet exemple).

En utilisant une batterie, vous pourrez facilement déplacer l’Arduino dans toute la maison et même connaître la température extérieure en le plaçant sur le rebord d’une fenêtre.

Ce programme est inspiré des exemples de connexion WiFi fournis à cette adresse : https://docs.arduino.cc/tutorials/uno-r4-wifi/wifi-examples

Port VRTC

Avec l’Arduino Uno R4 WiFi il est possible de conserver la date et l’heure de l’horloge en temps réel (même s’il est éteint). Il suffit de branchez une pile ou une batterie de 1.6 à 3,3 V aux ports VRTC et GND.

Mais, ce n’est pas possible avec la version Minima.

Connecteur QWIIC

L’Arduino Uno R4 WiFi possède aussi un connecteur QWIIC. Il permet d’accéder au bus I2C (seulement en 3,3 V) pour connecter des modules compatibles (mais il existe aussi des adaptateurs pour pouvoir utiliser les capteurs Grove).

Au début, j’étais plutôt intrigué parce que mon Arduino Uno R4 WiFi possédait une excroissance qui empêche l’utilisation du connecteur QWIIC (contrairement à la coque de l’Arduino Uno R4 Minima). Mais finalement c’était seulement une bavure qui n’a pas été enlevée…

Vous trouverez plus de détails à l’adresse suivante : https://docs.arduino.cc/tutorials/uno-r4-wifi/qwiic

Conclusion

Cette nouvelle carte, propose de nombreuses améliorations à un prix plus bas ou équivalent à l’Arduino Uno R3. Apparemment, la fondation Arduino ne souhaite pas seulement proposer une alternative mais bien éliminer le modèle qui avait pourtant fait son succès.

Alors faut-il suivre le mouvement et jeter son vieil Arduino ?

A mon avis, il n’y a pas d’urgence, l’Arduino Uno R3 réponds toujours à la plupart des usages pédagogiques et s’il vous donne encore satisfaction, il n’y a pas forcement de raisons d’en changer.

Par contre, si vous débutez et que vous achetez votre 1er Arduino, je vous conseillerais plutôt de choisir l’Arduino Uno R4. Et pour quelques euros de plus, la version WiFi, qui me semble beaucoup plus intéressante (à moins d’être absolument certain de ne jamais utiliser la matrice ou le WiFi).

Le modèle Minima conviendrait peut être plus au milieu scolaire. Il est en effet inutile d’acheter des dizaines de cartes avec des fonctions qui ne serviront jamais.

Mais n’enterrons pas trop vite l’Arduino Uno R3. Il est possible que certains utilisateurs refusent l’évolution proposée par la fondation. Et de toute façon, avec plusieurs dizaines de millions de cartes en circulation, il y aura forcement une certaine inertie. Les versions R3 et R4 cohabiteront donc encore pendant de nombreuses années.

Mon livre

Dans cet article, je suis passé très rapidement sur certains points. Mais si vous n’avez pas tout compris ou si vous voulez en savoir plus sur l’Arduino, sachez que la 3ème édition de mon livre Arduino – Apprivoisez l’électronique et le codage est parue en juillet 2023.

Je me suis d’ailleurs amusé à faire une petite vidéo d’unboxing à l’occasion du 14 juillet.

Ce livre est disponible sur le site des Editions ENI et bien sûr dans toutes les bonnes boutiques.

Vous y trouverez plus de 600 pages d’explications illustrées par des exemples concrets (un peu comme dans cet article).

Evidement, je regrette de ne pas avoir pu parler de l’Arduino Uno R4 dans mon livre (qui est paru presque en même temps que la carte). C’est une des raisons qui m’ont poussées à écrire cet article. Cependant, rassurez-vous, la majeur partie des exemples présentés dans le livre pour l’Arduino Uno R3 fonctionnent toujours avec l’Arduino Uno R4.

Toutefois, par mesure de précaution, augmentez avec l’Arduino Uno R4 la valeur des résistances utilisées avec les LED (470 à 1000 Ω au lieu de 220).

Je vous souhaite beaucoup de plaisir et d’amusement à la découverte de l’Arduino.

Sources et liens utiles

• Arduino Uno R4 Minima : https://docs.arduino.cc/hardware/uno-r4-minima
• Aide-mémoire : https://docs.arduino.cc/tutorials/uno-r4-minima/cheat-sheet
• Arduino Uno R4 WiFi : https://docs.arduino.cc/hardware/uno-r4-wifi
• Aide-mémoire : https://docs.arduino.cc/tutorials/uno-r4-wifi/cheat-sheet
• Mon livre sur l’Arduino : https://arduiblog.com/presentation-de-mon-livre/