Test du Maker Uno RP2040 avec l’IDE Arduino utilisant un micro servo, un capteur d’humidité du sol, un capteur à ultrasons et des modules OLED I2C

Aujourd’hui, nous allons passer en test la carte de développement Cytron Maker Uno RP2040 combinant le facteur de forme Arduino UNO avec le microcontrôleur Raspberry Pi RP2040 qui la rend programmable avec l’IDE Arduino (C/C++), Micropython ou CircuitPython.

La carte convient aussi bien aux débutants qu’aux utilisateurs avancés avec une disposition de ports pratique qui comprend un connecteur « Maker » plus six connecteurs Grove pour les modules de capteurs et un connecteur pour quatre servos en plus des connecteurs Arduino UNO. La carte propose deux options d’alimentation : USB (5V) via le connecteur USB-C ou une batterie LiPo/Li-Ion monocellulaire via le connecteur LiPo.

Spécifications du fabricant Uno RP2040 de Cytron

• SoC – Processeur Arm Cortex-M0+ double cœur Raspberry Pi RP2040 jusqu’à 133 MHz avec 264 Ko de SRAM
• Stockage – 2 Mo de mémoire flash
• USB – Port USB-C pour l’alimentation et la programmation
• Expansion
  • Embases Arduino UNO pour blindages
  • 6x ports Grove (E/S numériques, sortie PWM, UART, I2C, entrée analogique)
  • 1x port Maker compatible avec les modules Qwiic, STEMMA/QT et Grove (ce dernier via un câble de conversion)
  • Connecteur 12 broches pour 4x servos
• Divers
  • 16x LED d’état pour GPIO
  • 1x Piezo Buzzer avec interrupteur muet
  • Clavier programmable par l’utilisateur
  • Bouton de réinitialisation
  • Bouton de démarrage
  • 2x LED RVB (WS2812)
• Source de courant
  • 5V via port USB-C
  • Connecteur LiPo à cellule unique avec circuit de protection intégré contre les surcharges/décharges
• Dimensions – 60,96 x 9,40 cm (facteur de forme Arduino UNO)

Déballage du kit Cytron Maker Uno RP2040

Le Maker Uno RP2040 peut être acheté en tant que carte autonome, mais nous avons demandé quelques modules pour rendre l’test plus intéressant et avons tout reçu dans un seul package.

Notre kit comprend le Maker Uno RP2040 lui-même, quatre câbles Grove vers jumper, un câble USB-A vers USB-C, un capteur d’humidité du sol avec un câble Grove, un capteur à ultrasons HC-SR04 avec un câble Grove, un micro servo SG90 avec accessoires, un écran OLED I2C de 0,96 pouces (résolution 128 × 64) et quatre pieds en caoutchouc de silicone.

Voici un aperçu plus approfondi du haut du tableau…

… et la face inférieure avec le microcontrôleur Raspberry Pi RP2040 et une zone blanche pour permettre aux étudiants d’écrire leur nom.

Tous les modules sont des pièces disponibles dans le commerce, nous n’entrerons donc pas dans les détails cette fois.

Premiers pas avec la carte Maker Uno RP2040 à l’aide de l’IDE Arduino

Comme mentionné dans l’introduction, le Maker Uno RP2040 peut être alimenté soit par un câble USB Type-C (5 V), soit par une batterie Li-Po/Li-Ion monocellulaire (3,7 V). Dans cette test, nous utiliserons un câble USB Type-C pour l’alimentation et pour programmer la carte avec un ordinateur portable exécutant Windows 11.

Le Maker Uno RP2040 prend en charge la programmation Arduino, Micropython et CircuitPython, mais dans cette test, nous nous concentrerons sur le premier. La première étape consiste donc à télécharger et installer l’IDE ​​Arduino pour votre système d’exploitation. Nous avons utilisé la dernière version disponible au moment de l’test, à savoir Arduino IDE 2.3.2 pour Windows.

Configuration de l’IDE Arduino

Nous suivrons principalement le tutoriel de Cytron pour travailler avec le Cytron Maker UNO RP2040 à l’aide de l’IDE Arduino. Trois étapes sont nécessaires pour la configuration initiale.

1. Ajoutez Maker Uno RP2040 à l’IDE Arduino.
   • • Accédez au menu Fichier-> Préférences et ajoutez l’URL «https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json» dans les «URL du gestionnaire de cartes supplémentaires».
     • Sélectionnez OK et recherchez « Uno RP2040 » pour installer le package de la carte.
     • Une fois installée, vous trouverez la carte Maker Uno RP2040 dans l’IDE Arduino. Sélectionnez-le simplement dans Outils > Carte > Raspberry Pi Pico/RP2040 > Cytron Maker Uno RP2040 ou dans le menu déroulant.

   

2. Entrez en mode Bootloader en connectant le Maker Uno RP2040 à votre ordinateur portable. Appuyez et maintenez le bouton BOOT et appuyez sur RESET (une seule pression !) et un nouveau lecteur nommé RPI-RP2 apparaîtra dans le gestionnaire de fichiers.
   
3. Sélectionnez la carte et le port COM
   • Sélectionnez la carte Maker Uno RP2040 dans Outils > Carte > Raspberry Pi Pico/RP2040 > Cytron Maker Uno RP2040
   • Sélectionnez le port COM en allant dans Outils > Port (la première fois, le port COM sera « UF2_Board »). Après avoir téléchargé le croquis, la carte sera réinitialisée et le port COM apparaîtra sous un nom tel que « COM12 ». Nous sommes maintenant prêts à commencer à coder.

Faire clignoter certaines LED

Assurez-vous que la bonne carte et le bon port COM sont sélectionnés dans l’Arduino et copiez le code suivant pour faire clignoter deux LED toutes les 500 ms :

</p><br /> <p>/* DESCRIPTION : Cet exemple de code utilisera Maker Uno RP2040 pour allumer alternativement l’une des deux LED GPIO intégrées. Pour ce code, les LED GPIO pour GPO et la broche GP1 sont sélectionnées. Chaque LED clignotera alternativement toutes les 0,5 secondes. AUTEUR : Cytron Technologies Sdn Bhd SITE WEB : www.cytron.io EMAIL : support@cytron.io */ // Affectations des broches pour les LED const int ledPin1 = 0; const int ledPin2 = 1 ; void setup() { // initialise les LED sur les broches GP0 et GP1 en sortie. pinMode(ledPin1, SORTIE); pinMode(ledPin2, SORTIE); } void loop() { // la led GP0 s’allume pendant 0,5 s puis s’éteint. digitalWrite(ledPin1, ÉLEVÉ); retard (500); digitalWrite(ledPin1, FAIBLE); retard (500); // la led GP1 s’allume pendant 0,5s puis s’éteint. digitalWrite(ledPin2, ÉLEVÉ); retard (500); digitalWrite(ledPin2, FAIBLE); retard (500); }

Sélectionnez Vérifier pour vérifier la compilation du code, puis téléchargez le croquis sur votre carte Maker Uno RP2040.

Deux LED devraient maintenant clignoter sur la carte (connectée à GP0 et GP1) en alternance toutes les 0,5 secondes. (Notez que GP2 est toujours activé et que nous ne pouvons pas voir clairement GP1 dans le fichier WebP animé ci-dessus, mais il clignote également).

Contrôler les LED RVB

Voici un croquis Arduino pour faire alterner les couleurs des deux LED RVB de la carte en passant du rouge, du vert, du bleu et de l’extinction :

</p><br /> <p>/* DESCRIPTION : Cet exemple de code utilisera Maker Uno RP2040 pour éclairer les LED RVB intégrées. Les LED RVB changeront séquentiellement leurs couleurs individuellement. AUTEUR : Cytron Technologies Sdn Bhd SITE WEB : www.cytron.io EMAIL : support@cytron.io RÉFÉRENCE : Lien de la bibliothèque Adafruit_NeoPixel : https://github.com/adafruit/Adafruit_NeoPixel/tree/master */ #include <Adafruit_NeoPixel.h> // Déclare le numéro de broche de la LED Neopixel et le numéro de la LED const int neoPin = 25; const int numPixels = 2; // Initialise les LED NeoPixel RGB sur la broche GP25 Adafruit_NeoPixel pixels (numPixels, neoPin, NEO_GRB + NEO_KHZ800); void setup() { pixels.begin(); // Initialise la bibliothèque NeoPixel pixels.clear(); // Définit toutes les couleurs de pixels sur « off » pixels.show(); // Envoie les couleurs des pixels mises à jour au matériel. } void loop() { // pixels.Color() prend des valeurs RVB, de 0,0,0 à 255 255 255 // Les NeoPixels sont numérotés de 0 à (nombre de pixels – 1). pixels.setPixelColor(0, pixels.Color(200, 0, 0)); // Rouge pixels.setPixelColor(1, pixels.Color(200, 0, 200)); // Pixels magenta.show(); // Envoie les couleurs des pixels mises à jour au matériel. retard (1000); pixels.setPixelColor(0, pixels.Color(0, 200, 0)); // Vert pixels.setPixelColor(1, pixels.Color(200, 200, 0)); // Pixels jaunes.show(); // Envoie les couleurs des pixels mises à jour au matériel. retard (1000); pixels.setPixelColor(0, pixels.Color(0, 0, 200)); // Bleu pixels.setPixelColor(1, pixels.Color(0, 200, 200)); // Pixels cyan.show(); // Envoie les couleurs des pixels mises à jour au matériel. retard (1000); pixels.setPixelColor(0, pixels.Color(0, 0, 0)); // Noir (éteint la LED) pixels.setPixelColor(1, pixels.Color(0, 0, 0)); // Noir (éteint la LED) pixels.show(); // Envoie les couleurs des pixels mises à jour au matériel. retard (1000); }

Téléchargeons maintenant le croquis sur la carte maker Uno RP2040…

Les LED RVB changeront de couleur et s’éteindront en boucle comme prévu.

Piloter une LED avec le bouton utilisateur

Le croquis Arduino ci-dessous allume ou éteint la LED connectée à la broche GP1 lorsque vous appuyez sur le bouton utilisateur (GP2) de la carte Maker Uno RP2040 :

</p><br /> <p>/* DESCRIPTION : Cet exemple de code montrera comment utiliser le bouton Utilisateur du Maker Uno RP2040 comme entrée. Dans ce code, le bouton sera utilisé pour contrôler une LED embarquée. Si le bouton est enfoncé, la LED s’allumera pendant 0,5 seconde puis s’éteindra AUTEUR : Cytron Technologies Sdn Bhd SITE WEB : www.cytron.io EMAIL : support@cytron.io */ // Déclarez les affectations des broches pour la LED et le bouton. const int ledPin1 = 8 ; const int btn1 = 2; void setup() { // initialise les broches des LED GP8 en sortie et le bouton utilisateur GP2 en entrée pinMode(ledPin1, OUTPUT); pinMode(btn1, INPUT_PULLUP); } void loop() { // cochez le bouton 1 (GP2) enfoncé if (!digitalRead(btn1)) { // la led GP0 s’allume pendant 0,5 s puis s’éteint. digitalWrite(ledPin1, ÉLEVÉ); retard (500); digitalWrite(ledPin1, FAIBLE); } }

Test du buzzer

Nous jouerons du son via le buzzer lorsque nous appuierons sur le bouton utilisateur (GP2) en utilisant ce code :

</p><br /> <p>/* DESCRIPTION : Cet exemple de code utilisera le buzzer du Maker Uno RP2040 pour jouer les tonalités. Le bouton Utilisateur également utilisé dans ce code. Au démarrage, une courte mélodie sera jouée, puis le code attendra que vous appuyiez sur le bouton pour jouer une autre série de tonalités courtes. AUTEUR : Cytron Technologies Sdn Bhd SITE WEB : www.cytron.io EMAIL : support@cytron.io */ // Déclarer l’affectation des broches pour le buzzer et le bouton const int buzzerPin = 8; const int btn1 = 2; // Crée un tableau de la fréquence des notes mélodiques avec sa durée correspondante pour chaque note int melody_note[10] = {659, 659, 0, 659, 0, 523, 659, 0, 784, 0} ; // [E5, E5, REST, E5, REST, C5, E5, REST, G5]<br /><br /> int mélodie_durée[10] = {150, 150, 150, 150, 150, 150, 150, 150, 200, 150} ; void setup(){ // Initialise la broche du buzzer comme sortie pinMode(buzzerPin, OUTPUT); // Initialiser les boutons pinMode(btn1, INPUT_PULLUP); // Joue la mélodie au démarrage play_melody(buzzerPin); } void loop(){ // Vérifiez que le bouton 1 (GP2) est enfoncé if (!digitalRead(btn1)) { // Joue des tonalités (buzzerPin,262,100); retard (100); tonalité (buzzerPin, 659 100); retard (100); tonalité (buzzerPin, 784 100 ); retard (100); pas de tonalité (buzzerPin); } } void play_melody(int pin){ for(int i=0; i<10; i++){ if(melody_note[i] == 0){ noTone(broche); } autre{ ton(pin, melody_note[i], 100); } delay(int(melody_duration[i])); } }

Après avoir téléchargé le croquis, nous devrions entendre un court extrait de la mélodie du thème de Mario Bros à chaque fois que nous appuyons sur le bouton utilisateur.

Croquis Arduino pour contrôler un micro servo du Maker Uno RP2040

Jusqu’à présent, nous n’avons testé que le matériel intégré à la carte Maker Uno RP2040, mais nous allons maintenant commencer à tester les capacités d’extension en connectant un micro servo S90 aux broches GP14, + et – de l’en-tête SERVO.

Le croquis Arduino ci-dessous fera tourner les quatre servos de 0 degrés à 180 degrés et inversement dans une boucle infinie :

</p><br /> <p>/* DESCRIPTION : Cet exemple de code utilisera Maker UNO RP2040 pour contrôler quatre servomoteurs connectés aux ports de servo intégrés. Le servomoteur balayera de 0° à 180° avec un incrément de 1° toutes les 10 millisecondes. Ensuite, les servos reviennent de 180 degrés à 0 degré avec une décrémentation de 1 degré toutes les 10 millisecondes. AUTEUR : Cytron Technologies Sdn Bhd SITE WEB : www.cytron.io EMAIL : support@cytron.io */ // Inclut la bibliothèque de servos #include <Servo.h> // Crée des objets servo pour chaque servos Servo servo1; Servoservo2 ; Servoservo3 ; Servoservo4 ; void setup() { // Attache chaque objet servo aux broches correspondantes servo1.attach(14); servo2.attach(15); servo3.attach(16); servo4.attach(17); } void loop() { // Déplacez les servos de 0 degré à 180 degrés avec un incrément de 1 degré par pas pour (int pos = 0; pos <= 180; pos += 1) { servo1.write(pos) ; // Définit la position du servo 1 sur les degrés ‘pos’ servo2.write(pos); // Définit la position du servo 2 sur les degrés ‘pos’ servo3.write(pos); // Définit la position du servo 3 sur les degrés ‘pos’ servo4.write(pos); // Réglez la position du servo 4 sur ‘pos’ degrés delay(10); // Pause de 15 millisecondes pour contrôler la vitesse de mouvement du servo } // Déplacez les servos de 180 degrés à 0 degré avec un décrément de 1 degré par pas pour (int pos = 200; pos >= 0; pos -= 1 ) { servo1.write(pos); // Définit la position du servo 1 sur les degrés ‘pos’ servo2.write(pos); // Définit la position du servo 2 sur les degrés ‘pos’ servo3.write(pos); // Définit la position du servo 3 sur les degrés ‘pos’ servo4.write(pos); // Réglez la position du servo 4 sur ‘pos’ degrés delay(10); // Pause de 15 millisecondes pour contrôler la vitesse de mouvement du servo } } /* REMARQUE : ce code est écrit pour les servomoteurs standard. Si vous utilisez un servo à rotation continue de 360 ​​degrés, la fonction servo.write (pos) se comporte différemment du servo standard. Il contrôle la vitesse plutôt que la position. Une valeur proche de 90 signifie aucun mouvement, 0 correspond à pleine vitesse dans un sens et 180 à pleine vitesse dans l’autre sens */

Nous n’avons qu’un seul micro servo que nous avons connecté au GP14 (S1) et ajouté un petit drapeau pour un effet dramatique 🙂

Le servomoteur tourne en douceur de 0° à 180° par incréments de 1° toutes les 10 ms. Lorsqu’il atteint 180°, il inverse sa direction et revient à 0° par incréments de 1° toutes les 10 ms.

Lecture des valeurs analogiques d’un capteur d’humidité du sol

La carte Maker Uno RP2040 est livrée avec divers connecteurs Grove avec des interfaces numériques, analogiques ou I2C.

Nous allons d’abord tester un connecteur analogique (Grove 5) à l’aide d’un capteur d’humidité du sol Maker pour mesurer l’humidité dans un verre d’eau.

Il y a des LED sèches, humides et mouillées sur le module de capteur, mais le code suivant signalera les valeurs brutes et de tension de la broche A3 (GP29) du moniteur série :

</p><br /> <p>/* DESCRIPTION : Cet exemple de code utilisera Maker Uno RP2040 pour lire l’entrée analogique du Maker Soil Module, puis affichera le résultat sur le moniteur série. Ce code s’applique également à tout capteur analogique. CONNEXION : Grove 5 du Maker Uno RP2040 : Maker Soil Module GP29 – Broche OUT du Maker Soil Module AUTEUR : Cytron Technologies Sdn Bhd SITE WEB : www.cytron.io EMAIL : support@cytron.io */ int sensorPin = 29; // sélectionne la broche d’entrée pour le potentiomètre int raw_value = 0; valeur de tension flottante = 0 ; void setup() { // déclare le sensorPin comme OUTPUT : pinMode(sensorPin, INPUT); Série.begin(9600); // active la résolution adc sur 12 bits (10 bits par défaut) analogReadResolution(12); } void loop() { // lit la valeur du capteur : raw_value = analogRead(sensorPin); // Convertit la valeur brute de l’ADC en tension (3,3 V est la référence de tension de la carte) voltage_value = (raw_value * 3,3) / 4095 ; Serial.print(« Valeur brute : « ); Serial.println(raw_value); Serial.print(« Valeur de tension : « ); Serial.println(voltage_value); Serial.println(« ——————————–« ); retard (1000); }

Une fois le croquis exécuté, nous pouvons ouvrir le moniteur série pour vérifier les mises à jour des valeurs en boucle toutes les 1 secondes.

Lecture des valeurs numériques d’un capteur à ultrasons HC-SR04

Bien que seuls deux des connecteurs Grove prennent en charge l’analogique, n’importe lequel des 6 connecteurs Grove et le port Maker peuvent être configurés pour accepter un capteur numérique. Dans cette test, nous utiliserons un module de capteur à ultrasons HC-SR04 connecté aux broches 20 (signal ECHO), 21 (signal TRIG) et 3,3 V et GND du connecteur Grove 6 de la carte Maker Uno RP2040 afin de mesurer la distance jusqu’à la boîte de vente au détail Cytron.

Voici le croquis Arduino pour mesurer la distance et afficher la valeur sur le moniteur série :

</p><br /> <p>/* DESCRIPTION : Cet exemple de code utilisera le Maker UNO RP2040 avec le capteur à ultrasons HC-SR04P pour mesurer la distance, puis affichera les lectures sur le moniteur série. CONNEXION : HC-SR04P – Grove 6 du Maker UNO RP2040 ou GP20 – Broche Echo du HC-SR04P GP21 – Broche Trig du HC-SR04P AUTEUR : Cytron Technologies Sdn Bhd SITE WEB : www.cytron.io EMAIL : support@cytron.io RÉFÉRENCE : Code adapté de www.HowToMechatronics.com : https://howtomechatronics.com/tutorials/arduino/ultrasonic-sensor-hc-sr04/ */ // définit les numéros de broches const int echoPin = 20 ; const int trigPin = 21 ; // définit les variables de longue durée ; distance intérieure ; void setup() { pinMode(trigPin, SORTIE); // Définit le trigPin comme Output pinMode(echoPin, INPUT); // Définit echoPin comme entrée Serial.begin(9600); // Démarre la communication série } void loop() { // Efface le trigPin digitalWrite(trigPin, LOW); delayMicroseconds(2); // Définit le trigPin sur l’état HIGH pendant 10 microsecondes digitalWrite(trigPin, HIGH); delayMicroseconds(10); digitalWrite(trigPin, FAIBLE); // Mesure la réponse de echoPin duration = pulseIn(echoPin, HIGH); // Calculez la distance à partir de la valeur de durée // Utilisez 343 mètres par seconde comme vitesse du son distance = durée * 0,034 / 2 ; // Imprime la distance sur le Serial Monitor Serial.print(« Distance : « ); Serial.print(distance); Serial.println( » cm »); retard (100); }

Téléchargeons le code sur le tableau et déplaçons la boîte à différentes distances du colis.

La distance sera affichée sur le moniteur série en centimètres.

Connexion d’un module OLED I2C au Maker Uno RP2040.

Nous avons déjà testé l’entrée analogique et l’interface E/S numérique, et nous allons maintenant passer en I2C en utilisant le petit écran OLED SSD1315 fourni dans notre kit connecté au connecteur Grove 6 I2C.

Voici un simple croquis Arduino pour écrire quelques messages sur le module OLED :

</p><br /> <p>/* DESCRIPTION : Cet exemple de code montrera comment utiliser Maker UNO RP2040 avec l’écran OLED SSD1315 pour afficher du texte. CONNEXION : Grove 6 de Maker UNO RP2040 – Écran OLED SSD1315 Grove GP20 – SDA GP21 – SCL AUTEUR : Cytron Technologies Sdn Bhd SITE WEB : www.cytron.io EMAIL : support@cytron.io REFERENCE : Code adapté de : https://wiki .seeedstudio.com/Grove-OLED-Display-0.96-SSD1315/ */ #include <Arduino.h> #include <U8g2lib.h> #ifdef U8X8_HAVE_HW_SPI #include <SPI.h> #endif #ifdef U8X8_HAVE_HW_I2C #include <Wire .h> #endif U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock(SCL)*/ SCL, /*data(SDA)*/ SDA, /* reset=*/ U8X8_PIN_NONE); void setup(void) { u8g2.begin(); } boucle vide(void) { u8g2.clearBuffer(); u8g2.setFont(u8g2_font_ncenB08_tr); // Coordonnées ajustées pour un meilleur positionnement u8g2.drawStr(5, 15, « Hello »); u8g2.drawStr(5, 30, « Cnx-Software »); u8g2.sendBuffer(); retard (1000); }

La première fois que nous avons essayé de compiler le code, cela s’est soldé par un échec en raison de l’absence du fichier u8g2lib.h.

C’est parce que nous n’avons pas encore installé la bibliothèque graphique U8g2. Il peut être installé en allant dans Outils-> Gérer les bibliothèques et en recherchant u8g2.

Après avoir chargé le code sur le tableau, l’écran reste toujours sombre. Nous avons finalement essayé un autre module d’affichage OLED similaire (également adresse I2C 0x7B) et le texte s’est affiché correctement.

Dans cette test de la carte Maker Uno RP2040 avec l’IDE Arduino, nous avons pu faire clignoter les LED, contrôler les lumières LED RVB, appuyer sur le bouton utilisateur pour allumer une LED ou faire émettre une mélodie au buzzer, contrôler un micro servo, lire les valeurs du capteur à partir d’un capteur d’humidité du sol (analogique) et un capteur à ultrasons (E/S numérique), ainsi que l’affichage du texte sur un module OLED I2C.

Tout cela a pu être fait relativement facilement grâce aux tutoriels de Cytron qui sont assez faciles à suivre même pour un débutant. La carte est adaptée à l’enseignement STEM avec des LED intégrées, des LED RVB, un buzzer et des capacités d’extension via les embases Arduino et les connecteurs Grove et Maker.

Nous tenons à remercier Cytron de nous avoir envoyé le kit Maker Uno RP2040 pour test. La carte Maker Uno RP2040 peut être achetée au prix de 14,90 $ auprès de certains distributeurs locaux en Europe, en Inde, au Japon et en Égypte. Ils ne vendent pas directement le kit que nous avons reçu, mais vous trouverez le capteur d’humidité du sol Maker, le capteur à ultrasons HC-SR04, le micro servo SG90 et l’écran OLED I2C de 0,96 pouces sur la boutique en ligne de l’entreprise.

Retrouvez l’histoire de Raspberry Pi dans cette vidéo :