Publié le 29 juillet 2026 - par

Arduino UNO R4 WiFi : 3 projets pour tester le Kit d’Apprentissage Elecrow 26-en-1

Vous cherchez à exploiter tout le potentiel de la nouvelle carte Arduino UNO R4 WiFi ? Avec son microcontrôleur 32 bits Renesas RA4M1 et son module ESP32-S3 intégré, cette architecture redéfinit le prototypage IoT. Pour vous accompagner, le Kit d’apprentissage 26-en-1 Elecrow (26-in-1 Learning Kit) propose un écosystème matériel plug-and-play redoutable, regroupant 22 modules et capteurs détachables sans soudure. Dans ce guide technique, je vais évaluer cette solution pensée pour les makers. Je mettrai ensuite ce matériel à l’épreuve à travers trois projets de démonstration concrets en C++ (thermomètre 7 segments, détection PIR avec matrice LED, et horloge RTC avec mise a l heure).

Arduino UNO R4 WiFi : 3 projets pour tester le Kit d’Apprentissage Elecrow 26-en-1

Le contexte : Un kit plébiscité par la communauté Maker

Si vous suivez l’actualité de Framboise314 ou si vous avez croisé ma route récemment, vous avez peut-être déjà aperçu ce matériel. Lors de mes déplacements au Faire Festival de Toulouse fin mai, puis au Nantes Maker Campus début juin, j’ai eu l’occasion d’exposer ce kit « tout-en-un ». Il a fortement attiré l’attention des visiteurs et des utilisateurs d’Arduino aguerris présents sur les stands.

Le fabricant Elecrow m’a en effet confié ce kit d’évaluation pour réaliser ces tests techniques approfondis. Face à l’engouement suscité par son architecture matérielle ingénieuse sur les salons, je prévois d’ailleurs de l’intégrer dès la rentrée dans les formations Arduino que je dispenserai au FabLab UtoPi de Ville du Creusot Communauté urbaine Creusot Montceau. Je vous propose maintenant de passer à l’analyse de l’écosystème matériel avant de plonger dans le code.

Le déballage : Un inventaire modulaire bien pensé

Boîte en plastique du kit Elecrow 26-en-1 pour Arduino UNO R4

On commence le déballage par la boîte en plastique qui contient une grande plaque comportant 21 modules « cassables » dont le PCB est prédécoupé. (Le Shield central est compté comme un module par Elecrow).

Pour ma part, je préfère conserver la plaque intacte. Si j’avais voulu des modules séparés en vrac, j’aurais opté pour une autre version où les modules sont libres. et la plaque a des entretoises aux 4 angles, ainsi que sous le Shield central, ce qui permet de l utiliser posée sur une table ou un établi sans problème de stabilité.

Vue d'ensemble de la plaque principale avec les 22 modules prédécoupés

On trouve à l’intérieur une copie de la fiche ci-dessous qui indique clairement l’emplacement et la référence des différents modules.

Cliquer pour agrandir

Intéressons-nous ensuite au dessous de la plaque, puis à la zone centrale qui accueille l’Arduino.

Vue de dessous de la plaque principale du kit Elecrow

Voici une vue générale (ci-dessus) et une vue rapprochée du shield Arduino (ci-dessous). On peut considérer que la carte complète forme un grand shield géant. Au-dessus de l’emplacement de l’Arduino UNO R4 (au centre), il y a cette carte Shield avec de longues broches..

Détail des broches sous le shield central

Gros plan sur les connexions et la structure de la carte Shield centrale.

Vue rapprochée du Base Shield et de ses connecteurs Crowtail

On peut déjà remarquer la présence des connecteurs Crowtail propres à Elecrow. Ces connecteurs équipent des dizaines (centaines ?) de modules qu’on pourra connecter directement, à condition de respecter scrupuleusement les broches indiquées. Il y a aussi un peu d’électronique, on y reviendra plus loin.

Accessoires et modules externes du kit Elecrow 26-en-1

Enfin, pour compléter cet inventaire, la dernière image rassemble les éléments qui ne se trouvent pas directement sur la plaque principale : le moteur pas-à-pas (PAP), le servomoteur SG90, un écran LCD 1602, la télécommande infrarouge, la carte Arduino UNO R4 WiFi, les 10 câbles Crowtail ainsi que quelques capteurs additionnels. Il y a également le câble USB pour la programmation de l’Arduino.

Le cœur de ce kit c’est l’Arduino UNO R4

L’écran 1602  est un modèle  I2C, Elecrow a ajouté la carte d’adaptation rouge qu’on voit sur la photo ci-dessus.

Un ULN2003 est monté sur le shield. Il peut piloter un moteur pas à pas connecté sur la prise dédiée.

Le pilotage de 2 servomoteurs est prévu avec des connecteurs Dupont.

Montage de l’Arduino : Précautions et assemblage

Mise en place de l'Arduino UNO R4 WiFi dans sa coque transparente

Je passe ensuite à l’étape d’assemblage de la carte sur la plaque principale. Vous noterez que l’Arduino UNO R4 WiFi est protégé par une coque transparente. Il faut présenter la carte par le dessous en positionnant ses connecteurs face aux longues broches du shield central.

Vérification de l'alignement des broches de l'Arduino

C’est ici qu’une certaine rigueur s’impose. Avant d’exercer la moindre pression, il est impératif de contrôler visuellement l’alignement. Il faut s’assurer absolument qu’aucune broche n’est décalée d’un pas, sous peine de les plier au moment de l’insertion.

Contrôle final de l'insertion des broches

Je vous recommande d’inspecter l’alignement sur toute la longueur et sous plusieurs angles. Une fois que vous êtes certain que chaque broche se trouve rigoureusement en face de son connecteur respectif, vous pouvez presser fermement pour emboîter l’ensemble.

Matrice LED de l'Arduino visible à travers le Base Shield

Une fois le montage achevé, on constate côté face que la mécanique a été parfaitement pensée : la matrice de LED (12×8) de l’Arduino R4 WiFi tombe exactement au niveau de l’ouverture centrale de la carte shield, ce qui permettra de visualiser les affichages sans aucune gêne.

Tour d’horizon des modules intégrés

Afficheur 4 segments et capteur de température/humidité

Je vous propose de détailler les composants présents sur la plaque. On y trouve d’abord un afficheur 7 segments à 4 chiffres (très utile pour du comptage ou l’affichage de données), accompagné juste à côté d’un capteur de température et d’humidité.

Ensemble de capteurs divers

Un peu plus bas, vous remarquerez un véritable concentré de capteurs : un récepteur infrarouge, un capteur de son, un interrupteur à bouton-poussoir avec maintien, un accéléromètre 3 axes, un buzzer pour les alertes sonores et enfin un capteur de lumière ambiante.

Potentiomètre linéaire et capteur de gaz MQ-2

On continue avec un potentiomètre linéaire (à glissière), toujours pratique pour faire varier une consigne de manière analogique. Il est situé à droite d’un détecteur de gaz type MQ-2.

Capteurs PIR, de flamme et MQ-2

Dans cette autre zone, on retrouve le capteur de gaz MQ-2, mais cette fois photographié aux côtés d’un capteur de mouvement PIR (reconnaissable à sa lentille de Fresnel blanche) et d’un capteur de flamme infrarouge.

Capteur d'eau Crowtail

Ici, je vous montre le détecteur d’eau. Son fonctionnement est simple : ses pistes dorées parallèles exposées permettent de mesurer la conductivité et donc de détecter la présence d’un liquide ou un niveau d’eau.

Modules LED et boutons poussoirs

Les incontournables de tout apprentissage sur Arduino : un jeu de trois LED (rouge, jaune, verte) et les trois boutons-poussoirs des couleurs correspondantes pour créer vos premières interfaces interactives.

Module relais 5V

Pour la commutation de charges nécessitant plus de puissance, le kit inclut un module relais 5V. Comme toujours avec ce genre de module, gardez à l’esprit les précautions de sécurité électrique si vous pilotez des tensions importantes.

Gros plan sur le capteur de température et d'humidité

Un gros plan sur le capteur de température et d’humidité que l’on avait aperçu sur la première image, bien protégé à l’intérieur de son boîtier ajouré noir.

Détecteur à ultrasons vue de face

On passe ensuite au classique capteur de distance à ultrasons. Sur cette image, je vous le présente de face. On distingue très nettement les deux transducteurs (émetteur et récepteur) protégés par leurs grilles métalliques.

Détecteur à ultrasons vue de dos

Et pour être complet, voici le même détecteur à ultrasons, cette fois photographié par le dessous. Cette vue permet d’observer le PCB et l’électronique embarquée, notamment le circuit intégré RCWL-9616 qui se charge du traitement des signaux.

Gros plan sur le capteur de mouvement PIR Crowtail

Je vous propose un dernier focus sur le capteur de mouvement PIR. Sur ce gros plan, on distingue parfaitement la lentille de Fresnel blanche qui concentre les rayons infrarouges, ainsi que le circuit intégré BISS0001, un classique incontournable pour le traitement des signaux issus de ce type de capteur.

Gros plan sur le récepteur infrarouge et le capteur de son

Ici, un rapprochement sur deux modules mitoyens : à gauche, le récepteur infrarouge (marqué 1838) qui vous permettra de décoder les signaux de la télécommande fournie. À droite, le capteur de son avec son microphone à électret et son amplificateur opérationnel, idéal pour détecter des bruits ambiants ou des claquements de mains.

Vue d'ensemble de la carte Elecrow 26-en-1 assemblée avec l'Arduino UNO R4 WiFi

Et pour clore ce chapitre de présentation matérielle, voici une vue de dessus de l’ensemble du kit une fois le montage de la carte Arduino UNO R4 WiFi terminé. La plaque principale regroupe de manière ordonnée les 21 modules d’apprentissage autour du cœur du système, l’ensemble est maintenant prêt pour le câblage Crowtail et la phase de programmation. C’est parti !

Programmation d’exemples avec le kit Elecrow Arduino Uno R4

Transition du classique ATMega328P vers le Renesas RA4M1 (Arm® Cortex®-M4)

Avant d’attaquer la partie logicielle avec les modules du kit, il est indispensable de faire un point sur le cœur de la carte. L’Arduino UNO R4 WiFi marque une rupture technologique majeure : l’abandon de l’historique microcontrôleur 8 bits ATMega328P au profit d’un processeur 32 bits Renesas RA4M1, architecturé autour d’un cœur Arm® Cortex®-M4.

Concrètement, qu’est-ce que ce changement de moteur vous apporte lors de la programmation et du développement ?

  • Puissance de calcul et architecture 32 bits : La fréquence d’horloge passe de 16 MHz à 48 MHz. Couplée à l’architecture 32 bits, cette carte exécute les calculs complexes (notamment en virgule flottante) et les algorithmes lourds avec une aisance redoutable.
  • Une capacité mémoire décuplée : Avec 256 Ko de mémoire Flash et 32 Ko de SRAM (contre seulement 32 Ko et 2 Ko pour la R3), vous disposez d’un espace de travail considérablement élargi. C’est un atout crucial pour inclure de multiples bibliothèques gourmandes (comme le Wi-Fi, les écrans ou les capteurs I2C complexes) sans saturer la mémoire de la puce.
  • Des périphériques matériels embarqués avancés : Le RA4M1 intègre nativement un véritable convertisseur numérique-analogique (DAC) 12 bits, permettant de générer de vrais signaux analogiques (et non plus du simple PWM). On y trouve également un amplificateur opérationnel (Op-Amp) interne et un bus CAN, offrant une précision et des possibilités de diagnostic industriel inédites sur une carte de ce format.
  • Le maintien de la logique 5V : C’est la grande force de cette itération. Contrairement à la vaste majorité des microcontrôleurs de la famille Arm® Cortex® qui imposent une tension de 3,3V, le processeur de la R4 tolère et opère en 5V. Vos shields, capteurs et actionneurs existants (y compris les 21 modules de ce kit Elecrow) restent donc parfaitement compatibles sans nécessiter le moindre adaptateur de niveau logique.
  • Gestion native de l’USB : Le microcontrôleur gère lui-même l’interface USB, ce qui permet à l’Arduino de simuler directement des périphériques HID (Human Interface Device) comme un clavier ou une souris, tout en optimisant les vitesses de transfert vers le moniteur série.

En résumé, cette carte vous offre la rigueur et la puissance de calcul d’une puce moderne tout en préservant la robustesse et la compatibilité de l’écosystème 5V historique d’Arduino.

Préparation logicielle : Cœur Renesas et bibliothèques Elecrow

Avant de vous présenter les montages et d’entrer dans le vif du sujet avec le code, je dois insister sur deux étapes préparatoires indispensables pour votre environnement de développement.

La première concerne la carte en elle-même. L’Arduino UNO R4 WiFi utilise une architecture 32 bits Renesas, radicalement différente des classiques puces 8 bits AVR. Par défaut, l’IDE Arduino ne possède pas les outils pour compiler un programme destiné à ce processeur. Il faut donc lui ajouter le « cœur » (core) logiciel correspondant. Voici la procédure pas à pas pour configurer votre IDE :

  1. Ouvrez votre IDE Arduino.
  2. Dans le menu de gauche, cliquez sur l’icône Gestionnaire de cartes (vous pouvez aussi passer par le menu Outils > Type de carte > Gestionnaire de cartes).
  3. Dans la barre de recherche du gestionnaire, tapez la requête : UNO R4.
  4. Repérez le paquet nommé « Arduino UNO R4 Boards » (édité par Arduino) et cliquez sur Installer. L’IDE va télécharger l’ensemble de la chaîne de compilation ARM (cette opération peut prendre quelques instants).
  5. Une fois l’installation achevée, rendez-vous dans le menu Outils > Type de carte, descendez jusqu’à la nouvelle section Arduino Renesas UNO R4 Boards et sélectionnez rigoureusement Arduino UNO R4 WiFi.
  6. Connectez votre carte en USB à l’ordinateur, puis dans Outils > Port, sélectionnez le port COM qui vient d’apparaître.

Préparation logicielle : L’installation des bibliothèques Elecrow

La seconde étape concerne les composants du kit. Par défaut, l’IDE Arduino ne possède pas les instructions (les bibliothèques) nécessaires pour dialoguer avec l’ensemble des modules spécifiques fournis par Elecrow. Si vous tentez de compiler un programme sans ces fichiers, la sanction est immédiate : une erreur de compilation vous indiquant qu’il manque un fichier .h.

Les bibliothèques nécessaires sont hébergées sur le dépôt GitHub du fabricant. L’interface de GitHub ne permettant pas de télécharger uniquement le dossier des bibliothèques, la méthode la plus rigoureuse consiste à procéder à une installation manuelle. Voici la marche à suivre étape par étape :

  1. Rendez-vous sur le dépôt GitHub officiel du kit Elecrow.
  2. Cliquez sur le bouton vert   <> Code  , puis sélectionnez Download ZIP pour récupérer l’archive du dépôt sur votre ordinateur.
  3. Décompressez cette archive.
  4. Ouvrez le dossier décompressé et rendez-vous dans le sous-dossier nommé libraries. Vous y trouverez les dossiers de chaque composant (comme TM1650 ou DHT20).
  5. Copiez l’intégralité de ces dossiers et collez-les dans le répertoire des bibliothèques de votre IDE Arduino (qui se trouve généralement dans Documents/Arduino/libraries sous Windows ou ~/Documents/Arduino/libraries sous macOS/Linux).
  6. Redémarrez votre IDE Arduino pour qu’il prenne en compte ces nouveaux ajouts.

Votre environnement de développement est désormais configuré et prêt pour exploiter les capteurs de ce kit. Je vous propose donc de passer immédiatement à la pratique avec le premier montage.

⚠️ Conseil de manipulation
Faites très attention lors du branchement des câbles Crowtail sur les connecteurs des modules. Les circuits imprimés (PCB) sont prédécoupés en usine, ils ont tendance à se rompre facilement sous la pression. Je vous conseille de maintenir fermement le module d’une main pendant que vous insérez la prise de l’autre.

Projet 1 : Thermomètre sur 7 segments (Exploitation du bus I2C)

Pour ce premier projet, on va vérifier la bonne acquisition des données environnementales et le multiplexage de l’affichage. J’utilise le capteur de température/humidité DHT20 conjointement avec l’afficheur 4 digits TM1650. Le choix de ces deux modules n’est pas anodin : tous deux communiquent via le protocole I2C.

 

Le Base Shield du kit Elecrow simplifie la démarche. Branchez simplement les deux modules sur les ports marqués I2C. Puisqu’il s’agit d’un bus de communication, l’ordre physique des connecteurs n’a pas d’importance ; le microcontrôleur RA4M1 dialoguera avec chaque périphérique grâce à son adresse matérielle unique.

D’un point de vue logiciel, la démarche requiert une certaine rigueur. Le capteur DHT20 renvoie une valeur à virgule flottante (type float). Or, l’afficheur TM1650 attend une chaîne de caractères. L’astuce consiste à multiplier la température par 10 (par exemple, 24.5 °C devient l’entier 245), à scinder ce nombre chiffre par chiffre pour créer notre chaîne, puis à activer manuellement la virgule (le point décimal matériel) au bon index de l’afficheur.

Voici le code complet permettant d’obtenir un thermomètre numérique fiable et réactif. vous trouverez dans les sources un .zip qui regroupe les programmes de démo.

#include <Wire.h>
#include <TM1650.h>
#include "DHT20.h"

TM1650 display;
DHT20 DHT;

void setup() {
  Serial.begin(115200);
  Wire.begin();

  display.init();
  display.displayOn();
  display.setBrightness(3);

  DHT.begin();
  display.displayString("    ");
}

void loop() {
  if (millis() - DHT.lastRead() >= 1000) {
    DHT.read();
    float temperature = DHT.getTemperature();

    int tempInt = (int)(temperature * 10);
    int d1 = (tempInt / 1000) % 10;
    int d2 = (tempInt / 100) % 10;
    int d3 = (tempInt / 10) % 10;
    int d4 = tempInt % 10;

    char buf[5];
    buf[0] = (d1 == 0) ? ' ' : '0' + d1;
    buf[1] = '0' + d2;
    buf[2] = '0' + d3;
    buf[3] = '0' + d4;
    buf[4] = '\0';

    display.displayString(buf);
    display.setDot(2, true);
  }
}

et vous pouvez vérifier sur le moniteur (en 115200) que vous recevez bien la température. On vient de valider pas mal de choses, non ?

Projet 2 : Détection de mouvement avec capteur PIR et Matrice LED

Pour ce deuxième montage, j’ai voulu exploiter une des nouveautés matérielles les plus visibles de l’Arduino UNO R4 WiFi : sa matrice LED 12×8 intégrée. L’objectif est simple : nous allons utiliser le détecteur de mouvement PIR du kit Elecrow pour déclencher un affichage visuel directement sur la carte.

Le capteur PIR (Passive Infrared) génère un signal logique HAUT (3.3V ou 5V) lorsqu’il détecte une variation de rayonnement infrarouge dans son champ de vision, typiquement le passage d’une personne ou d’un animal. Nous allons raccorder ce capteur sur le port numérique D8 de notre Base Shield.

Côté code, la gestion de la matrice de l’UNO R4 est grandement facilitée par la bibliothèque native Arduino_LED_Matrix.h, qui est automatiquement incluse lorsque vous installez le support de la carte dans l’IDE. J’allume un carré sur la matrice pour vérifier que tout est fonctionnel.

Pour rendre cette alarme visuelle encore plus… visible, j’ai décidé de coupler cet affichage matriciel avec le module Crowtail contenant une LED rouge de 5mm, fourni dans le kit. Ce module vient se brancher très simplement sur un autre port numérique du Base Shield (le port D3 dans mon exemple).

Le code s’enrichit donc de quelques lignes classiques pour déclarer la broche de la LED en sortie (OUTPUT) et pour basculer son état (HIGH ou LOW) en parfaite synchronisation avec le déclenchement de la matrice LED.

Projet 3 : Réalisation d’une horloge interactive : Cahier des charges et câblage

Pour couronner notre exploration de l’écosystème Elecrow et de l’Arduino UNO R4 WiFi, je vous propose un projet interactif et autonome : une horloge numérique à affichage 7 segments dotée d’une interface de réglage complète.

Cahier des charges fonctionnel

  • Mode Normal (Horloge) : L’afficheur 4 digits restitue l’heure courante au format HH:MM. Les deux points centraux clignotent au rythme des secondes pour attester du bon déroulement temporel (gestion non bloquante par millis()).
  • Mode Réglage : Une impulsion sur le bouton de commande bascule le système en mode configuration. Une LED témoin s’allume pour signaler visuellement cet état.
  • Incrémentation ergonomique : En mode réglage, des appuis successifs ou prolongés (auto-répétition) sur les boutons dédiés permettent d’ajuster indépendamment les heures et les minutes de manière cyclique.

Plan de connexions (Crowtail Base Shield)

Les contraintes physiques de la carte shied et l’utilisation du bus I2C imposent un mappage précis des broches sur l’Arduino UNO R4 WiFi :

Composant / Fonction Broche Arduino (Crowtail) Rôle / Description
Afficheur 7-segments (TM1650) Port I2C (SDA / SCL) Affichage dynamique des 4 chiffres et des points centraux.
Bouton Vert Broche D8 Bascule de mode (Normal / Réglage) et validation.
Bouton Rouge Broche D3 Incrémentation des heures (avec gestion de l’auto-répétition).
Bouton Jaune Broche D0 Incrémentation des minutes (avec gestion de l’auto-répétition).
LED Verte (Témoin) Broche D9 Indicateur visuel d’activation du mode réglage.

Ce choix d’implantation garantit l’intégrité du bus de communication tout en exploitant des entrées numériques en mode INPUT_PULLUP pour assurer la stabilité des signaux de commande.

 


#include 
#include 

// Initialisation de l'afficheur 7 segments I2C
TM1650 display;

// Définition des broches selon nos connexions sur le Crowtail Base Shield :
const int pinBtnVert = 8;   // Bouton Vert : mode/validation (broche D8)
const int pinBtnRouge = 3;  // Bouton Rouge : heures (broche D3)
const int pinBtnJaune = 0;  // Bouton Jaune : minutes (broche D0)
const int pinLedMode = 9;   // LED Verte : témoin lumineux du mode réglage (broche D9)

// Variables pour l'horloge
bool modeReglage = false;   // Faux par défaut (mode horloge normale)
int heures = 12;            // Heure de départ
int minutes = 0;            // Minute de départ
int secondes = 0;           // Seconde de départ

// Variables pour la gestion du temps
unsigned long derniereSeconde = 0;
unsigned long dernierMillisAuto = 0;
const int delaiAutoRepet = 150; // Vitesse de défilement lors d'un appui long
bool etatPoints = true;         // Pour faire clignoter les deux points centraux

void setup() {
  // Configuration des broches des boutons en entrée avec résistance de rappel
  pinMode(pinBtnVert, INPUT_PULLUP);
  pinMode(pinBtnRouge, INPUT_PULLUP);
  pinMode(pinBtnJaune, INPUT_PULLUP);
  
  // Configuration de la LED
  pinMode(pinLedMode, OUTPUT);
  digitalWrite(pinLedMode, LOW); // LED éteinte au démarrage

  // Initialisation du bus I2C et de l'afficheur TM1650
  Wire.begin();
  display.init();
  display.displayOn();
  
  // Premier affichage
  afficherHeure(heures, minutes, etatPoints);
}

void loop() {
  unsigned long currentMillis = millis();

  // --- 1. GESTION DU BOUTON VERT (Mode Normal <-> Réglage) ---
  if (digitalRead(pinBtnVert) == LOW) {
    delay(200); // Anti-rebond
    modeReglage = !modeReglage; // Inversion du mode
    
    // La LED indique si on est en mode réglage
    digitalWrite(pinLedMode, modeReglage ? HIGH : LOW);
    
    // Fige les deux points centraux en mode réglage
    if (modeReglage) {
      etatPoints = true; 
      afficherHeure(heures, minutes, etatPoints);
    }
    
    while(digitalRead(pinBtnVert) == LOW); // Attente du relâchement
  }

  // --- 2. GESTION DES MODES ---
  if (modeReglage) {
    // --- MODE RÉGLAGE ---
    
    // Bouton Rouge : Heures
    if (digitalRead(pinBtnRouge) == LOW) {
      heures = (heures + 1) % 24;
      delay(250); 
      
      // Défilement rapide si maintenu
      while (digitalRead(pinBtnRouge) == LOW) {
        if (millis() - dernierMillisAuto > delaiAutoRepet) {
          heures = (heures + 1) % 24;
          dernierMillisAuto = millis();
          afficherHeure(heures, minutes, true);
        }
      }
      afficherHeure(heures, minutes, true);
    }

    // Bouton Jaune : Minutes
    if (digitalRead(pinBtnJaune) == LOW) {
      minutes = (minutes + 1) % 60; 
      delay(250);
      
      // Défilement rapide si maintenu
      while (digitalRead(pinBtnJaune) == LOW) {
        if (millis() - dernierMillisAuto > delaiAutoRepet) {
          minutes = (minutes + 1) % 60;
          dernierMillisAuto = millis();
          afficherHeure(heures, minutes, true);
        }
      }
      afficherHeure(heures, minutes, true);
    }

  } else {
    // --- MODE HORLOGE NORMALE ---
    if (currentMillis - derniereSeconde >= 1000) { 
      derniereSeconde = currentMillis;
      secondes++;
      etatPoints = !etatPoints; // Fait clignoter les points chaque seconde
      
      if (secondes >= 60) {
        secondes = 0;
        minutes++;
        if (minutes >= 60) {
          minutes = 0;
          heures = (heures + 1) % 24;
        }
      }
      // Mise à jour de l'affichage avec clignotement
      afficherHeure(heures, minutes, etatPoints);
    }
  }
}

// Fonction pour envoyer l'heure formatée au TM1650
void afficherHeure(int h, int m, bool afficherPoints) {
  char texteAffichage[5];
  
  // Formate les heures et minutes avec des zéros devant si < 10 (ex: "0905")
  sprintf(texteAffichage, "%02d%02d", h, m);
  
  // Envoie la chaîne à l'afficheur
  display.displayString(texteAffichage);
  
  // Gère l'affichage des deux points centraux (selon la bibliothèque TM1650, 
  // cela active le point du digit 1 ou 2, correspondant au double point central)
  if (afficherPoints) {
    display.setDot(1, true); 
  } else {
    display.setDot(1, false);
  }
}

 

Télécharger les programmes et le manuel

Les programmes de démo sont disponibles en ligne sous forme d’un fichier .ZIP

Vous pouvez télécharger le manuel en anglais sur le site de Elecrow

Vidéo

Conclusion

Au terme de cette série de tutoriels consacrée au kit Elecrow 26-en-1 et à l’Arduino UNO R4 WiFi, on mesure tout le potentiel de cet écosystème. Grâce à un ensemble de modules largement documentés (en anglais) par Elecrow, ce matériel offre un formidable terrain de jeu pour découvrir et maîtriser la programmation des microcontrôleurs.

De la simple lecture d’un capteur ou de l’allumage d’une LED jusqu’à la conception de projets de plus en plus complexes et interactifs comme notre horloge multifonction, la progression se fait naturellement. Chaque module vient enrichir la palette technique du maker, permettant d’aborder des notions fondamentales telles que la gestion du temps non bloquant, l’exploitation des bus de communication ou la structuration d’interfaces homme-machine (IHM) robustes.

Que vous débutiez dans l’univers de l’électronique programmée ou que vous souhaitiez exploiter toute la puissance de l’UNO R4 pour vos réalisations, ce kit constitue une base idéale et évolutive. À vous désormais de combiner ces briques matérielles pour donner vie à vos propres projets !

Il est vendu environ 75$ sur le site Elecrow. Si vous considérez le prix d’un Arduino UNO R4, celui des 26 modules achetés individuellement, les fils crowtail, cette somme est raisonnable.

Sources

Acheter le kit sur la page Elecrow

(lien affilié)

https://www.elecrow.com/wiki/26-in-1_Learning_Kit_for_Arduino_UNO_R4_with_26_lessons_Support_WiFi_and_BLE.html

https://www.elecrow.com/download/product/SEA00904D/User_Manual_for_21-in-1_Learning_Kit_for_Arduino_UNO_R4.pdf

 

 

À propos François MOCQ

Électronicien d'origine, devenu informaticien, et passionné de nouvelles technologies, formateur en maintenance informatique puis en Réseau et Télécommunications. Dès son arrivée sur le marché, le potentiel offert par Raspberry Pi m’a enthousiasmé j'ai rapidement créé un blog dédié à ce nano-ordinateur (www.framboise314.fr) pour partager cette passion. Auteur de plusieurs livres sur le Raspberry Pi publiés aux Editions ENI.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. Découvrez comment les données de vos commentaires sont traitées.