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é

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é.

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.
Intéressons-nous ensuite au dessous de la plaque, puis à la zone centrale qui accueille l’Arduino.

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..

Gros plan sur les connexions et la structure de la carte Shield centrale.
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.

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

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.

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.

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.

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

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é.

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.

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.

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.
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.

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.

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.

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.

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.

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.

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.

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.

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 :
- Ouvrez votre IDE Arduino.
- 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). - Dans la barre de recherche du gestionnaire, tapez la requête :
UNO R4. - 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).
- 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. - 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 :
- Rendez-vous sur le dépôt GitHub officiel du kit Elecrow.
- Cliquez sur le bouton vert <> Code , puis sélectionnez Download ZIP pour récupérer l’archive du dépôt sur votre ordinateur.
- Décompressez cette archive.
- 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). - 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/librariessous Windows ou~/Documents/Arduino/librariessous macOS/Linux). - 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.
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 parmillis()). - 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é)




















