Test SunFounder GalaxyRVR – Un robot de type Mars Rover programmable Arduino pour l’éducation

SunFounder nous a envoyé un robot GalaxyRVR à 6 roues pour test. Il ressemble aux robots Mars Rover de la NASA mais cible le marché de l’éducation avec une carte compatible Arduino UNO R3 et une carte ESP32-CAM pour la connectivité WiFi et la capture vidéo.

Le kit robot GalaxyRVR peut transmettre des signaux vidéo via WiFi pour explorer la planète Terre avec votre appareil mobile ou votre tablette et la caméra peut être réglée de haut en bas grâce à un servomoteur. Le robot est alimenté par un panneau solaire couplé à une batterie et dispose de capteurs tels que des modules d’évitement d’obstacles et à ultrasons.

Les robots d’exploration Mars Rover de la NASA

La NASA utilise actuellement le rover Perseverance, également connu sous le nom de Percy, comme dernier robot d’exploration planétaire à atterrir sur Mars. Il est conçu pour explorer le cratère Jezero dans le cadre de la mission Mars 2020 de la NASA. En plus de ses instruments scientifiques, Perseverance embarque également Ingenuity, un petit hélicoptère martien expérimental.

Le kit robot SunFounder GalaxyRVR simule une structure mobile avec le même système de mécanisme Rocker-Bogie utilisé dans le rover Mars de la NASA avec la capacité d’explorer tous les types de terrains. Qu’il s’agisse d’une montagne rocheuse, d’une plage de sable ou d’un champ herbeux, un système d’amortissement des vibrations aide le robot à se déplacer en douceur.

Qu’est-ce qu’un système Rocker-Bogie ?

Le système Rocker-Bogie est un mécanisme capable de surmonter les obstacles environnementaux et a été conçu pour s’adapter à la topographie imprévisible de Mars, notamment les pentes abruptes et les gros rochers. Le système peut franchir des obstacles et utiliser ses six roues pour naviguer sur des terrains difficiles et explorer différentes zones de la planète.

Déballage et assemblage du kit SunFounder GalaxyRVR

Le kit robot SunFounder GalaxyRVR est livré avec plus de 300 pièces (y compris les vis) que les utilisateurs doivent apprendre à assembler eux-mêmes. Les instructions peuvent être trouvées sur GitHub (PDF).

Les personnes qui préfèrent les didacticiels vidéo peuvent consulter les instructions de montage dans la vidéo ci-dessous.

Nous allons maintenant entrer dans le détail des composants clés du kit. C’est assez long, vous pouvez donc passer à la partie programmation si vous souhaitez poursuivre la révision sans connaître les détails de chaque composant.

SunFounde R3 : carte de contrôle GalaxyRVR

Le SunFounder R3 est une carte microcontrôleur basée sur ATmega328P avec 14 ports d’E/S numériques (dont 6 peuvent être utilisés comme sorties PWM) et 6 broches d’entrée analogiques. Il se connecte à un ordinateur via un câble de périphérique USB pour télécharger un programme et peut être alimenté avec un adaptateur AC-DC ou une batterie 7-12 V pour commencer.

Il s’agit essentiellement d’un clone du populaire Arduino UNO R3.

Bouclier SunFounder GalaxyRVR

Le bouclier GalaxyRVR est une carte d’extension qui s’installe sur la carte Arduino SunFounder S3 et comprend des connecteurs pour les moteurs, les lumières RVB, les capteurs d’évitement d’obstacles IR, la carte ESP32-CAM et les modules à ultrasons.

La carte d’extension dispose également d’un circuit de charge et d’un connecteur PH2.0-3P pour une batterie LiPo. Une charge complète d’une batterie 18 650 7,4 V 2 000 mAh prend environ 130 minutes.

Liste des ports sur le bouclier GalaxyRVR :

• Port moteur
  • Ports moteur (à droite) – 3 moteurs peuvent être connectés aux 3 moteurs contrôlés par le même ensemble de broches de signal 2 et 3.
  • Ports moteur (gauche) – 3 moteurs peuvent être connectés aux 3 moteurs contrôlés par le même ensemble de broches de signal 4 et 5.
  • Type de port : XH2.54, 2P.
• Caméra I/F – connecteur à 5 broches pour le port de la carte adaptateur de caméra
• Servo de la caméra – Le servo de la caméra est connecté. Le fil marron se connecte au « – », le fil rouge se connecte au « + » et le fil jaune se connecte à la broche 6.
• Capteurs
  • IR GAUCHE/DROITE – Connecteurs à 3 broches pour modules d’évitement d’obstacles IR. Le module d’évitement d’obstacles gauche est connecté à la broche 8, le module d’évitement d’obstacles droit est connecté à la broche 7.
  • SONAR – connecteur 4 broches pour les broches Trig et Echo
• Divers
  • Bouton de réinitialisation – Appuyez sur ce bouton pour réinitialiser le programme sur la carte Arduino.
  • Indicateurs
    • Indicateur de charge – S’allume en rouge lorsque le bouclier se charge via le port USB-C.
    • Indicateur d’alimentation – S’allume en vert lorsque l’interrupteur d’alimentation est en position « ON ».
    • Indicateur de batterie – Deux indicateurs orange représentent différents niveaux de batterie. Ils clignotent pendant la charge et s’éteignent lorsque la batterie doit être rechargée.
  • Interrupteur d’alimentation – Faites glisser sur ON pour allumer le GalaxyRVR
  • Bande RVB – Pour connecter 2 bandes LED RVB.
  • Commutateur de mode – L’ESP32-CAM et la carte Arduino partagent les mêmes broches RX (réception) et TX (transmission). Ainsi, lorsque vous téléchargez du code, vous devrez basculer ce commutateur vers la droite pour déconnecter l’ESP32-CAM afin d’éviter tout conflit ou problème potentiel.
• Pouvoir
  • Port de charge – Port USB-C 5 V/2 A utilisé pour charger la batterie
  • Port de batterie – Entrée d’alimentation 6,6 V ~ 8,4 V PH2.0 à 3 broches pour une batterie alimentant à la fois le Shield GalaxyRVR et la carte Arduino
  • SOLAR – Connecteur 2 broches pour le panneau solaire

ESP32-CAM

L’ESP32-CAM est un petit module de caméra OV2560 doté d’un module WiFi ESP32-S et d’un emplacement pour carte microSD pour stocker les images prises avec la caméra. Il mesure 27 x 40,5 x 4,5 mm et ne consomme que 6 mA.

Carte adaptateur ESP32-CAM

La carte adaptateur ESP32-CAM est une carte d’extension pour l’ESP32-CAM utilisée pour le connecter au robot SunFounder GalaxyRVR.

La carte adaptateur ESP32-CAM se connecte à la carte d’extension SunFounder GalaxyRVR via un connecteur ZH 1.5 à 5 broches.

Module à ultrasons HC-SR04

Le robot GalaxyRVR dispose également d’un capteur de distance à ultrasons HC-SR04 disponible dans le commerce avec une portée de 2 cm à 400 cm et une plage de précision allant jusqu’à 3 mm.

Le port du module à ultrasons est connecté au connecteur à 5 broches du bouclier SunFounder GalaxyRVR.

Module d’évitement d’obstacles IR

Le module d’évitement d’obstacles infrarouge est un module d’évitement d’obstacles infrarouge qui peut détecter des objets devant vous. Il est généralement utilisé dans les robots. La plage de détection est de 2 cm à 40 cm et les objets de différentes couleurs ont différents niveaux de réflectivité. Ainsi, plus l’objet est sombre, plus la distance de détection est courte.

Le module d’évitement d’obstacles IR se compose d’un émetteur IR et d’un récepteur IR. Il émet un signal lumineux infrarouge et lorsque la lumière infrarouge émise frappe un objet, elle est réfléchie vers le photorécepteur. Lorsque la lumière sur la carte du capteur est détectée, l’état sera affiché et il enverra un signal de bas niveau à la broche de SORTIE.

Les deux modules d’évitement d’obstacles IR sont connectés à la carte d’extension SunFounder GalaxyRVR via les connecteurs IR GAUCHE et IR DROITE à 3 broches.

Bande LED RVB

Deux bandes LED RVB avec quatre LED RVB R5050 font partie du kit.

Ils sont connectés à deux 4 broches connectées sur le bouclier SunFounder GalaxyRVR.

Moteur à engrenages TT

Chaque roue est rattachée à un motoréducteur TT. Tous les engrenages sont logés dans une construction en plastique durable avec un rapport d’engrenage de 1:120 et deux fils de 250 mm avec connecteurs XH2.54-2P (3 V CC).

Spécifications du moteur TT :

• Tension de fonctionnement – ​​3 V ~ 4,5 V CC
• Nombre d’arbres – Arbre simple Rapport de démultiplication : 1:120
• Courant à vide – 130 mA
• Vitesse de rotation sous charge – 38 tr/min ±8 % tr/min
• Tension de démarrage – 2 V (maximum) sans charge
• Couple de sortie – 3 V ≥ 1,2 kgf.cm
• Durée de vie – 70-120H
• Sens de rotation – deux directions
• Dimensions – 70 x 22,5 x 36,6 mm
• Fil – gris et noir 24 AWG, longueur 250 mm.
• Connecteur – Blanc XH2.54-2P
• Poids – 28,5 grammes

Chaque motoréducteur TT est connecté via un connecteur à 2 broches sur le blindage SunFounder Galaxy RVR avec trois blocs de connecteurs pour les moteurs gauche et droit.

roues

Le robot SunFounder GalaxyRVR est livré avec 6 roues d’un diamètre de 75 mm chacune et d’une largeur de 37 mm en caoutchouc synthétique adaptées pour glisser sur tous types de sols.

Servomoteur

Le servomoteur est utilisé pour contrôler la position angulaire de la caméra avec une grande précision. Le servomoteur est doté d’un engrenage métallique, prend une entrée de 4,8 à 7,4 volts CC et peut tourner jusqu’à 180 degrés.

Il est connecté via un connecteur à 3 broches au bouclier GalaxuRVR.

Panneau solaire

Un panneau solaire est un appareil qui convertit l’énergie solaire en énergie électrique. Il se compose d’une cellule photovoltaïque (PV), constituée de matériaux semi-conducteurs tels que le silicium. Lorsque la lumière du soleil frappe la cellule photovoltaïque, elle éloigne les électrons des atomes et ces électrons traversent la cellule en générant un courant électrique. Les panneaux solaires peuvent être utilisés pour produire de l’électricité à diverses fins. Cela inclut l’alimentation en électricité des maisons, des entreprises et même de communautés entières. Il s’agit d’une source d’énergie propre et renouvelable qui peut contribuer à réduire notre dépendance aux combustibles fossiles.

Caractéristiques du panneau solaire

• Puissance de sortie – 6 V/660 mA
• Temps pour charger complètement la batterie – 7,2 heures (théorique, en supposant un soleil éclatant)
• Dimensions – 170 x 170 mm
• Fil – gris et noir 24AWG 200mm
• Connecteur – Blanc XH2.54-2P

Batterie

La batterie est produite par SunFounder lui-même. Il se compose de deux batteries 18 650 d’une capacité de 2 000 mAh. Le connecteur est un connecteur XH2.54 à 3 broches conçu pour être branché sur le blindage GalaxyRVR.

Principales caractéristiques

• Chargement de la batterie – 5V/2A
• Sortie batterie – 5V/5A
• Capacité de la batterie – 2x 3,7 V 2 000 mAh
• Autonomie de la batterie – 90 minutes
• Temps de charge de la batterie – 130 minutes
• Connecteur – 3 broches XH2.54

Gestion de l’énergie du robot SunFounder GalaxyRVR

Les principaux composants de ce système électrique sont les batteries et le panneau solaire alimenté par le soleil. Travaillant en tandem, le robot GalaxyRVR peut travailler à toute heure du jour et de la nuit.

Premiers pas avec le robot SunFounder GalaxyRVR

Le robot GalaxyRVR peut être programmé en langage C avec l’IDE Arduino. Le robot SunFounder GalaxyRVR nécessitait trois bibliothèques. Les utilisateurs doivent accéder au gestionnaire de bibliothèques pour les installer en commençant par la bibliothèque Servo.

Répétez la même chose pour les bibliothèques « SoftPWM » et « SunFounder AI Camera ». Le téléchargement de programmes sur la carte SunFounder S3 nécessite de déplacer le commutateur de téléchargement vers la droite pour se déconnecter de l’ESP32-CAM.

Faites maintenant glisser l’interrupteur d’alimentation sur « ON » pour allumer le robot GalaxyRVR.

Test des lumières LED RVB

Pour tester les LED RVB, nous avons effectué une série de cycles pour changer les couleurs.

Voici le code du programme de test :

</p><br /> <p>#include <SoftPWM.h> // Inclut la bibliothèque SoftPWM // Définit les numéros de broches pour les bandes RVB const int bluePin = 11; const int redPin = 12 ; const int greenPin = 13 ; /* Calibrer la luminosité */ #define R_OFFSET 1.0 #define G_OFFSET 0.25 #define B_OFFSET 0.45 void setup() { SoftPWMBegin(); // Initialise le PWM logiciel sur toutes les broches } void loop() { // Définit différentes couleurs avec un délai de 1 seconde (1000 ms) entre setColor(255, 0, 0); // Définit la couleur sur rouge delay(1000); setColor(255, 128, 0); // Définit la couleur sur orange delay(1000); setColor(255, 255, 0); // Définit la couleur sur jaune delay(1000); setColor(0, 255, 0); // Définit la couleur sur vert delay(1000); setColor(0, 0, 255); // Définit la couleur sur bleu delay(1000); setColor(0, 255, 255); // Définit la couleur sur bleu clair delay(1000); setColor(255, 0, 255); // Définit la couleur sur violet delay(1000); setColor(255, 255, 255); // Définit la couleur sur blanc delay(1000); } // Définir une fonction pour définir la couleur void setColor(int red, int green, int blue) { SoftPWMSet(redPin, red * R_OFFSET); // Définir la couleur rouge SoftPWMSet(greenPin, green * G_OFFSET); // Définir la couleur verte SoftPWMSet(bluePin, blue * B_OFFSET); // Définir la couleur bleue }

Programme de test de contrôle du servomoteur pour monter et descendre la caméra ESP32.

Nous avons testé le servomoteur en écrivant du code ajustant la caméra de 0 degrés à 180 degrés en retardant le changement de degré toutes les 100 millisecondes.

Exemple de code :

</p><br /> <p>#include <Servo.h> Servo monServo ; // crée un objet servo void setup() { myServo.attach(6); // attache le servo sur la broche 6 Serial.begin(9600); // initialise la communication série à un débit en bauds de 9600 } void loop() { for (int i = 0; i <= 180; i++) { // boucle de 0 à 180 degrés Serial.print(« L’angle est :  » ); // affiche les informations sur l’angle Serial.println(i); // affiche la valeur d’angle actuelle myServo.write(i); // contrôle le servo pour qu’il se déplace vers le délai d’angle actuel (100) ; // délai de 100 millisecondes } }

Tests de mouvement du robot SunFounder Galaxy RVR

Nous avons ensuite écrit un exemple de programme pour avancer, tourner à gauche, tourner à droite, reculer et arrêter le robot, avec des commandes séquencées.

Exemple de code :

</p><br /> <p>#include <SoftPWM.h> // Définir les broches des moteurs const int in1 = 2; const int dans2 = 3 ; const int dans3 = 4 ; const int in4 = 5 ; void setup() { // Initialiser SoftPWM SoftPWMBegin(); } void loop() { moveForward(200); // Déplace le Rover vers l’avant delay(1000); tourner à gauche (200); // Tournez le Rover vers la gauche delay(1000); moveForward(200); // Déplace le Rover vers l’avant delay(1000); tourner à gauche (200); // Tournez le Rover vers la gauche delay(1000); moveForward(200); // Déplace le Rover vers l’avant delay(1000); moveBackward(200); // Déplace le Rover vers l’arrière delay(1000); tourner à droite (200); // Tournez le Rover vers la droite delay(1000); stopMove(); // Arrête le délai Rover (5000); } void moveForward(int speed) { // Définit la rotation des moteurs gauche dans le sens inverse des aiguilles d’une montre SoftPWMSet(in1, speed); SoftPWMSet(in2, 0); // Définit la rotation des moteurs droits dans le sens des aiguilles d’une montre SoftPWMSet(in3, 0); SoftPWMSet (in4, vitesse); } void moveBackward(int speed) { // Définit la rotation des moteurs gauche dans le sens des aiguilles d’une montre SoftPWMSet(in1, 0); SoftPWMSet (in2, vitesse); // Définit la rotation des moteurs droits dans le sens inverse des aiguilles d’une montre SoftPWMSet(in3, speed); SoftPWMSet(in4, 0); } void turnLeft(int speed) { // Configure tous les moteurs pour qu’ils tournent dans le sens des aiguilles d’une montre SoftPWMSet(in1, 0); SoftPWMSet (in2, vitesse); SoftPWMSet(in3, 0); SoftPWMSet (in4, vitesse); } void turnRight(int speed) { // Configure tous les moteurs pour qu’ils tournent dans le sens inverse des aiguilles d’une montre SoftPWMSet(in1, speed); SoftPWMSet(in2, 0); SoftPWMSet (in3, vitesse); SoftPWMSet(in4, 0); } void stopMove() { // Arrête tous les moteurs SoftPWMSet(in1, 0); SoftPWMSet(in2, 0); SoftPWMSet(in3, 0); SoftPWMSet(in4, 0); }

Test de capteur à ultrasons

Nous avons écrit un croquis pour lire la valeur du capteur à ultrasons et si la condition que le capteur lit plus de 50 centimètres, le robot avance, tandis que si le capteur lit moins de 15 centimètres et plus de 1 centimètre, le robot recule pendant 500 millisecondes et tourne à gauche pendant 1,5 seconde.

Croquis Arduino :

</p><br /> <p>#include <SoftPWM.h> // Définir les broches du module ultrasonique #define ULTRASONIC_PIN 10 // Définir les broches des moteurs const int in1 = 2; const int dans2 = 3 ; const int dans3 = 4 ; const int in4 = 5 ; void setup() { // Initialiser SoftPWM SoftPWMBegin(); //Série.begin(9600); } void loop() { // Lire la distance du capteur à ultrasons float distance = readSensorData(); //Serial.println(distance); // Distance de sortie pour le débogage // Contrôle du mobile basé sur la lecture de la distance if (distance > 50) { // S’il est possible d’avancer en toute sécurité moveForward(200); } else if (distance < 15 && distance > 1) { // S’il y a un obstacle, fermez moveBackward(200); retard (500); // Attendez un moment avant d’essayer de revenir en arrièreLeft(150); retard (1000); } else { // Pour les distances intermédiaires, procédez avec prudence moveForward(150); } } float readSensorData() { // Un délai de 4 ms est requis, sinon la lecture peut être de 0 delay(4); //Défini sur OUTPUT pour envoyer le signal pinMode(ULTRASONIC_PIN, OUTPUT); // Efface la broche de déclenchement digitalWrite(ULTRASONIC_PIN, LOW); delayMicroseconds(2); // Déclenchez le capteur en envoyant une impulsion haute pendant 10us digitalWrite(ULTRASONIC_PIN, HIGH); delayMicroseconds(10); // Remettez la broche de déclenchement sur faible digitalWrite(ULTRASONIC_PIN, LOW); //Défini sur INPUT pour lire pinMode(ULTRASONIC_PIN, INPUT); // pulseIn renvoie la durée de l’impulsion sur la broche float duration = pulseIn(ULTRASONIC_PIN, HIGH); // Calculez la distance (en cm) en fonction de la vitesse du son (340 m/s ou 0,034 cm/us) distance du flotteur = durée * 0,034 / 2 ; distance de retour ; } void moveForward(int speed) { // Définit la rotation des moteurs gauche dans le sens inverse des aiguilles d’une montre SoftPWMSet(in1, speed); SoftPWMSet(in2, 0); // Définit la rotation des moteurs droits dans le sens des aiguilles d’une montre SoftPWMSet(in3, 0); SoftPWMSet (in4, vitesse); } void moveBackward(int speed) { // Réglez les moteurs gauche pour qu’ils tournent dans le sens des aiguilles d’une montre SoftPWMSet(in1, 0); // Arrêtez SoftPWMSet (in2, vitesse); // Pleine vitesse // Réglez les bons moteurs pour qu’ils tournent dans le sens inverse des aiguilles d’une montre SoftPWMSet(in3, speed); // Pleine vitesse SoftPWMSet(in4, 0); // Stop } // Fonction pour tourner vers l’arrière gauche void backLeft(int speed) { SoftPWMSet(in1, 0); SoftPWMSet(in2, 0); SoftPWMSet (in3, vitesse); SoftPWMSet(in4, 0); }

Évitement d’obstacles avec les modules d’évitement d’obstacles IR

Nous avons ensuite écrit un autre programme pour lire la valeur des modules d’évitement d’obstacles droit et gauche. Si le capteur IR droit détecte un objet et que le capteur IR gauche ne détecte pas d’objet, le robot tourne en arrière vers la droite à une vitesse de 150 et si le capteur IR droit ne peut rien détecter, mais que le capteur IR gauche trouve l’objet, le robot tourne en arrière à gauche à une vitesse de 150. Si les deux capteurs détectent un objet, le robot recule à une vitesse de 150. Dans toutes les autres conditions, le robot avance.

Exemple de code :

</p><br /> <p>#include <SoftPWM.h> // Définir les broches des moteurs const int in1 = 2; const int dans2 = 3 ; const int dans3 = 4 ; const int in4 = 5 ; // Définir les broches des modules IR #define IR_RIGHT 7 #define IR_LEFT 8 void setup() { // Initialiser SoftPWM SoftPWMBegin(); // Définit les broches du module IR comme entrées pinMode(IR_RIGHT, INPUT); pinMode(IR_LEFT, INPUT); } void loop() { // Lire les valeurs des capteurs IR int rightValue = digitalRead(IR_RIGHT); int leftValue = digitalRead(IR_LEFT); // Sur la base des lectures du capteur IR, contrôlez les mouvements du mobile if (rightValue == 0 && leftValue == 1) { // Chemin droit bloqué backRight(150); } else if (rightValue == 1 && leftValue == 0) { // Chemin gauche bloqué backLeft(150); } else if (rightValue == 0 && leftValue == 0) { // Les deux chemins ont bloqué moveBackward(150); } else { // Les chemins sont effacés moveForward(150); } délai (100); } // Fonction pour déplacer le mobile vers l’arrière void moveBackward(int speed) { // Régler les moteurs gauche pour qu’ils tournent dans le sens des aiguilles d’une montre SoftPWMSet(in1, 0); // Arrêtez SoftPWMSet (in2, vitesse); // Pleine vitesse // Réglez les bons moteurs pour qu’ils tournent dans le sens inverse des aiguilles d’une montre SoftPWMSet(in3, speed); // Pleine vitesse SoftPWMSet(in4, 0); // Stop } void moveForward(int speed) { // Fait tourner les moteurs gauche dans le sens inverse des aiguilles d’une montre SoftPWMSet(in1, speed); SoftPWMSet(in2, 0); // Définit la rotation des moteurs droits dans le sens des aiguilles d’une montre SoftPWMSet(in3, 0); SoftPWMSet (in4, vitesse); } // Fonction pour tourner vers l’arrière droit void backRight(int speed) { SoftPWMSet(in1, 0); SoftPWMSet (in2, vitesse); SoftPWMSet(in3, 0); SoftPWMSet(in4, 0); } // Fonction pour tourner vers l’arrière gauche void backLeft(int speed) { SoftPWMSet(in1, 0); SoftPWMSet(in2, 0); SoftPWMSet (in3, vitesse); SoftPWMSet(in4, 0); }

Envoi d’images de la caméra vers un navigateur Web

Notre prochain programme de test vise à diffuser des images de la carte ESP32-CAM dans un navigateur Web. Il faut d’abord se connecter à un réseau WiFi et ouvrir le navigateur Web en utilisant l’adresse IP du robot (par exemple 192.168.1.xxx).

Croquis Arduino :

</p><br /> <p>#include « SunFounder_AI_Camera.h » // Configuration Wifi et informations d’identification // Mode AP // #define WIFI_MODE WIFI_MODE_AP // #define SSID « GalaxyRVR » // #define PASSWORD « 12345678 » // Mode STA #define WIFI_MODE WIFI_MODE_STA #define SSID « VOTRE SSID » #define PASSWORD « VOTRE MOT DE PASSE » // Configuration de l’appareil #define NAME « GalaxyRVR » // Nom de l’appareil #define TYPE « AiCamera » // Type d’appareil #define PORT « 8765 » // Port pour l’application SunFounder Controller / / Créer un objet AiCamera AiCamera aiCam = AiCamera(NOM, TYPE); void setup() { // Initialiser Serial (facultatif, si vous devez déboguer) Serial.begin (115200); // Initialiser AiCamera aiCam.begin (SSID, MOT DE PASSE, WIFI_MODE, PORT); // Définir le délai d’expiration de la commande (facultatif, 100 par défaut) aiCam.setCommandTimeout(100); } void loop() { // Boucle AiCamera. il faut le mettre dans loop(). Et plus important encore, chaque fois que la boucle // s’exécute, une période d’envoi de données et de réception s’exécute, la boucle doit donc être suffisamment rapide. // ou il sera en retard ou même bloqué par un autre code. aiCam.loop(); }

Contrôler le robot SunFounder GalaxyRVR via une application mobile

SunFonuder fournit un croquis Arduino pour permettre aux utilisateurs de contrôler le robot GalaxyRVR à partir d’une application.

Croquis Arduino :

</p><br /> <p>#include « SunFounder_AI_Camera.h » #include <Servo.h> #include <SoftPWM.h> // Créer un objet Servo Servo myServo; // Configuration Wifi et informations d’identification // En mode AP #define WIFI_MODE WIFI_MODE_AP #define SSID « GalaxyRVR » #define PASSWORD « 12345678 » // Configuration de l’appareil #define NAME « GalaxyRVR » // Nom de l’appareil #define TYPE « AiCamera » // Appareil tapez #define PORT « 8765 » // Port pour l’application SunFounder Controller // Créez un objet AiCamera AiCamera aiCam = AiCamera(NAME, TYPE); // Définir les broches des moteurs const int in1 = 2; const int dans2 = 3 ; const int dans3 = 4 ; const int in4 = 5 ; void setup() { // Initialise Serial pour le débogage Serial.begin(115200); // Fixez le servo sur la broche 6 myServo.attach(6); // Initialise l’AiCamera aiCam.begin(SSID, PASSWORD, WIFI_MODE, PORT); // Définit la fonction à exécuter lorsque les données sont reçues aiCam.setOnReceived(onReceive); // Définit le délai d’expiration de la commande aiCam.setCommandTimeout(100); // Initialisation de SoftPWM SoftPWMBegin(); // Arrête tous les moteurs SoftPWMSet(in1, 0); SoftPWMSet(in2, 0); SoftPWMSet(in3, 0); SoftPWMSet(in4, 0); } void loop() { // Doit l’inclure dans la boucle. Gère l’envoi et la réception des données du contrôleur. aiCam.loop(); } // Fonction à exécuter lorsque les données sont reçues du contrôleur void onReceive() { // Récupère la valeur du curseur dans la région D int16_t sliderD = aiCam.getSlider(REGION_D); // Déplacez le servo vers l’angle indiqué par le curseur myServo.write(int(sliderD)); // Récupère les valeurs de limitation pour la gauche et la droite int throttle_L = aiCam.getThrottle(REGION_K); int throttle_R = aiCam.getThrottle(REGION_Q); // Définit la puissance des moteurs carSetMotors(throttle_L, throttle_R); } // Fonction pour définir la puissance des moteurs void carSetMotors(int8_t power_L, int8_t power_R) { // Définir la puissance du moteur gauche if (power_L >= 0) { SoftPWMSet(in1, map(power_L, 0, 100, 0 , 255)); SoftPWMSet(in2, 0); } autre { SoftPWMSet(in1, 0); SoftPWMSet(in2, map(power_L, 0, -100, 0, 255)); } // Définit la puissance du moteur droit if (power_R >= 0) { SoftPWMSet(in3, 0); SoftPWMSet(in4, map(power_R, 0, 100, 0, 255)); } autre { SoftPWMSet(in3, map(power_R, 0, -100, 0, 255)); SoftPWMSet(in4, 0); } }

Une fois le programme exécuté dans le robot, vous pouvez accéder à votre téléphone pour trouver le SSID GalaxyRVR défini dans le programme.

Connectez-vous-y avec le mot de passe du programme, dans notre cas : 12345678.

Recherchez maintenant le « SunFounder Controller » dans le Google Play Store ou l’App Store d’Apple et installez-le. Maintenant, démarrez l’application et appuyez sur l’icône de connexion dans le coin supérieur droit.

Après une connexion réussie au robot, le nom « GalaxyRVR » apparaîtra.

Appuyez maintenant sur l’icône + et sélectionnez l’interface utilisateur « GalaxyRVR » pour créer un nouveau contrôleur.

Enfin, appuyez sur l’icône Play dans le coin supérieur droit pour afficher le streaming vidéo du module ESP32-CAM.

Vous pouvez désormais contrôler toutes les fonctions du robot GalaxyRVR telles que l’affichage des lumières RVB, le contrôle des mouvements, l’évitement des obstacles et même la commande vocale du robot. La test vidéo ci-dessous montre comment tout cela fonctionne.

Test vidéo du robot Sunfounder GalaxyRVR

Conclusion

Le robot SunFounder GalaxyRVR est une nouveauté car la plupart des robots sur roues imitent simplement une voiture. Mais avec ce robot, les étudiants peuvent en apprendre davantage sur le système Rocker-Bogie utilisé dans les robots rover d’exploration planétaire de la NASA. Il dispose également de nombreuses fonctions telles que l’évitement d’obstacles, les bandes LED RVB et la diffusion de caméras en direct via WiFi. Les étudiants peuvent également en apprendre davantage sur la programmation Arduino en plus des concepts de robotique. De plus amples détails peuvent être trouvés dans la documentation.

Nous tenons à remercier SunFounder de nous avoir envoyé le kit robot rover GalaxyRVR Mars pour test. Le kit robot GalaxyRVR peut être acheté pour 129,99 $ sur la boutique en ligne de la société ou sur Amazon US.

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