> DIY: CutFlower 2.0 Tondeuse robot par Arduino.

Test des capteurs

Après avoir modifié le code avec la nouvelle librairie citée précédemment pour les capteurs ultrasons, et ça marche beaucoup mieux, j'ai procédé à quelques essai de détection des obstacles. Reste à faire certaines modifs et surtout intégrer dans le code la gestion du dilemme du coin!

C'est la reprise!

Bientôt la reprise de conception de cutflower2 avec de nouvelles idées plein la tête!

J'étais occupé avec la maison! Je suis impatient!

@ bientôt. !

Essai terrain...

J'ai fait un essai terrain pour voir le comportement du robot, malheureusement, ce test n'a pas été concluant, car le temps de réaction du robot est beaucoup trop long. Après vérification, le loop boucle en 0.8s aie aie!!

C'est due au temps de retour du ping de chacun des ultrasons...

J'ai trouvé sur le net, une modification de la librairie afin de pouvoir régler sois même la distance max efficace et ainsi ne pas perdre de temps à "écouter" pour rien... Avec cette nouvelle version, le loop est passé à 0.15s!!

https://code.google.com/p/arduino-new-ping/

Pour la petite histoire, à force de bricoler sur le robot, j'ai un peu oublié que c'était une tondeuse pendant l'essai, et je me suis présenté sur son coté pour simuler un obstacle en diagonale, vu son temps de réaction, elle ne m'a pas vu et elle m'a rouler sur le pied tout en coupant ma basket neuve par la même occasion ! Mon pied a eu très chaud, mais les lames coupent très bien !!!

Capteur à effet hall...

Installation de capteurs à effet hall et d'aimants sur chaque disque de coupe afin d'asservir les 3 moteurs brushless. Objectifs: réguler la vitesse en fonction de la difficulté rencontré pour la coupe de chacun des disques et permettre au programme de relancer un démarrage si un moteur cale par bourrage.

Code provisoire pour tester la régulation des moteurs de coupe:

/* Senseur à Hall Effect

Le circuit:

* Le senseur Effet Hall
Pin 1: +5v
Pin 2: Masse/GND
Pin 3: +5V via une résistance pull-up de 10 KOhms


*/

#include "Servo.h"
long timeRef=0; // variable pour temps de référence en millisecondes
long tps_comptage=1000; // variable pour délai de comptage en millisecondes
long timeRef2=0; // variable pour temps de référence en millisecondes
long tps_comptage2=10000; // variable pour délai de comptage en millisecondes

volatile long comptageImpuls_G=0;
volatile long comptageImpuls_M=0;
volatile long comptageImpuls_D=0;

const int ledPin = 13;
const int BRUSHLESS_M=38;
const int BRUSHLESS_G=36;
int sensorValue;
Servo cont_brushless_G;
Servo cont_brushless_M;
Servo cont_brushless_D;
int tourmin = 5000;
int vit_lame_G=140;
int vit_lame_M=140;
int vit_lame_D=140;

void setup()
{
Serial.begin(9600);
Serial.println("DEBUT SETUP");
pinMode( ledPin, OUTPUT );

cont_brushless_D.attach(BRUSHLESS_D);
pinMode(BRUSHLESS_D, OUTPUT);

cont_brushless_M.attach(BRUSHLESS_M);
pinMode(BRUSHLESS_M, OUTPUT);

cont_brushless_G.attach(BRUSHLESS_G);
pinMode(BRUSHLESS_G, OUTPUT);
delay (100);

attachInterrupt(4, gestionINT_D, RISING); // pin 19 attache l'interruption externe n°0 à la fonction gestionINT0()
attachInterrupt(3, gestionINT_M, RISING); // pin 20 mode déclenchement possibles = LOW, CHANGE, RISING, FALLING
attachInterrupt(2, gestionINT_G, RISING); // pin 21

DEM_MOT_G();
DEM_MOT_M();
DEM_MOT_D();
delay (1000);
Serial.println("FIN SETUP");
delay (1000);
}

void loop()
{

REG_COUPE();

}

void DEM_MOT_G() //demarrage de la coupe
{
Serial.println("DEM_MOT_G");
cont_brushless_G.write(50); // génère initialisation du controleur
delay (2000); //attente de 2 secondes pour initialisation du controleur

cont_brushless_G.write(vit_lame_G); // génère initialisation du controleur
delay (50);
}

void DEM_MOT_D() //demarrage de la coupe
{
Serial.println("DEM_MOT_D");
cont_brushless_D.write(50); // génère initialisation du controleur
delay (2000); //attente de 2 secondes pour initialisation du controleur

cont_brushless_D.write(vit_lame_D); // génère initialisation du controleur
delay (50);
}

void DEM_MOT_M() //demarrage de la coupe
{
Serial.println("DEM_MOT_M");
cont_brushless_M.write(50); // génère initialisation du controleur
delay (2000); //attente de 2 secondes pour initialisation du controleur

cont_brushless_M.write(vit_lame_M); // génère initialisation du controleur
delay (50);
}

void REG_COUPE()
{

if (millis()>(timeRef+tps_comptage))
{ // si le delai de comptage est écoulé

timeRef=timeRef+tps_comptage; // réinitialise le délai de comptage

//************* BRUSHLESS GAUCHE
Serial.print(comptageImpuls_G*60/2);
Serial.println("tours/mn G ");
if (((comptageImpuls_G*60)/2)>tourmin)
{
vit_lame_G = vit_lame_G-2;
cont_brushless_G.write(vit_lame_G);
Serial.print(vit_lame_G);
Serial.println("vit_lame_G-2");
}
if (((comptageImpuls_G*60)/2)<(tourmin-100))
{
vit_lame_G = vit_lame_G+5;
if (vit_lame_G > 170)
{
vit_lame_G = 170;
}
cont_brushless_G.write(vit_lame_G);
Serial.print(vit_lame_G);
Serial.println("vit_lame_G+5");
}

//************

//************* BRUSHLESS MILIEU

Serial.print(comptageImpuls_M*60/2);
Serial.println("tours/mn M");
if (((comptageImpuls_M*60)/2)>tourmin)
{
vit_lame_M = vit_lame_M-2;
cont_brushless_M.write(vit_lame_M);
Serial.print(vit_lame_M);
Serial.println("vit_lame_M-2");
}
if (((comptageImpuls_M*60)/2)<(tourmin-100))
{
vit_lame_M = vit_lame_M+5;
if (vit_lame_M > 170)
{
vit_lame_M = 170;
}
cont_brushless_M.write(vit_lame_M);
Serial.print(vit_lame_M);
Serial.println("vit_lame_M+5");
}

//************

//************* BRUSHLESS DROITE
Serial.print(comptageImpuls_D*60/2);
Serial.println("tours/mn D");
if (((comptageImpuls_D*60)/2)>tourmin)
{
vit_lame_D = vit_lame_D-2;
cont_brushless_D.write(vit_lame_D);
Serial.print(vit_lame_D);
Serial.println("vit_lame_D-2");
}
if (((comptageImpuls_D*60)/2)<(tourmin-100))
{
vit_lame_D = vit_lame_D+5;
if (vit_lame_D > 170)
{
vit_lame_D = 170;
}
cont_brushless_D.write(vit_lame_D);
Serial.print(vit_lame_D);
Serial.println("vit_lame_D+5");
}

//************
DETECT_ARRET_BRUSHLESS();
comptageImpuls_G=0;
comptageImpuls_M=0;
comptageImpuls_D=0;

} // fin si délai de comptage s'est écoulé

}

void gestionINT_G()

{
comptageImpuls_G=comptageImpuls_G+1;
}

void gestionINT_D()
{
comptageImpuls_D=comptageImpuls_D+1;
}

void gestionINT_M()
{
comptageImpuls_M=comptageImpuls_M+1;
}

void DETECT_ARRET_BRUSHLESS()
{
if (millis()>(timeRef2+tps_comptage2)) //delai comptage X10 pour detection arret moteur
{
timeRef2=timeRef2+tps_comptage2; // réinitialise le délai de comptage

if (((comptageImpuls_D*60)/2)<10)
{
DEM_MOT_D();
}

if (((comptageImpuls_M*60)/2)<10)
{
DEM_MOT_M();
}

if (((comptageImpuls_G*60)/2)<10)
{
DEM_MOT_G();
}
}
}

Ajouter un magnétomètre...

J'ai essayer d'ajouter un magnétomètre sur le robot pour qu'il fasse de belle ligne droite

et une tonte semi intelligente en faisant des parallèles...

1er test avec le hmc5883l, c'est un magnétomètre seul, et vu que le robot ne se

déplace pas sur une surface plate, les valeurs reçu sont inutilisable...

2ème test avec un LSM303DLH, c'est un magnétomètre combiné

avec un accéléromètre, afin de pouvoir avoir des valeurs utilisable sur tous types de terrain...

Facile à calibrer et à programmer, mais lors du test sur le robot, tous les résultats varie, c'est dû

au champ magnétique des moteur de traction! Même en éloignant le capteur des moteurs le capteur s'affole!

Des variations de +/- 20° quand les moteurs de traction sont alimentés...

Impossible d'utiliser ce capteur tant que je n'ai pas trouvé de solution pour blinder les moteurs...

Voici le log du capteur avec et sans les moteurs de traction en marche:

Carter de coupe, suite...

Confection d'un nouveau carter de coupe, et ce coup ci,

sans soudure pour ne pas vriller la tôle inox!!

Fixation des moteurs brushless sur le carter.

Les retours de protection sont en alu fixé par des rivets...

Modification du pare-choc AV

Renforcement du pare-choc avant pour qu'il résiste d'avantage aux chocs !

Préparation des moteurs...

Préparations des moteurs brushless 1000Kv 2826 Outrunner

et leurs supports, sans oublier la loctite !

et créations des disques de coupe par un ami sur sa CNC !

Carter de coupe...

Fabrication du carter de coupe en inox, et soudure de retour

afin d'éviter projection d'éclats de lames...

J'ai été obligé de souder des cornières pour renforcer la tôles qui a vrillée à cause des soudures...

Modif de la commande de puissance...

J'ai d'abord utilisé la commande de puissance du fauteuil roulant en remplaçant le joystick par un signal PWM simulé par l'arduino. Dans un premier temps, cela fonctionnait bien, mais au bout de 3 à 4 minutes, le contrôleur se mettait en défaut, et impossible d'en trouver la cause. Si un trop gros choc survenait, idem... Bref pas facile d'avoir un produit stable dans c'est conditions!

J'ai donc utilisé les même modules de puissances que CutFlower (ici), les ponts en H Double BTS7960B 43A. Et là, tout fonctionne très bien !

Essai terrain...

Premier essai terrain...

Modif du chassis...

Quelques modifications du châssis s'impose pour lui donner une forme et alléger le tout !

Réglage de la largeur du fauteuil pour correspondre à ma largeur de coupe.

Fabrication du pare-choc avant avec son capteur de collision...

J'attends la réception des chambre à air pour les roues AV et des capteurs moustaches...

Modif de la Commande...

Le signal en sortie du Joystick est un signal continu à 2.5v pour chaque sortie (AV,AR,D,G)

qui correspond au neutre du Jk.

Si on va à fond en AV, la sortie AV passe à 3.8v et celle AR à 1.2v

Si on va à fond en AR, la sortie AR passe à 3.8v et celle AV à 1.2v

Idem pour les sorties D et G quand on tourne.

J'ai simulé la même chose en PWM avec l'arduino et mis un filtre passe bas pour aplanir le signal PWM (pur, celui-ci était détecté comme une erreur par le module de commande du FR)