La Bebête du Nanard

          Une jolie bébête autonome qui va se déplacer sur une surface lisse, ou a peu près, et qui va changer de direction, après réflexion et mouvement de recul, si un obstacle se dresse en travers de son chemin ! Cette affreuse bestiole peut également se piloter par un smartphone ou tablette par le bluetooth; la synchronisation avec ce dernier va le faire passer en mode télécommandé. L' envoi de simples caractères majuscules va demander une action à la chose ( A, R, G, D, N pour respectivement un pas en avant, arrière, gauche , droite et repos) ...

          La marche comme les Culbutos, est assurée par deux servos-moteur de radio commande. L'arrière bascule le corps d'un côté puis de l'autre; alors que celui de devant, avance le pied levé, puis l'autre quand il sera à son tour.  

          Le corps est créé à l'imprimante 3D et la détection d'obstacle par un radar à ultrasons (HC-SR04) . L'ensemble est commandé par un Arduino Nano et la prise en main bluetooth par un circuit autonome (SPP-BT). Les pieds sont fait en fils de fer récupéré sur des porte-manteaux et les chaussures antidérapantes sont imprimées aussi . Les roues arrières viennent d'une vieille boîte Légo .

          Une batterie rechargeable (7,8 volt) de récupération fourni l'énergie pour la traction et la commande. Deux leds bicolores simulent des yeux, qui montrent la joie de vivre ou l'agacement de l'engin en cas d'obstacle ...

Le Schéma :

           Tout simple le schéma ! Grace à un Arduino Nano (1€80 chez Aliexpress ) qui va se charger de gérer tous les éléments du monstre .

           Un inter va permettre d'alimenter le circuit depuis la batterie de 7,6 volts. Cette tension est abaissée par le Nano et distribuée à tous les périphériques, sauf le circuit SPP-BT du bluetooth qui lui est en 3,3 volts; tension fournie également par le Nano.

           La commande des servos et l'alimentation sont envoyées sur les connecteurs JP5-JP8 où l'on raccordera ceux-ci (attention sur le pcb ces connecteurs sont inversés l'un par rapport à l'autre pour simplifier la sérigraphie du circuit; mais une étourderie n'est pas destructrice ).

           Les leds des yeux sont câblées en parallèle sur le connecteur JP3; les résistances R3-R4 de 180 Ohms limitent l'intensité (la sortance étant de 40 mA maxi) .

           Le radar à ultrasons HC-SR04 ( 0,50 € chez Aliexpress également) est raccordé au circuit par 4 fils souples: alimentation +5v , 0 v, Trigger qui en passant à l'état haut va envoyer une salve d'ultrasons et la borne Echo qui va, a son tour, passer à l'état logique haut dès qu'un écho sera entendu par le récepteur . L'ALU du µ-contrôleur n'a plus qu' a diviser le temps de retour par la vitesse du son, pour connaître la distance (2 fois car aller et retour )...

           Pour la prise en main par le bluetooth, on va utiliser l'information de la sortie LED du  SPP-BT qui s'active lorsque le circuit est synchronisé avec le smartphone ou la tablette.... on passe par un optocoupleur pour assurer l'isolation galvanique de l'un et l'autre; en effet le module BT est en 3,3 volts et le module Nano est en 5 volt. La résistance R1 de 330 Ohms limite le courant dans l'opto . R2 de son côté va servir de Pull Down sur l'entrée BT-OK... Les résistances R6-R7 sur l'entrée RX du SPP-BT sont montées en diviseur de tension pour ne pas que les informations aient une valeur supérieure à la tension d'alimentation (ça risque de faire désordre et ça ne fonctionnerait pas bien longtemps) !

Le Circuit Imprimé:

          Le circuit imprimé est réalisé de manière classique, en simple face comme décrit sur mon site. Pour limiter les perçages, je privilégie les composants SMD , et les connections sont réalisées par des barrettes sécables mâles/femelles (attention sur le pcb , les connecteurs des servos sont inversés l'un par rapport à l'autre pour simplifier la sérigraphie du circuit; mais une étourderie n'est pas destructrice ).

          Le support de l'Arduino est soudé sur toutes les pins, même inutilisées, pour assurer la résistance mécanique, et surtout pour avoir la possibilité de l'extraire pour la programmation ! Car la charge des entrées / sorties RX-TX n'est guère appréciée de l'IDE pour sa communication de téléchargement et crée des messages d'insultes à l'écran !

          Le module Bluetooth se soude côté composants et demande une certaine précision . N'oublions pas d'isoler les pistes de masse qui traversent sous le circuit SPP-BT  ! Un bout de feuille plastique, qui sera retiré après, ou laissé , fera l'affaire .

On commence par souder les SMD puis le module bluetooth avant tout les autres composants . L'optocoupleur est monté sous le Nano (attention au sens ) 

Le Boîtier :

          Le corps de la bébête est réalisé à l'imprimante 3D en PLA . Le mien se compose de 4 pièces mais votre immagination est libre de tous délires pour "arranger" l'aspect du monstre ! Les éléments sont:

• Le corps qui sert de support à toute la tripaille et à la rigidité squelettique de la base . Les évidements assurent la fixation des servos, du circuit, des leds des yeux et du radar à ultrasons 
• Les pieds, au nombre de deux, assurent la traction ... Je leur ai collé une semelle en caoutchouc pour améliorer l'adhérence .
• La partie supérieure de la coque qui reçoit la batterie collée à l'intérieure avec du double face, l'inter marche/arrêt et le trou pour le montage de la crête .
• La crête qui n'a pour rôle que de donner un look plus agressif ....

Rien n'empêche de recouvrir la partie supérieure de tissus ou de poils ! Des écailles de poisson ça peut être fun mais au bout d'un jour ça pue ....

Le boîtier est dessiné avec DS méchanical  Freeware de chez  Radiospares . 

Après avoir exporté en .STL les dessins, j'ai piloté, comme d'habitude, l'imprimante 3D par le très bon logiciel Repétier Host .

Le Sketch ou Programme :

Le programme est riche en commentaires, ce qui permet de traduire clairement ce que j'ai voulu faire ; L'avantage des sketchs d'Arduino c'est que c'est en libre partage et ça évite de refaire le monde lors de chaque développement ... Ca m'a bien servi pour importer certains morceaux et utiliser le copier/coller pour ne pas tout réécrire .

/* Bestiole marcheuse par basculement du corp, par les pattes arrières   
et avance des pattes avants. Deux servo permettent le déplacement et 
l'adhérence des pieds avants assure la traction alors que ceux de derrières
suivent en roue libre. Un mode autonomme est possible et l'anti collision est
assurée par un détecteur à ultrasons! Un pilotage manuel peut se faire par
bluetooth et depuis une tablette ou un smart phone ... Le programme vous
laisse la liberté pour toutes modifications ...
B.LECLERC 11/2018
*/

#include <Servo.h> //Déclaration des sous-programmes de composants

#define TRIGG 10 // Désignation des Entrées/Sorties
#define ECHO 9   
#define ledVerte  7
#define ledRouge  8
#define btOk  12

const long TIMEOUT = 25000UL; // Calcul de la relation temps de l'éco du son <-> distance obstacle
float son = 340.0 / 1000;

Servo frontServo; //Désignation des servos
Servo rearServo;

   int centerPos = 85; //Valeur des positions des servos suivant les pas à effectuer 
   int frontRightUp = 120; 
   int frontLeftUp = 50;
   int frontRightTurn = 100; 
   int frontLeftTurn = 70; 
   int backRightForward = 70; 
   int backLeftForward = 100;
   
   char cha; //Déclaration du caractère reçu sur la ligne RS, via le Bluetooth
   
   void moveForward()   {    // Pour faire un pas en avant            
                rearServo.write(backLeftForward);
                delay(700);  // Les delaiys permettent aux servox de rejoindre leur position
                frontServo.write(frontRightUp);
                delay(700);
                rearServo.write(backRightForward);
                delay(700);
                frontServo.write(frontLeftUp);
                delay(700);
               }

  void moveBack()   {     // Pour faire un pas en arrière
                rearServo.write(backLeftForward);
                delay(700);
                frontServo.write(frontLeftUp);
                delay(700);
                rearServo.write(backRightForward);
                delay(700);
                frontServo.write(frontRightUp);
                delay(700);
               }
               
void moveNone()   {          // Position repos 
                rearServo.write(centerPos);
                frontServo.write(centerPos);
                delay(1000);
               }
               

 void turnLeft()   {        // Pour tourner à gauche        
                rearServo.write(backLeftForward);
                delay(700);
                frontServo.write(frontRightTurn);
                delay(700);
                rearServo.write(backRightForward);
                delay(700);
                frontServo.write(frontLeftUp);
                delay(700);
               }

void turnRight()   {        // Pour tourner à droite        
                rearServo.write(backLeftForward);
                delay(700);
                frontServo.write(frontLeftTurn);
                delay(700);
                rearServo.write(backRightForward);
                delay(700);
                frontServo.write(frontLeftUp);
                delay(700);
               }

void setup()   {           //Prédispositions requises avant le dapart des cycles    
                frontServo.attach(3); //Pin où sont raccordé les commandes de servos
                rearServo.attach(5);
                pinMode (ledVerte, OUTPUT);  //Direction des pins
                pinMode (ledRouge, OUTPUT);
                pinMode (TRIGG, OUTPUT);
                digitalWrite (TRIGG, LOW); //Maintient bloquage envoi ultrason
                pinMode (ECHO, INPUT);
                pinMode (btOk, INPUT);
                Serial.begin(9600); //Initialisation de la com série 
               }

void loop()    {                    //Départ du cycles défini par le programme
                 digitalWrite(ledVerte, HIGH) ;  // Led verte allumée
                 digitalWrite(ledRouge, LOW) ;  // Led rouge éteinte
                 moveForward(); //Un pas en avant

                 digitalWrite(TRIGG,HIGH); //Envoi d'un puls d'ultrason de 10ms
                 delayMicroseconds(10);
                 digitalWrite(TRIGG,LOW);

                 int mesure = pulseIn(ECHO,HIGH,TIMEOUT); //Attente de l'écho
                 float distance_mm = mesure /2.0*son;  //Calcul de la distance 

                 if(distance_mm < 200) {         //Si la distance est inférieure à 200mm => Obstacle !
                 digitalWrite(ledRouge, HIGH) ;  //Led rouge allumée
                 digitalWrite(ledVerte, LOW) ;  // Led verte éteinte
                 moveNone();  //Pause marquée
                 delay (1000);
                    for (int i=0; i <= 3; i++){     // Pour deux fois
                      moveBack();       // Un pas en arrière
                    delay(700);
                    turnLeft();  // Tourne à droite
                     } 
                 delay (1000);
                 }

                 if (digitalRead(btOk)) {   // Le récepteur Bluetooth est-il activé ? Si Oui...
                 moveNone();   //Pause marquée
                 digitalWrite(ledVerte, LOW) ; // Led verte éteinte
                 delay (50);
                 goto tlCmd; // Saute au sous programme de marche pilotée
                 }

                 return; //Si non, retour au début (loop )

tlCmd:           
                 Serial.flush();  //Attente d'un caractère
                 cha = Serial.read();  // Lecture du caractère
                 if (Serial.available()>0) { //Valide si plus grand que nul
                 delay (50);
                 

                 if(cha=='A'){  //Si c'est le caractère A
                 digitalWrite(ledVerte, HIGH) ;  // Led verte allumée
                 moveForward();   // un pas en avant
                 digitalWrite(ledVerte, LOW) ; // Led verte éteinte
                 }

                 if(cha=='R'){   //Si c'est le caractère A
                 digitalWrite(ledRouge, HIGH) ;  //Led rouge allumée
                 moveBack();     // etc....
                 digitalWrite(ledRouge, LOW) ; // Led rouge éteinte
                 }

                 if(cha=='G'){
                 digitalWrite(ledRouge, HIGH) ;  //Led rouge allumée
                 digitalWrite(ledVerte, HIGH) ;  // Led verte Allumée
                 turnLeft();
                 digitalWrite(ledVerte, LOW) ;  // Led verte éteinte
                 digitalWrite(ledRouge, LOW) ; // Led rouge éteinte 
                 }

                 if(cha=='D'){
                 digitalWrite(ledRouge, HIGH) ;  //Led rouge allumée
                 digitalWrite(ledVerte, HIGH) ;  // Led verte Allumée
                 turnRight();
                 digitalWrite(ledVerte, LOW) ;  // Led verte éteinte
                 digitalWrite(ledRouge, LOW) ; // Led rouge éteinte 
                 }

                 if(cha=='N'){
                 moveNone(); 
                 }
                 }
                 
                 digitalWrite(ledRouge, LOW) ; // Led rouge éteinte
                 delay (50);                
                 goto tlCmd;  //Et on boucle sur l'étiquette tlCmd
                                 
               }

Pour la réalisation :

          Vous allez trouver dans le zip ci-dessous tous les fichiers que j'ai utilisé pour la réalisation pratique de ma bestiole ! aucune objection à utiliser ces pièces jointes pour adapter ou personnaliser la vôtre et en faire ce que vous voulez ... Après avoir été dézipés il suffit de les éditer et modifier avec le logiciel adéquat ou qui accepte une importation .

Crabe (393.71 Ko)

Ci-dessous, la batterie et un pied ....

          Pour la commande manuelle, j'utilise une application du Play Store  Là dessus, il y a plein de logiciels pour le pilotage bluetooth plus idéaux les uns que les autres ... Personnellement je ne me suis pas torturé à surcharger mon smartphone, j'utilise celui de mes expérimentations et qui fait partie d'un lot de 3 : Serial Bluetooth ...

          Une fois l'application lancée, il faut rechercher les "devices" (composants BT) et appairer celui qui correspond à votre monstre . Une fois reconnu et connecté, on peut pré-programmer les fonctions mémoires afin que chaque touche envoie le caractère qui correspond au mouvement désiré . "A" pour avance sur une touche, puis "R" pour recule, "G" pour un pas à gauche, "D" pour un pas à droite, "N" pour position repos .... Vous avez de la place en mémoire pour créer des grands pas, des petits pas, etc, etc ...

          L'hiver approche ! voici de quoi se passer le temps à la réalisation et au pilotage ! Mon chat adore faire face à la bébête, mais vu ce qu'elle c'est déjà ramasée comme coups de pattes, il commence à y avoir du jeu entre le capot et la base... Les fixations sur les servos ont également souffert ... A défaut d'amuser le gamin, ça amuse au moins le chat ....