Robot Arduiblog

From Communauté de la Fabrique des Mobilites

Nuvola English language flag.svg Nuvola Italy flag.svg


Fabrication d'un robot pédagogique contrôlé par Arduino en recyclant des moteurs de trottinettes électriques

💼 porté par

ImageVideo.jpg


  • Récupération des moteurs (et éventuellement d'une batterie) sur les trottinettes usagées
  • Tests des éléments
  • Construction et décoration du châssis
  • Branchements
  • Programmation du robot (avec un Arduino)
  • Tests de pilotage


Organisations utilisatrice ou intéressée par utiliser la ressource :

Contributeurs : Arduiblog

Tags : Trottinettes électriques, Arduino, recyclage, éducation, Maker, DIY, bricolage, technologie, programmation, codage, éléctronique, microcontrôleur

Catégories : Connaissance, Matériel

Thème : Données ouvertes, Open HardWare, Ecoles et Etudiants

Référent : Arduiblog

Défi auquel répond la ressource : Challenge sur la 2nde vie des électrottinettes

Personnes clés à solliciter :

Autre commun proche : Challenge sur la seconde vie des trottinettes électriques

Richesse recherchée : Expérimentation

Compétences recherchée :

Communauté d'intérêt : Communauté du challenge de seconde vie des trottinettes électriques

Type de licence ? Creative Commons

Conditions Générales d'Utilisation (CGU) :

Niveau de développement :

Lien vers l'outil de gestion des actions :

Lien vers l'outil de partage de fichiers :

Besoins :

Prochaines étapes :

Documentation des expérimentations :



Autres informations :

Liste des Acteurs qui utilisent ou souhaitent utiliser ce Commun Robot Arduiblog : aucun pour le moment

Liste des CR d'atelier en lien avec ce Commun Robot Arduiblog:

Présentation[edit | edit source]

Qui suis-je ?[edit | edit source]

  • Jean-Christophe QUETIN
  • Auteur de livres sur l’Arduino et le micro:bit (aux Éditions ENI)
  • Créateur du site arduiblog.com
  • Maker, passionné d’informatique et de technologies

Mon projet[edit | edit source]

Fabriquer un robot pédagogique géant contrôlé par Arduino à partir de trottinettes électrique usagées.

Trottinette01.jpg

Les 2 roues motrices et la roue libre sont fixées sur un châssis et le microcontrôleur (Arduino) se charge de piloter le robot.

Il est possible d’ajouter différents modules de contrôle (détecteur d’obstacle, module de suivi de ligne, caméra intelligente, récepteur de télécommande, etc…). Et ensuite, de décorer le robot selon ses goûts.

Les variantes sont extrêmement nombreuses, vous pouvez par exemple fabriquer : une valise électrique, un véhicule autonome, un kart, un fauteuil électrique, un accessoire de cinéma SF (ou n’importe quelle autre idée issue de votre imagination).

Matériel nécessaire[edit | edit source]

Pour ce projet vous avez besoin de :

  • 2 moteurs de trottinettes,
  • 1 batterie
  • 1 Arduino
  • 2 contrôleurs moteur
  • 2 potentiomètres numériques
  • 1 module relais
  • De bois, de métal et de vis (pour le châssis)
  • De quelques outils de base (pinces, tournevis, clés plates, clés Allen...)
  • Éventuellement une imprimante 3D

Moteur de trottinette[edit | edit source]

Le moteur est intégré à la roue (avant ou arrière, selon le modèle). Pour le trouver, il suffit d'identifier la roue qui possède un fil électrique. Dans cet exemple, il s'agit de la roue avant. Le démontage est plutôt facile puisqu'il faut simplement dévisser l'écrou situé de chaque coté. Par contre, je n'ai pas réussi à démonter la fourche, pour récupérer le connecteur femelle. Heureusement, la prise s'est débranché assez facilement (en tirant sur le câble). S'il reste coincé, vous pouvez aussi couper le fil (le plus loin possible), puisqu'il faudra de toute façon, refaire le branchement avec le nouveau contrôleur.

Trottinette02.jpg

Batterie[edit | edit source]

La batterie est généralement située sous la trottinette afin de baisser le centre de gravité. Sur ce modèle, elle était simplement fixée par quelques vis (dont la tête était cachée sous le tapis anti dérapant).

Trottinette05.jpg

Arduino[edit | edit source]

C'est le cerveau du robot, il est facile à programmer, possède une grande communauté et peut accueillir de nombreux capteurs ou modules. Avec lui, il sera donc possible de personnaliser le robot à l'infini. Mais d'autres cartes de développement feront également l'affaire (micro:bit, ESP32, Raspberry Pi ou Pico, Pyboard, PYBStick26...).

Trottinette07.jpg

Si vous avez besoin de plus d'informations, sachez que j'ai écris un livre sur le sujet, n'hésitez donc pas à visiter le site des Éditions ENI.

Trottinette08.jpg

Contrôleur moteur[edit | edit source]

C'est un boîtier électronique spécialisé dans le contrôle des moteurs de trottinettes (de 36 à 48 V et jusqu'à 18 A). Il interprète les instructions envoyées par le microcontrôleur (5V) et modifie en conséquence la vitesse et/ou le sens de rotation du moteur. Cet élément est indispensable puisqu'il est impossible de connecter directement l'Arduino au moteur et à la batterie.

Trottinette06.jpg

Potentiomètre numérique[edit | edit source]

Il permet de simuler la poignée d'accélérateur de la trottinette, qui est constituée d'un simple potentiomètre actionné à la main par l'utilisateur. Cependant, cet élément est facultatif, il également possible de piloter directement le contrôleur de moteurs en utilisant les sorties PWM de l'Arduino (voir un peu plus loin dans le tuto).

Trottinette14.jpg

Module relais[edit | edit source]

J'ai utilisé un module relais pour simuler le bouton poussoir qui inverse le sens de rotation du moteur (en reliant brièvement les 2 fils blancs). J'ai également prévu de contrôler l'alimentation des moteurs en reliant (ou non) le petit fil rouge à la borne + de l'alimentation. Il existe peut être un module plus adapté ou une solutions plus performante à base de transistor ou de MOSFET. Mais en l'absence d'une documentation claire et détaillées sur le contrôleur de moteur, j'ai choisi le relais parce qu'il sépare complètement le circuit de L'Arduino de celui du contrôleur.

Trottinette15.jpg

Test du matériel[edit | edit source]

Puisqu'ils proviennent qu'une trottinette hors d'usage, il est indispensable de vérifier que la batterie et le moteur fonctionnent correctement. Cette étape évite de se creuser la tête pendant des heures en se demandant pourquoi le robot ne fonctionne pas comme prévu alors que tout est bien branché.

La batterie[edit | edit source]

Pour tester la batterie, utilisez un voltmètre relié aux fils rouge et noir.

Attention, ne coupez pas en même temps tous les fils qui sortent directement de la batterie (juste avant le connecteur) parce que vous risquez de faire un court circuit avec votre pince.

Normalement, la tension obtenue doit être autour de 36 V (ça dépend du niveau de charge). Mais là, avec 0,94 V il y a clairement un problème.

Trottinette09.jpg

La batterie n'a manifestement pas été conçue pour être démontée. Elle est parfaitement protégée des chocs dans un solide boîtier métallique (certainement de l’aluminium). Malheureusement, le fabricant a ensuite coulé une sorte de mastic ou de résine qui a définitivement aggloméré tous les éléments. La seule solution pour ouvrir la batterie est d'inciser délicatement le boîtier avec un disque à découper (sur un outil de type Dremel).

Attention, cette opération comporte un risque, il ne faut absolument rester dans l'angle et ne pas aller trop profond pour ne pas toucher les éléments de batterie.

Trottinette17.jpg

La trottinette a peut être fait un petit séjour dans l'eau parce que la carte de contrôle est oxydée (alors qu'elle était extrêmement bien protégée). Mais dans ces conditions, je vais pas tenter de réparer cette batterie.

Trottinette20.jpg

Il est quand même possible de recycler une partie des composants. En effet, la grosse batterie de 36V est constituée d'une quarantaine d’éléments standards (18650) de 3,6 V. Même si certains sont définitivement hors d'usage, j'ai quand même réussi à en récupérer 24 qui fonctionnent encore.

Trottinette19.jpg

Je pourrais les réassembler pour faire une batterie de 20 cellules, mais cette opération est délicate. Elle nécessite du matériel et des connaissances que pour l'instant, je ne possède pas. Toutefois, de nombreux objets utilisent des cellules 18650 (cigarette électronique, batterie externe de téléphone portable, panneaux solaires, robots...), il sera donc très facile de leur trouver une utilité (ne serait-ce que pour alimenter un Arduino).

Trottinette21.jpg

Pour alimenter mon robot, j'ai commandé une nouvelle batterie de trottinette, mais en attendant je vais tester les moteurs avec une batterie 10 cellules d'overboard. Elle est compatible puisque la tension est la même (36V) mais bien sûr, l'autonomie est beaucoup plus faible (surtout avec 2 moteurs).

Trottinette23.jpg

Les moteurs[edit | edit source]

Les contrôleurs de moteurs possèdent de nombreux fils de couleurs et de diamètres différents. Mais on peut les classer par catégorie.

1) Alimentation générale (batterie). Le fil noir est relié à la masse et le gros fil rouge à la borne + 36V. Si le petit fil rouge n'est pas relié au + 36V, l'alimentation du moteur est coupée ce qui peut être intéressant pour être sûr que le robot est arrêté.

2) Alimentation du moteur, à relier aux 3 gros fils (bleu, vert et jaune)

3) Contrôle du moteur, à relier aux 5 petits fils (rouge, noir, bleu, vert et jaune.

4) Vitesse du moteur, à relier au potentiomètre numérique en suivant le schéma (rouge, noir et vert).

5) Inversion du sens de rotation à relier au module relais (blanc et blanc)

Les autres fils ne sont pas utilisés

Trottinette11.jpg

Dans un premier temps, j'ai utilisé le potentiomètre numérique. Voilà le schéma de branchement pour le moteur gauche (G) ou droit (D).

Trottinette25.jpg

Et voilà le programme permettant de tester le fonctionnement des moteurs dans un sens, puis dans l'autre. J'ai ajouté une LED témoin (reliée à la borne D11), mais ce n'est pas obligatoire. Vous trouverez la bibliothèque DigiPotX9Cxxx à l'adresse suivante : https://electropeak.com/learn/interfacing-x9c104-100k-ohm-digital-potentiometer-module-with-arduino/).

/*

Challenge : Seconde vie des trottinettes électriques (La fabrique des mobilites)

Projet de Jean-Christophe QUETIN (www.arduiblog.com)

https://wiki.lafabriquedesmobilites.fr/wiki/Robot_Arduiblog

Branchement des potentiomètres X9C104 :

***** Moteur gauche *****

Arduino 5V - VCC

Arduino GND - GND

Arduino pin 2 - INC

Arduino pin 3 - U/D

Arduino pin 4 - CS

Controleur moteur fil rouge - RH

Controleur moteur fil vert - RW

Controleur moteur fil noir - RL

***** Moteur droit *****

Arduino 5V - VCC

Arduino GND - GND

Arduino pin 5 - INC

Arduino pin 6 - U/D

Arduino pin 7 - CS

Controleur moteur fil rouge - RH

Controleur moteur fil vert - RW

Controleur moteur fil noir - RL

*/

// Appel des bibliotheques

#include <DigiPotX9Cxxx.h>

// Definition des ports

DigiPot moteurGauche(2,3,4);

DigiPot moteurDroit(5,6,7);

const int SENSGAUCHE = 8;

const int SENSDROIT = 9;

const int LED = 11;

// Définition des variables

int vitesseGauche = 0;

int vitesseDroite = 0;

void setup() {

pinMode(LED, OUTPUT);

pinMode(SENSGAUCHE, OUTPUT);

pinMode(SENSDROIT, OUTPUT);

digitalWrite(SENSGAUCHE, 1);

digitalWrite(SENSDROIT, 1);

// Arret des moteurs

moteurGauche.reset();

moteurDroit.reset();

}

void loop() {

moteurGauche.set(80);

moteurDroit.set(80);

analogWrite(LED, 70);

delay(3000);

moteurGauche.set(90);

moteurDroit.set(90);

analogWrite(LED, 255);

delay(3000);

moteurGauche.set(0);

moteurDroit.set(0);

analogWrite(LED, 0);

delay(5000);

inversionMoteurs();

}

void inversionMoteurs(){

moteurGauche.set(0);

moteurDroit.set(0);

digitalWrite(SENSGAUCHE, 0);

digitalWrite(SENSDROIT, 0);

delay(500);

digitalWrite(SENSGAUCHE, 1);

digitalWrite(SENSDROIT, 1);

}

Trottinette16.jpg

Pour voir la roue tourner, allez sur ma chaîne Youtube : https://www.youtube.com/watch?v=pjtATH7JCCA

Mais entre-temps, yannlabsud (un autre participant au challenge) a découvert qu'on pouvait aussi piloter directement le contrôleur de moteurs en le reliant directement à l'Arduino (sans potentiomètre numérique). Pour cela il suffit d'utiliser une des sorties PWM. Après avoir vérifié que cela fonctionne, j'ai décider d'adopter cette solution parce qu'elle simplifie énormément les branchements, la programmation et qu'elle mobilise seulement 2 ports de l'Arduino (au lieu de 6). Alors merci beaucoup Yann.

J'ai aussi ajouté la possibilité d'activer (ou de désactiver) l'alimentation des moteurs avec le module relais (en reliant le petit fil rouge à la borne + de l'alimentation). Mais ce n'est pas indispensable, vous pouvez simplement laisser les fils connectés entre eux. Par contre je vous conseille d'ajouter un interrupteur pour couper l'alimentation du robot. Voilà donc le nouveau schéma :

Trottinette-31.jpg

Et la nouvelle version du code :

/*

Challenge : Seconde vie des trottinettes électriques (La fabrique des mobilites)

Projet de Jean-Christophe QUETIN (www.arduiblog.com)

https://wiki.lafabriquedesmobilites.fr/wiki/Robot_Arduiblog

*/

// Definition des ports

const int MOTEURGAUCHE = 5;

const int MOTEURDROIT = 6;

const int SENSGAUCHE = 7;

const int SENSDROIT = 8;

const int ACTIVATIONMOTEURGAUCHE = 9;

const int ACTIVATIONMOTEURDROIT = 10;

void setup() {

pinMode(MOTEURGAUCHE, OUTPUT);

pinMode(MOTEURDROIT, OUTPUT);

pinMode(SENSGAUCHE, OUTPUT);

pinMode(SENSDROIT, OUTPUT);

pinMode(ACTIVATIONMOTEURGAUCHE, OUTPUT);

pinMode(ACTIVATIONMOTEURDROIT, OUTPUT);

analogWrite(MOTEURGAUCHE, 0);

analogWrite(MOTEURDROIT, 0);

digitalWrite(SENSGAUCHE, 1);

digitalWrite(SENSDROIT, 1);

digitalWrite(ACTIVATIONMOTEURGAUCHE, 1);

digitalWrite(ACTIVATIONMOTEURDROIT, 1);

// Demarrage des moteurs

delay(1000);

digitalWrite(ACTIVATIONMOTEURGAUCHE, 0);

digitalWrite(ACTIVATIONMOTEURDROIT, 0);

}

void loop() {

analogWrite(MOTEURGAUCHE, 70);

analogWrite(MOTEURDROIT, 70);

delay(4000);

analogWrite(MOTEURGAUCHE, 125);

analogWrite(MOTEURDROIT, 125);

delay(2000);

analogWrite(MOTEURGAUCHE, 220);

analogWrite(MOTEURDROIT, 220);

delay(4000);

analogWrite(MOTEURGAUCHE, 0);

analogWrite(MOTEURDROIT, 0);

delay(8000);

inversionMoteurs();

}

void inversionMoteurs(){

digitalWrite(SENSGAUCHE, 0);

digitalWrite(SENSDROIT, 0);

delay(300);

digitalWrite(SENSGAUCHE, 1);

digitalWrite(SENSDROIT, 1);

}

Attention : La vitesse des moteurs n'est plus un pourcentage (de 0 à 100), mais une valeur PWM (de 0 à 255).

Construction du châssis[edit | edit source]

J'attendais la livraison de la 2ème roue pour commencer la fabrication du châssis et finalement j'ai reçu 2 nouvelles roues. Je ne vais pas me plaindre parce qu'elles sont toutes neuves et n'ont pas connu de séjour dans l'eau (de l'eau coulait par le fil du 1er moteur). Mais les roues sont légèrement plus petites (20 cm, au lieu de 25 cm).

Trottinette-28.jpg

J'ai bien fait d'attendre, comme cela je peux adapter le châssis aux nouvelles roues. J'ai choisi une petite planche de MDF (50 X 40 cm) et j'ai fixé les roues (en ajoutant la roue libre) avec chutes de bois, des équerres, des plaques de tôle et beaucoup de vis. Le résultat n'est pas exceptionnel (je ne suis pas menuisier), mais cela semble suffisamment solide.

Trottinette27.jpg

Et avec un petit coup de peinture et quelques éléments imprimées en 3D, on ne voit quasiment plus les petits défauts.

Trottinette45.jpg

Pilotage du robot[edit | edit source]

Il existe énormément de solutions pour contrôler un robot de ce type, mais le plus simple est certainement d'utiliser un module Bluetooth de type HC-06 et un smartphone. Il serait possible de relier le récepteur Bluetooth aux ports D0 et D1 de l'Arduino, mais cela gène le téléversement du programme (puisque le contrôleur USB utilise les mêmes ports). Comme nous avons encore de nombreuses d'entrées/sorties disponibles, il est beaucoup plus pratique de créer un port série virtuel. J'ai choisi les ports D2 (RX) et D3 (TX) mais vous pouvez en utiliser d'autre (à condition bien sûr, de modifier le programme).

Attention : n'oubliez pas de croiser les fils et donc de relier le TX de l'Arduino au RX du module et le le RX de l'Arduino au TX du module.

Trottinette-47.jpg

Ensuite, vous pouvez installer sur votre smartphone l'application Arduino bluetooth controller (ou une autre de même type). Activez le Bluetooth et associez le module HC-06 (le code par défaut est 1234). Lancez Arduino bluetooth controller (pour le moment, le module HC-06 clignote).

Sélectionnez le module dans la rubrique Connect to a device et choisissez Controller mode (maintenant, le module HC-06 est allumé en continu). Appuyez sur le petit engrenage en haut à droite et attribuez un chiffre ou une lettre à chacun des boutons, par exemple j'ai choisi :

  • g pour gauche,
  • a pour avant
  • d pour droite,
  • r pour arrière,
  • 1 pour carré,
  • 2 pour triangle,
  • 3 pour croix,
  • 4 pour cercle,
  • 5 pour select,
  • 6 pour start.

Évidement, vous pouvez utiliser les caractères de votre choix, il faudra simplement qu'ensuite cela corresponde au sketch de l'Arduino.

Trottinette46.jpg

Le programme fourni en exemple est optimisé pour mes moteurs, mais vous devrez certainement l'adapter un peu à votre matériel. Le régime des moteurs doit être dosé avec précision parce que s'il est trop bas, le robot ne démarrera pas et s'il est trop élevé le robot risque de se retourner (s'il est aussi léger que le mien) ou de partir comme une fusée pour percuter le premier obstacle rencontré (car il n'y a pas de freins). De plus, les 2 moteurs ne réagissent pas de manière parfaitement identique. J'ai été obligé de réduire un peu la puissance du moteur droit pour que le robot ne dévie pas (trop) en ligne droite.

Au début, je comptais inverser le sens de rotation une ou des 2 roues, afin de mieux négocier les virages ou simplement de reculer. Malheureusement, cela ne fonctionne pas très bien parce que qu'au moment de l'inversion de sens, le moteur s'emballe pendant un très court instant. Ce qui rend le comportement du robot un petit peu chaotique. Je pense que ce problème est causé par le contrôleur de moteur. Il faudrait peut être tester avec un autre modèle, mais pour le moment, j'ai préféré renoncer à la marche arrière.

Il ne faut pas trop s'éloigner du robot puisque la portée du module HC-06 est d'une dizaine de mètres (environ). Pour éviter que le robot continue à rouler lorsqu'il est hors de portée, le programme lui demande d'avancer un bref instant et ensuite de s'arrêter. Il faut donc appuyer de temps en temps sur les boutons pour lui indiquer la direction à suivre, mais pas trop souvent, sinon il n'a pas le temps d'exécuter les commande au fur et à mesure et il risque d'exécuter les commandes avec un temps de retard (par exemple, continuer à avancer au lieu de tourner ou de s'arrêter). Le pilotage n'est donc pas aussi fluide qu'avec un véhicule télécommandé classique.

Vous trouverez ci dessous un exemple de programme qui fonctionne (même si tout n'est pas parfait). Libre à vous, de vous en inspirer et/ou de l'améliorer.

/*

Challenge : Seconde vie des trottinettes électriques (La fabrique des mobilites)

Projet de Jean-Christophe QUETIN (www.arduiblog.com)

https://wiki.lafabriquedesmobilites.fr/wiki/Robot_Arduiblog

*/

// Appel des bibliotheques

#include <SoftwareSerial.h>

// Définition des ports séries virtuels

// RX de l'arduino (port 2) est connecté au port TX du module HC-06

// TX de l'arduino (port 3) est connecté au port RX du module HC-06

SoftwareSerial moduleHC06(2, 3);

// Definition des ports

const int MOTEURGAUCHE = 5;

const int MOTEURDROIT = 6;

const int SENSGAUCHE = 7;

const int SENSDROIT = 8;

const int ACTIVATIONMOTEURGAUCHE = 9;

const int ACTIVATIONMOTEURDROIT = 10;

// Stockage du contenu du message

char message = 0;

void setup() {

moduleHC06.begin(9600);

pinMode(MOTEURGAUCHE, OUTPUT);

pinMode(MOTEURDROIT, OUTPUT);

pinMode(SENSGAUCHE, OUTPUT);

pinMode(SENSDROIT, OUTPUT);

pinMode(ACTIVATIONMOTEURGAUCHE, OUTPUT);

pinMode(ACTIVATIONMOTEURDROIT, OUTPUT);

analogWrite(MOTEURGAUCHE, 0);

analogWrite(MOTEURDROIT, 0);

digitalWrite(SENSGAUCHE, 1);

digitalWrite(SENSDROIT, 1);

digitalWrite(ACTIVATIONMOTEURGAUCHE, 0);

digitalWrite(ACTIVATIONMOTEURDROIT, 0);

}

void loop() {

// Réception du message par la liaison Bluetooth

if (moduleHC06.available()){

message = moduleHC06.read();

}

// Réaction en fonction du message reçu

switch (message) {

// Bouton haut

case 'a':

avant(75, 800); // Vitesse 200 pendant 1 seconde

break;

// Bouton bas

case 'r':

arret();

break;

// Bouton gauche

case 'g':

tourneGauche(80, 700); // Vitesse 200 pendant 300 millisecondes

break;

// Bouton droit

case 'd':

tourneDroite(85, 700); // Vitesse 200 pendant 300 millisecondes

break;

// Bouton carré

case '1':

inversionMoteurG();

break;

// Bouton triangle

case '2':

// Vous pouvez ajouter ici une fonction pour ce bouton

break;

// Bouton croix

case '3':

inversionMoteurD();

break;

// Bouton cercle

case '4':

inversionMoteurs();

break;

// Bouton select

case '5':

// Vous pouvez ajouter ici une fonction pour ce bouton

break;

// Bouton start

case '6':

// Vous pouvez ajouter ici une fonction pour ce bouton

break;

}

message = 0;

delay(20);

}

// Fonctions

void avant(int vitesse, int duree) {

analogWrite(MOTEURGAUCHE, vitesse);

analogWrite(MOTEURDROIT, (vitesse-5));

delay(duree);

arret();

}

void arriere(int vitesse, int duree) {

inversionMoteurs();

analogWrite(MOTEURGAUCHE, vitesse);

analogWrite(MOTEURDROIT, vitesse);

delay(duree);

inversionMoteurs();

}

void tourneGauche(int vitesse, int duree) {

analogWrite(MOTEURDROIT, vitesse);

delay(duree);

arret();

}

void tourneDroite(int vitesse, int duree) {

analogWrite(MOTEURGAUCHE, vitesse);

delay(duree);

arret();

}

void arret(){

analogWrite(MOTEURGAUCHE, 0);

analogWrite(MOTEURDROIT, 0);

}

void inversionMoteurs(){

arret();

digitalWrite(SENSGAUCHE, 0);

digitalWrite(SENSDROIT, 0);

delay(300);

digitalWrite(SENSGAUCHE, 1);

digitalWrite(SENSDROIT, 1);

}

void inversionMoteurG(){

arret();

digitalWrite(SENSGAUCHE, 0);

delay(300);

digitalWrite(SENSGAUCHE, 1);

}

void inversionMoteurD(){

arret();

digitalWrite(SENSDROIT, 0);

delay(300);

digitalWrite(SENSDROIT, 1);

}

Trottinette50.jpg

Vous trouverez ici une démonstration du robot en action : https://www.youtube.com/watch?v=ofHFo1G38Io

Evolution du robot[edit | edit source]

Il reste de nombreuses possibilités d'amélioration du robot.

Vous pouvez par exemple utiliser d'autres télécommandes compatibles avec l'Arduino (radio, Wifi, manette de PS3/PS4...) ou ajouter de nouvelles fonctions au robot (LED RGB, Buzzer...).

Mais vous pouvez également le rendre autonome avec un module radar Lidar ou une caméra intelligente (de type HuskyLens ou Pixy2).

Bien sûr, comme d'habitude la seule limite sera certainement votre imagination...