Il y a quelques semaines, Elecrow m’a fait parvenir sa nouvelle valisette d’apprentissage, le All-in-one Starter Kit pour Arduino Nano R4, afin de la passer au banc d’essai. J’ai immédiatement accepté cette opportunité, et ce pour une raison très concrète. Dès le mois de septembre, je vais animer de nouveaux cours de programmation Arduino au FabLab UtoPi du Creusot. Le format « tout-en-un » sans câblage complexe m’intéresse tout particulièrement, car j’ai la ferme intention d’utiliser ces kits complets Arduino et Arduino Nano comme supports pédagogiques pour ces ateliers. Je vous propose donc d’examiner en détail le contenu et le potentiel de cette solution.
Starter Kit Elecrow Arduino Nano R4 : Banc d’essai complet à la loupe
Depuis sa réception, j’ai eu le plaisir de présenter ce kit sur différents événements : le Faire Festival à Toulouse et le Nantes Maker Campus. À chaque fois, les visiteurs, qu’ils soient enseignants, formateurs ou étudiants, ont été très intéressés par cette valisette qui met l’Arduino à la portée de chacun.
Le All-in-one Starter Kit se présente sous la forme d’une valisette compacte intégrant une platine principale sur laquelle on insère l’Arduino Nano R4. Autour du microcontrôleur on trouve une panoplie complète de capteurs, d’actionneurs et d’afficheurs (relais, LCD I2C, capteur ultrason, servomoteur, DHT11, etc.), tous directement implantés et pré-câblés sur le PCB.
L’avantage majeur de cette architecture réside dans l’absence totale de câblage par fils DuPont sur breadboard. Naturellement, la maîtrise du câblage et de l’interfaçage électrique reste une étape indispensable dans ce type de formation, mais elle viendra dans un second temps. Dans cette phase initiale de prise en main ou de prototypage, la platine offre un environnement matériel totalement fiable.
Elle élimine d’emblée les incertitudes chronophages : faux contacts, erreurs de brochage, composants mal enfichés ou inversions de polarité. Vous pouvez ainsi vous concentrer exclusivement sur la logique applicative et l’algorithmique. Cette approche permet de valider sereinement les programmes, en ayant la garantie absolue que le hardware sous-jacent répondra présent.
Dans la valise vous trouverez l’Arduino Nano R4 dans un sachet antistatique, avec sa mousse de protection. Au centre se trouvent les palonniers et la visserie de fixation destinés au servomoteur SG90. Enfin, sur la droite, le kit fournit un capteur d’humidité du sol. C’est un grand classique pour vos projets : planté dans un pot, il permet de détecter le besoin en eau d’une plante. Lorsque la terre devient trop sèche, l’Arduino peut par exemple faire coller le relais de la valise pour déclencher l’alimentation d’une pompe à eau et arroser la fleur automatiquement.
Les capteurs et actionneurs embarqués
Pour vous donner une idée précise des capacités de cette platine, voici l’inventaire des modules directement exploitables autour de l’Arduino Nano R4 :
Les interfaces d’affichage et de signalisation :
- Écran LCD 1602 (interfacé en I2C)
- Afficheur 7 segments à 4 chiffres
- 3 LEDs (Rouge, Jaune, Verte)
- Buzzer
Les capteurs et commandes (Entrées) :
- Capteur de température et d’humidité (DHT11)
- Capteur de distance à ultrasons (type HC-SR04)
- Détecteur de mouvement PIR
- Capteur de son (microphone)
- Récepteur Infrarouge (IR)
- Potentiomètre linéaire (à glissière)
- 3 boutons-poussoirs tactiles
Les actionneurs (Sorties) :
- Relais 5V (avec bornier à vis pour le circuit de puissance)
- Servomoteur (type SG90)
Analyse détaillée des capteurs et actionneurs du kit Elecrow
Pour mieux comprendre l’architecture de cette platine didactique, examinons de plus près les différents sous-systèmes qui la composent. Le routage du PCB est particulièrement soigné et la sérigraphie indique clairement les affectations de broches pour chaque composant, ce qui facilite la programmation sans avoir à se référer constamment au schéma de principe.
La vue d’ensemble confirme l’approche intégrée : le microcontrôleur Arduino Nano R4 prend place au centre, entouré de ses périphériques.
Cette disposition aérée permet une identification rapide des modules lors de l’exécution et du débogage de vos programmes.
Le Relais (Broche D4)
L’étage de puissance est confié à un relais électromécanique Songle (modèle SRD-05VDC-SL-C) piloté par la broche D4. Il dispose d’un bornier à vis 3 points (Commun, Normalement Ouvert, Normalement Fermé) permettant d’interfacer des charges importantes (jusqu’à 10A sous 250VAC ou 30VDC). Le circuit de commande intègre les composants de protection nécessaires (transistor de commutation et diode de roue libre) pour protéger la sortie du microcontrôleur.
Le Buzzer (Broche D3)
Connecté à la sortie D3, ce buzzer permet de générer des retours sonores ou des alarmes. La présence d’un transistor de commande sur le PCB garantit une consommation de courant faible, adaptée aux possibilités de la broche du Nano R4. Il est parfait pour valider auditivement l’état de vos systèmes embarqués.
Le capteur de distance à ultrasons (Broches D6 et D7)
Incontournable en robotique, ce module de télémétrie utilise la broche D6 pour l’émission (Trigger) et D7 pour la réception (Echo). Le fait qu’il soit directement soudé sur la platine est un excellent point : cela élimine les erreurs de mesure souvent causées par des fils DuPont défectueux ou des vibrations mécaniques sur les montages volants.
Le capteur de luminosité (Bus I2C)
Contrairement aux simples photorésistances (LDR) analogiques souvent fournies dans les kits de base, Elecrow a opté ici pour un capteur numérique interfacé sur le bus I2C (broches A4/SDA et A5/SCL). La sérigraphie précise d’ailleurs son adresse matérielle (ADD:0x5C). Cela garantit des mesures d’éclairement fiables et simplifie l’exploitation des données dans le code.
Le capteur 3 axes (Bus I2C)
Pour la détection de mouvement et d’inclinaison dans l’espace, la carte embarque un capteur 3 axes (accéléromètre/gyroscope). Tout comme le capteur de luminosité, il communique via le bus I2C (broches A4/SDA et A5/SCL) à l’adresse0x6B. C’est idéal pour s’initier à la récupération de données inertielles.
Le capteur de température et d’humidité
Un composant incontournable des kits de prototypage : le capteur de type DHT (ici estampillé ASAIR). Parfait pour les projets domotiques ou les stations météo, il permet de relever les données de l’atmosphère ambiante.
Le bloc de boutons-poussoirs (Broche A3)
Voici une conception matérielle qu’on retrouve souvent pour économiser les précieuses entrées/sorties du microcontrôleur. Les trois boutons (K1, K2, K3) sont regroupés sur une seule et même broche analogique (A3) grâce à un réseau de résistances (pont diviseur). Une simple lecture analogique sur A3 permet au programme de déduire précisément quel bouton vient d’être pressé.
L’afficheur 4 digits (Bus I2C)
Cet afficheur 7 segments à 4 chiffres est le candidat tout trouvé pour afficher des chronomètres, des horloges ou le retour visuel des capteurs. Autre bon point pour Elecrow : il est interfacé en I2C (adresse 0x70), ce qui libère un nombre considérable de broches par rapport à un afficheur classique à commande directe.
Le détecteur de mouvement PIR (Broche A2)
Architecturé autour du classique circuit intégré BISS0001, ce capteur infrarouge passif (PIR) doté de sa lentille de Fresnel permet de détecter une présence. Directement relié à la broche A2, il suffit de lire son état logique pour déclencher un relais ou un buzzer en cas de mouvement.
Le potentiomètre à glissière (Broche A0)
C’est un potentiomètre linéaire, comme on en trouve sur les tables de mixage. Il est branché sur l’entrée analogique A0. C’est l’idéal pour faire varier une valeur en douceur, comme la vitesse d’un moteur, le volume d’un buzzer ou l’intensité d’une lumière.
Le servomoteur (Broche D9)
Pour mettre vos projets en mouvement, la carte intègre un petit servomoteur SG90 bleu tout à fait classique. Il est commandé par la broche D9. Petit détail pratique : la sérigraphie indique les angles de 0 à 180 degrés pour vous aider à vous repérer d’un coup d’œil.
L’écran LCD (Bus I2C)
Un grand classique de l’Arduino : l’écran LCD capable d’afficher 2 lignes de 16 caractères. L’avantage ici, c’est qu’il est connecté en I2C (à l’adresse 0x27).
Affichage d’un programme de test du bus I2C
Au lieu d’utiliser une multitude de fils, deux broches suffisent pour afficher vos textes ou les valeurs de vos capteurs.
Les trois LEDs (Broches D5, D10, D11)
Rien de tel que de faire clignoter une LED pour son premier programme. Vous avez ici un feu tricolore prêt à l’emploi avec une LED rouge (D5), une jaune (D10) et une verte (D11). C’est parfait pour indiquer visuellement l’état de votre montage.
Le capteur de son (Broche A1)
Ce petit micro capte le bruit ambiant et envoie son signal vers l’entrée analogique A1. Si vous regardez juste en dessous, vous verrez un petit composant carré avec une croix : c’est un potentiomètre qui vous permet d’ajuster la sensibilité du micro avec un simple tournevis (privilégiez un tournevis isolant).
Le récepteur Infrarouge et les extensions (Broche D2)
Le composant marqué 1838 sert à recevoir les signaux d’une télécommande infrarouge, relié à la broche D2. Mais l’intérêt de cette zone, ce sont aussi les deux prises blanches situées juste à côté. Celle du haut permet de brancher facilement d’autres capteurs sur les entrées A6 et A7. Celle du bas vous donne accès au port série (RX et TX). C’est très bien pensé pour ajouter vos propres modules si ceux de la carte ne vous suffisent pas !
Charger un programme dans l’Arduino Nano R4
Sur le côté droit de la valise, vous remarquerez la présence d’une prise USB-C. C’est tout simplement l’accès direct à l’Arduino Nano R4. En la reliant à votre ordinateur, c’est par là que vous allez téléverser vos nouveaux programmes. Mais elle a un autre avantage très pratique : une fois votre programme en mémoire, vous n’avez plus besoin d’ordinateur. Branchez simplement une alimentation USB 5V classique (comme un chargeur de téléphone ou une batterie externe) sur cette prise, et la valise démarrera toute seule pour exécuter votre code de façon autonome.
Le programme de test de la platine
Pour vous permettre de vérifier rapidement que tout fonctionne, je vous ai préparé un programme qui teste presque chaque module. L’idée est simple : utiliser l’écran LCD et les trois boutons pour créer un petit menu interactif. Vous appuyez sur les boutons pour faire défiler les tests et choisir celui que vous voulez lancer.
Le code est volontairement très commenté pour que les débutants puissent s’y retrouver. Vous y verrez par exemple comment on utilise la fonction millis() pour éviter de bloquer le programme avec des delay(), ou encore comment on lit plusieurs boutons sur une seule broche analogique.
Note : Vous retrouverez ce programme en téléchargement (archive ZIP) juste en dessous, ainsi qu’une vidéo de démonstration pour voir la platine en action !
#include
#include
#include
#include
#include
// ================== BRANCHEMENTS (MAPPING MATÉRIEL) ==================
// Ici, on donne un nom à chaque broche pour rendre le code plus facile à lire
const int PIN_BUZZER = 3; // Le buzzer est sur la broche D3
const int PIN_LED_R = 5; // La LED rouge est sur D5
const int PIN_TRIG = 6; // Broche d'émission du capteur ultrason (D6)
const int PIN_ECHO = 7; // Broche de réception du capteur ultrason (D7)
const int PIN_SERVO = 9; // Le servomoteur est sur D9
const int PIN_LED_Y = 10; // La LED jaune est sur D10
const int PIN_LED_G = 11; // La LED verte est sur D11
const int PIN_POT = A0; // Le potentiomètre à glissière est sur A0
const int PIN_SOUND = A1; // Le capteur de bruit est sur A1
const int PIN_BTN = A3; // Les 3 boutons sont regroupés sur A3
// ================== CRÉATION DES OBJETS ==================
// On prépare les outils pour discuter avec les composants complexes
LiquidCrystal_I2C lcd(0x27, 16, 2); // Écran LCD à l'adresse I2C 0x27, 16 colonnes, 2 lignes
Servo myservo; // L'objet pour contrôler le servomoteur
DHT20 dht; // Le capteur de température et humidité
// ================== LISTE DES ÉTATS DU PROGRAMME ==================
// C'est la liste des menus. Le programme ne peut être que dans un de ces états à la fois.
enum State {
MODE_MENU, // L'écran d'accueil avec la liste
MODE_TEST_BUZZER,
MODE_TEST_US, // US = Ultrason
MODE_TEST_POT, // Potentiomètre
MODE_TEST_SERVO,
MODE_TEST_SOUND, // Bruit
MODE_TEST_DHT, // Température/Humidité
MODE_TEST_LIGHT, // Lumière
MODE_TEST_IMU // Accéléromètre
};
// Au démarrage, on se place sur le menu d'accueil
State currentState = MODE_MENU;
// ================== VARIABLES GLOBALES ==================
// Les textes qui s'afficheront sur l'écran LCD pour le menu
const char* menuItems[] = {
"1. Buzzer",
"2. Ultrason",
"3. Potentiometre",
"4. Servo Moteur",
"5. Capteur Bruit",
"6. Temp Humidite",
"7. Lumiere (Lux)",
"8. Accelerometre"
};
const int NUM_ITEMS = 8; // Le nombre total de menus
int menuIdx = 0; // Le numéro du menu actuellement affiché (commence à 0)
unsigned long lastUpdate = 0; // Chronomètre pour cadencer les mesures sans bloquer le programme
// Ces variables retiennent si les capteurs I2C ont bien démarré
bool lightSensorOk = false;
bool imuSensorOk = false;
// ================== FONCTIONS PRATIQUES ==================
// Cette fonction lit la broche A3 pour deviner quel bouton a été pressé
int getKeyPress() {
static unsigned long lastPressTime = 0; // Mémorise la dernière fois qu'on a appuyé
int val = analogRead(PIN_BTN); // On lit la tension sur la broche A3
int btn = 0;
// Selon la valeur lue, on sait quel bouton est enfoncé (grâce aux résistances sur la carte)
if (val > 490 && val < 530) btn = 1; // Bouton K1 (Gauche) else if (val > 660 && val < 700) btn = 2; // Bouton K2 (Milieu) else if (val > 830 && val < 870) btn = 3; // Bouton K3 (Droite) // On vérifie qu'il s'est passé au moins 300 millisecondes depuis le dernier appui (anti-rebond) if (btn != 0 && (millis() - lastPressTime > 300)) {
lastPressTime = millis();
return btn;
}
return 0; // Aucun bouton pressé
}
// Fonction pour éteindre toutes les LEDs et le buzzer (pratique quand on quitte un test)
void resetOutputs() {
digitalWrite(PIN_LED_R, LOW);
digitalWrite(PIN_LED_Y, LOW);
digitalWrite(PIN_LED_G, LOW);
noTone(PIN_BUZZER);
}
// Fonction pour dessiner le menu sur l'écran
void drawMenu() {
lcd.clear(); // On efface l'écran
lcd.setCursor(0, 0); // On se place sur la première ligne, tout à gauche
lcd.print("--- MENU IHM ---");
lcd.setCursor(0, 1); // On se place sur la deuxième ligne
lcd.print(menuItems[menuIdx]); // On affiche le nom du test sélectionné
}
// ================== DÉMARRAGE (SETUP) ==================
void setup() {
// On indique à l'Arduino qui est une sortie (OUTPUT) et qui est une entrée (INPUT)
pinMode(PIN_BUZZER, OUTPUT);
pinMode(PIN_LED_R, OUTPUT);
pinMode(PIN_LED_Y, OUTPUT);
pinMode(PIN_LED_G, OUTPUT);
pinMode(PIN_TRIG, OUTPUT);
pinMode(PIN_ECHO, INPUT);
// On prépare le servomoteur
myservo.attach(PIN_SERVO, 600, 2600);
myservo.write(0); // On le met à la position 0 degré
// Démarrage de la communication I2C (très important pour l'écran et les capteurs avancés)
Wire.begin();
delay(200); // Petite pause pour laisser le temps aux composants de s'allumer
// Allumage de l'écran LCD
lcd.init();
lcd.backlight(); // On allume le rétroéclairage
// Allumage du capteur de température
dht.begin();
// Initialisation manuelle du capteur de lumière (adresse 0x5C) pour éviter les plantages
Wire.beginTransmission(0x5C);
Wire.write(0x10); // Mode haute résolution continu
if (Wire.endTransmission() == 0) {
lightSensorOk = true; // Si ça marche, on le note
}
// Démarrage de l'accéléromètre
if (IMU.begin()) {
imuSensorOk = true; // Si ça marche, on le note
}
drawMenu(); // On affiche le menu pour la première fois
}
// ================== BOUCLE PRINCIPALE (LOOP) ==================
void loop() {
int key = getKeyPress(); // On regarde si un bouton est pressé
// Si on est en train de faire un test et qu'on appuie sur K2 ou K3, on retourne au menu
if (currentState != MODE_MENU && (key == 2 || key == 3)) {
resetOutputs(); // On coupe les alarmes ou lumières en cours
currentState = MODE_MENU; // On change l'état pour dire "Je suis dans le menu"
drawMenu();
return; // On arrête ce tour de boucle ici
}
// Le "switch" permet de choisir quelle partie du code exécuter selon l'état actuel
switch (currentState) {
// CAS 1 : ON EST DANS LE MENU PRINCIPAL
case MODE_MENU:
if (key == 1) {
// Bouton de gauche : on passe au test suivant
menuIdx = (menuIdx + 1) % NUM_ITEMS;
drawMenu();
}
else if (key == 3) {
// Bouton de droite : on revient au test précédent
menuIdx = (menuIdx - 1 + NUM_ITEMS) % NUM_ITEMS;
drawMenu();
}
else if (key == 2) {
// Bouton central : On valide et on lance le test sélectionné !
currentState = static_cast(MODE_TEST_BUZZER + menuIdx);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(menuItems[menuIdx]);
lastUpdate = millis();
}
break;
// CAS 2 : LE TEST DU BUZZER
case MODE_TEST_BUZZER:
// Toutes les demi-secondes (500 ms)
if (millis() - lastUpdate > 500) {
lastUpdate = millis();
static bool stateBuzzer = false;
stateBuzzer = !stateBuzzer; // On inverse l'état
if(stateBuzzer) tone(PIN_BUZZER, 1000); // On fait un bip à 1000 Hertz
else noTone(PIN_BUZZER); // On coupe le son
}
break;
// CAS 3 : LE TEST DU CAPTEUR ULTRASON
case MODE_TEST_US:
// On mesure la distance 4 fois par seconde (toutes les 250 ms)
if (millis() - lastUpdate > 250) {
lastUpdate = millis();
// Séquence d'activation du capteur ultrason (on envoie un "clic")
digitalWrite(PIN_TRIG, LOW);
delayMicroseconds(2);
digitalWrite(PIN_TRIG, HIGH);
delayMicroseconds(10);
digitalWrite(PIN_TRIG, LOW);
// On chronomètre le temps que met l'écho à revenir
long duration = pulseIn(PIN_ECHO, HIGH, 30000);
// On calcule la distance en cm avec la vitesse du son
float distance = duration * 0.034 / 2;
lcd.setCursor(0, 1);
lcd.print("Dist: ");
lcd.print(distance, 1);
lcd.print(" cm ");
// Si on approche la main à moins de 15 cm, on allume la LED et on bipe !
if (distance > 0 && distance <= 15.0) { digitalWrite(PIN_LED_R, HIGH); tone(PIN_BUZZER, 2000); } else { digitalWrite(PIN_LED_R, LOW); noTone(PIN_BUZZER); } } break; // CAS 4 : LE TEST DU POTENTIOMÈTRE case MODE_TEST_POT: if (millis() - lastUpdate > 200) {
lastUpdate = millis();
int valPot = analogRead(PIN_POT); // On lit la glissière (valeur de 0 à 1023)
float voltage = valPot * (5.0 / 1023.0); // On convertit cette valeur en Volts
lcd.setCursor(0, 1);
lcd.print("V: ");
lcd.print(voltage, 2); // Affiche la tension avec 2 chiffres après la virgule
lcd.print(" Volts ");
}
break;
// CAS 5 : LE TEST DU SERVOMOTEUR
case MODE_TEST_SERVO:
if (millis() - lastUpdate > 50) {
lastUpdate = millis();
int valPot = analogRead(PIN_POT); // On utilise la glissière pour piloter le moteur
// On transforme la course de la glissière (0 à 1023) en un angle (0 à 180 degrés)
int angle = map(valPot, 0, 1023, 0, 180);
myservo.write(angle); // On déplace le moteur
lcd.setCursor(0, 1);
lcd.print("Angle: ");
lcd.print(angle);
lcd.print(" deg ");
}
break;
// CAS 6 : LE TEST DU BRUIT
case MODE_TEST_SOUND:
if (millis() - lastUpdate > 100) {
lastUpdate = millis();
int valSound = analogRead(PIN_SOUND); // On écoute le micro
lcd.setCursor(0, 1);
lcd.print("Niveau: ");
lcd.print(valSound);
lcd.print(" ");
// Vu-mètre avec les LEDs : plus on fait de bruit, plus on allume de LEDs
digitalWrite(PIN_LED_G, valSound > 100 ? HIGH : LOW);
digitalWrite(PIN_LED_Y, valSound > 300 ? HIGH : LOW);
digitalWrite(PIN_LED_R, valSound > 600 ? HIGH : LOW);
}
break;
// CAS 7 : LE TEST TEMPÉRATURE ET HUMIDITÉ
case MODE_TEST_DHT:
if (millis() - lastUpdate > 1000) { // Mise à jour toutes les secondes seulement
lastUpdate = millis();
dht.read();
float temp = dht.getTemperature();
float hum = dht.getHumidity();
lcd.setCursor(0, 1);
lcd.print("T:");
lcd.print(temp, 1); // Température
lcd.print("C H:");
lcd.print(hum, 1); // Humidité
lcd.print("% ");
}
break;
// CAS 8 : LE TEST DE LUMIÈRE
case MODE_TEST_LIGHT:
if (millis() - lastUpdate > 300) {
lastUpdate = millis();
lcd.setCursor(0, 1);
if (lightSensorOk) {
// Lecture manuelle pour le BH1750 à l'adresse 0x5C
Wire.requestFrom(0x5C, 2);
if (Wire.available() == 2) {
uint16_t val = Wire.read() << 8 | Wire.read(); float lux = val / 1.2; // Conversion brute en Lux lcd.print("Lum: "); lcd.print(lux, 0); lcd.print(" lx "); } } else { lcd.print("ERR INIT I2C "); // Affiche une erreur si le capteur est mal branché } } break; // CAS 9 : LE TEST DE L'ACCÉLÉROMÈTRE case MODE_TEST_IMU: if (millis() - lastUpdate > 300) {
lastUpdate = millis();
lcd.setCursor(0, 1);
if (imuSensorOk) {
float x, y, z;
if (IMU.accelerationAvailable()) {
IMU.readAcceleration(x, y, z); // Récupère l'inclinaison sur les 3 axes
lcd.print("X"); lcd.print(x, 1);
lcd.print(" Y"); lcd.print(y, 1);
lcd.print(" Z"); lcd.print(z, 1);
lcd.print(" ");
}
} else {
lcd.print("ERR INIT I2C ");
}
}
break;
}
}
Vidéo
Conclusion
Pour conclure, ce kit d’apprentissage Elecrow centré sur l’Arduino Nano R4 laisse une très bonne impression globale. Le format de la platine « tout-en-un » est un véritable atout : il élimine complètement la corvée des fils volants et les inévitables problèmes de faux contacts que l’on rencontre souvent avec les plaques d’essais (breadboards). Cette absence de câblage facilite grandement l’apprentissage. L’utilisateur peut se concentrer directement sur l’essentiel, c’est-à-dire l’écriture du code et la compréhension de la logique de chaque composant.
Du côté des ressources, la documentation fournie par Elecrow est complète, bien structurée, et permet d’exploiter chaque module sans difficulté. Le seul regret est que tout ce contenu soit malheureusement disponible uniquement en anglais. Il faudra donc s’appuyer sur des outils de traduction si vous n’êtes pas à l’aise avec l’anglais technique.
Disponibilité et tarif
Si cette solution clé en main vous intéresse pour vous lancer ou pour équiper votre plan de travail, sachez que la valise d’apprentissage Arduino Nano R4 est disponible directement sur le site d’Elecrow. Elle y est proposée au tarif de 48,90 $.
Merci pour cette présentation très intéressante et très complète.