mthibs

Salut !

Loin de moi l'idée de faire de la concurrence à Donovandu88 avec son super bras robot BCN3D Moveo mais ce sujet est dédié au montage et au test du kit bras rotatif et pince robot qu'il y a dans la boutique !

Ce kit est composé de toutes les pièces mécaniques et visserie nécessaire pour assembler un bras robotique 6 DOF.

Par contre, les servo moteurs ne sont pas fournis avec, j'utilise les servo MG995 qui sont parfait pour cette application.

Je mets quelques photos du montage :

en commençant l'assemblage de la base tournante et du premier servo

Ensuite on passe à la partie supérieure

Et enfin le montage de la pince

Le bras est monté !

Pour faire fonctionner le bras j'utilise le driver 16 servo I2C et une arduino uno. Jekert a testé ce driver sur le forum !

Pour alimenter les moteurs, une batterie LiPo 12V est suffisante, avec un convertisseur 5V 7A. On peut utiliser un convertisseur 5V 5A mais au delà de trois moteurs en action il n'y a plus assez de courant.

Pour le programme, il suffit d'adapter celui posté par Jekert pour contrôler plusieurs servos dans le test du driver !

Voici un exemple de programme que je n'ai pas encore testé :

Et il ne reste plus qu'à programmer une jolie chorégraphie 

Et voilà le programme !

Il s'agit d'un programme qui permet d'afficher les composantes RGB des différents éléments analysés par le capteur GY-31 !

Le capteur est relativement précis et sensible et il faut le calibrer.

Il fonctionne très bien, j'ai fait l'essai avec des feuilles de couleurs.

Par contre l'orientation des leds blanches sur le capteur influe beaucoup sur la détection, une fois calibré il ne faut plus y toucher !

Les valeurs sont affichées dans le moniteur série :

Ce capteur est sympa pour faire des machines de tri par exemple, ou bien pour participer à la coupe de france de robotique   .

@R1D1 : Oups, tu as raison je n'ai pas fait attention quand j'ai écrit ^^

@Melmet : Trouvé ! (enfin je crois.. )

En ajoutant un Timeout sur la lecture de la pin Echo la led s'allume correctement !

En affichant les distances dans le moniteur série, on remarque qu'il y en a qui ne sont pas cohérentes sans timeout :

Ces valeurs au-dessus de 3000 disparaissent une fois le timeout en place.

Sinon, à quoi sert Q2 ? Le premier relais active une lampe mais l'autre ?

Voila ma version du programme :

et une video du résultat

Dis moi si maintenant ça fonctionne 

Bonjour tout le monde !

Je poste un nouveau test sur le capteur de couleur présent sur la boutique !

C'est le capteur GY-31 basé sur le composant TSC3210.

Ce capteur a 10 entrées/sorties, 4 trous de fixation pour vis M3, 4 leds blanches pour éclairer la surface de l'objet pointé.

Ce capteur renvoie les composantes RGB de chaque objet qu'il pointe. Le signal de sortie est sous forme d'un signal carré dont la fréquence varie en fonction de la couleur perçu.

Ce que je trouve pas mal c'est qu'il y a la possibilité d’allumer ou d'éteindre les leds blanches (à l'aide d'une entrée exprès sur le capteur), pour ne pas les utiliser lorsque la pièce est déjà bien éclairée.

Pour l'utiliser, voici le câblage que j'ai fait avec une arduino uno :

Il y a la possibilité de régler l'échelle de fréquence de la sortie du capteur en jouant sur les entrées S0 et S1 du capteur.

On peut aussi mettre des filtres de couleurs pour ne détecter que le rouge, le bleu, le verre ou aucune.

Le programme pour l'utiliser arrive prochainement !  

Bonjour bonjour !

Le test suivant est à propos de l'émetteur-récepteur radio que l'on peut voir sur le shop !

Cet émetteur radio se présente sous la forme d'une petite télécommande de 55x30 mm avec deux boutons A et B dessus.

La télécommande est équipée d'un cache bouton qui la protège d'appuis non voulus et d'un petit mousqueton qui permet de l'accrocher pour ne pas la perdre (à son porte clé par exemple  ).

Le récepteur est un pavé de 40x20x10 mm avec une petite antenne flexible en spirale. La petite taille du récepteur permet de le mettre partout sur un robot sans l'encombrer.

Le récepteur a 2 entrées : une alimentation 5V (fil rouge), la masse (fil noir) et 2 sorties : le signal des boutons (fil blanc) et une alimentation 5V (fil vert).

Avant de l'utiliser, j'ai d'abord souder des connecteurs mâles sur les fils du récepteurs pour pouvoir les relier plus facilement à une carte arduino uno.

Avant de construire un programme pour piloter un moteur à l'aide de ce module radio, j'ai analysé les signaux du récepteur avec un oscilloscope :

Ci-dessus, le signal du récepteur lorsque le bouton A est enfoncé : on voit que la courbe jaune est à 0V.

Maintenant, le signal quand le bouton B de la télécommande est enfoncé :

La courbe jaune passe à 600mV environ.

La courbe bleue ne change pas d'état quelque soit le bouton activé, elle reste toujours à 5V.

Je m'attendais à avoir un signal pour chacun des boutons mais je me suis aperçu qu'un fil de sortie (le vert) était une alimentation  .

Il y a donc un signal de sortie pour deux boutons.

Le programme à faire est un peu différent que s'il y avait un signal par bouton mais finalement le résultat est le même  .

Une petite précision, si vous branchez le récepteur à une carte arduino, le signal de sortie ne peut être lu que par des entrées analogiques car la tension du signal est trop faible pour les autres entrées de la carte.

En parlant du programme, le voilà :

// Contrôle PWM simple
#define A 3 // Contrôle vitesse moteur 1
#define B 4 //controle direction moteur 1
#define bouton A2  //pin du signal du récepteur radio

int compteur; 
int compteur2;
int sens_rotation;  //variable qui indique le sens de rotation
                    //que le moteur doit adopter
int front;   //variable de détection de front montant

void stop() //Stop
{
digitalWrite(A,LOW);
digitalWrite(B,LOW);
}

void advance(char a) // En avant
{
analogWrite (A,a); // Contrôle de vitesse en PWM
digitalWrite(B,HIGH);
}

void back_off (char a) // En arrière
{
analogWrite (A,a);
digitalWrite(B,LOW);
}

void setup()
{
compteur=0;
compteur2=compteur;
front=0;
sens_rotation=1;  //initialisation en marche avant
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(bouton,INPUT);
Serial.begin(9600); // Définit vitesse de transmission série
}

void loop()
{
front=analogRead(bouton); //lecture du signal du récepteur
if(front>0){  //détection de l'appui du bouton B
  compteur=1;
}
if(front==0){
  compteur=0;
}
if(compteur==1 && compteur2==0){  //incrémentation seulement sur un
  sens_rotation+=1;               //front montant
}
compteur2=compteur;

  if(analogRead(bouton)>0){  //si le bouton B est enfoncé
    if (sens_rotation%2==0){ // si le résultat est pair
      if(sens_rotation==2){
        stop();
      }
      else{
        advance(255-128);  // le driver fonctionne à l'état bas en marche avant
      }
    }
    if (sens_rotation%2==1){  // si le résultat est impair
      back_off(128);   // le driver fonctionne à l'état haut en marche arrière
    }
  }

  if(analogRead(bouton)==0){  //si le bouton A est enfoncé
    stop();
  }
}

Le but de ce programme est de faire fonctionner ce moteur à courant continu dans un sens puis dans l'autre grâce au récepteur radio et au driver l9110 dont le test est ici  .

Le principe est le suivant : on fait varier le sens de rotation du moteur à chaque fois qu'il s'arrête et redémarre (donc on appui sur le bouton A puis en incrémentant une variable à chaque front montant du signal du bouton B.

Pour détecter les fronts montants, un compteur prend la valeur 0 si le signal du bouton B est nul et prend la valeur 1 si une tension est détectée. Un compteur2 mémorise la valeur précédente du premier compteur et l'incrémentation se fait uniquement pour compteur =1 et compteur2=0.

Ensuite, il suffit de distinguer les cas en faisant une division par 2 avec reste pour déterminer quand le résultat est pair ou impair.

Bref, avec le programme présenté, voila le résultat :

Avec ça, vous pouvez par exemple ouvrir ou fermer une porte de garage !

Si vous voulez un autre exemple d'utilisation, il y  a ce post sur une pince robotique  .

Salut !

Ce test concerne le driver L9110 de la boutique  .

Il s'agit d'un petit driver de moteur à courant continu très facile à utiliser !

Il a deux puces de commande et peut donc piloter 2 moteurs à courant continu qui sont reliés par l'intermédiaire de deux borniers à vis.

L'intérêt de ce driver c'est qu'il est très petit (pas plus grand qu'une pièce de 2€ !) et s'intègre super facilement dans n'importe quel projet !

Il peut se fixer à l'aide des 4 trous de vis M3 présents.

Sur le fonctionnement :

Il peut être piloté à partir de 2,5 V, ce qui le rend utilisable par des cartes microcontrôleurs alimentées en 3,3 V ou 5 V.

Le courant maximal qui circule dans ce driver est de 800 mA.

Deux entrées numériques sont utilisées pour contrôler à la fois la direction et la vitesse du moteur.

Voici la table de vérité du driver, pour un moteur :

L'entrée IA est utilisée pour donner l'information sur la vitesse et IB l'information sur la direction.

Il faut faire attention puisque lorsque l'on veut faire tourner en avant le moteur (dans mon cas) c'est l'état bas du signal de vitesse qui est pris en compte par le driver et non l'état haut.

Un exemple simple : pour faire tourner le moteur à pleine vitesse dans le sens positif, il ne faudra pas utiliser la commande "analogWrite(255);" sur votre carte arduino mais bien "analogWrite(0);"  .

Le driver possède aussi une led qui permet de savoir quand il est mis sous tension.

Voila le programme que j'ai utilisé dans mon arduino pour faire fonctionner correctement ce petit driver :

Et la vidéo qui va avec :

Pour vous faire une idée de ce driver, rien de tel qu'une modélisation 3D que voici   :

Voilà voilà, n'hésitez pas à poser des questions !

Salut NekoKS !

Je vais te proposer un programme qui fonctionne pour ouvrir/fermer ta pince !

Mais d'abord, voyons voir ce que tu as fait  :

Le début de ton programme est juste, par contre je pense qu'il y a des erreurs dans ta fonction loop.

 

 

for(pos1 = 0; pos1 < 180; pos1 += 180)

Quand tu fais pos1 +=180, la variable pos1 est incrémentée de 180 en 180. Mais ta boucle se termine lorsque pos1<180, donc ta boucle ne fonctionne que pour pos1=0. Je te propose donc de ne pas mettre de boucle à moins que tu changes la valeur de l'incrémentation.

 

 

for(pos1 = 180; pos1>=180; pos1-=180)

Dans ta deuxième boucle du décrémente pos1 de 180, mais ta condition d'arrêt est "pos1>=180", donc ta deuxième boucle ne va jamais s’arrêter.

Si tu veux aller de la position 180 à 0 : for(pos1=180, pos1=0, pos1-=180).

Par contre après vérification l'émetteur récepteur radio que tu as, ne fonctionne pas exactement comme ce que Mike a dit. Sur les deux fils de signal (blanc et vert) un seul est utile : le vert est une alimentation 5V et le blanc le fil qui permet de connaitre la position des boutons.

J'illustre ça avec quelques images (c'est plus facile  )

Là c'est le signal lorsque le bouton A de l'émetteur est appuyé (la courbe jaune c'est le fil blanc et la courbe bleue c'est le fil vert (trop de couleurs  :kez_11: ))

La courbe 1 est à 0V et la courbe 2 est à 5V.

Maintenant, c'est le bouton B qui est enfoncé : la courbe 1 est à 600mV et la courbe 2 est à 5V.

Bref, un seul signal change. Pour ton application sert toi uniquement du fil blanc.

Une petite remarque en plus, le signal du récepteur est de 600mV lorsque le bouton B est enclenché, c'est une tension trop faible pour qu'elle soit lue comme un état haut grâce au "digitalRead" d'arduino. Il faut que tu branche le fil sur une entrée analogique (A0 à A5) et que tu utilise un "analogRead".

A présent, ma version :

J'utilise la pince présente dans le kit bras et pince robot et un servomoteur towerPro.

Voici le code dans la carte arduino :

#include <Servo.h>
#define bouton A2  //pin du siganl du récepteur radio

Servo myservo;  // creation d'un objet servo pour le controler

void setup() {
  pinMode(bouton,INPUT);
  pinMode(3,OUTPUT);
  
  myservo.attach(3);  // le pin 3 est attribué au servo
  myservo.write(145);

  Serial.begin(9600);
}

void loop() {
    if (analogRead(bouton)>0){  //lecture de la valeur du signal du récepteur
      myservo.write(10);      //position pince ouverte
      Serial.println("HIGH");
    }
        
    if (analogRead(bouton)==0){
      myservo.write(145);   //position pince fermée
      Serial.println("LOW");
    }
}

Et le résultat en vidéo :

Et voilà ! J'espère que mes explications étaient assez claires, hésites pas à continuer de partager ton avancée  .

Pour la dérive j'ai fait un essai en immobilisant l'imu dans une position et j'ai relevé les valeurs toutes

les 5 minutes pendant 1 heure et j'ai tracé la courbe suivante :

On voit bien que seul un axe (celui de lacet) est soumis à une forte dérive.

Sinon pour les écarts j'ai fait un histogramme et ont obtient sur une heure une variation d'environ 15° sur l'axe de lacet.

Finalement l'écart sur une heure sur les deux autres axes est négligeable.

Pour avoir des valeurs stables sur tous les axes il y a un temps de calibration nécessaire.

J'ai fait plusieurs essaies et il faut en moyenne à peu près 30s plus ou moins 2s à chaque essaies.

Les valeurs me semble cohérentes : après l'avoir secoué un peu dans tout les sens je l'ai immobilisé et remis en position initiale.

Les valeurs étaient quasiment identiques qu'au départ sur tous les axes (à 0.03 près).

Pour les mouvements de lacet, roulis et tangage, les axes sont les suivants :

 L'axe x correspond à la 1ère colonne dans le moniteur série (lacet), l'axe y à la 2ème (tangage) et l'axe z à la 3ème (roulis).

Pour la dérive je n'ai pas encore fait le test. Je posterai le résultat dans la journée . 

Bonjour !

Je lance un nouveau test, cette fois-ci il s'agit du MPU-6050.

C'est une centrale inertielle à 6 degrés de liberté. Ce capteur comporte à la fois un gyromètre 3 axes et un accéléromètre 3 axes.

Le MPU-6050 est un petit circuit imprimé avec 8 broches de connexions.

Il est fournit avec des connecteurs séparés, il y en a deux sortes. Comme ça on peut souder ceux qu'on veut  .

Donc une petite étape de soudure plus tard... le montage.

J'ai utilisé une carte arduino uno pour communiquer avec la centrale inertielle. Le capteur communique avec le protocole I2C, c'est pratique.

Les connexions :

• la broche VCC du capteur avec celle de la carte
• le GND du capteur avec celle de la carte
• la broche SCL du capteur est connectée à la broche A5 de la arduino
• la broche SDA à la broche A4 de la carte
• la broche INT du capteur est connectée à la broche numérique 2 de la carte.

Pour la programmation, je me suis contenté d'utiliser le code d'exemple du MPU-6050 que voici

Après un court temps d'initialisation, le capteur affiche des valeurs dans le moniteur série.

Il faut attendre quelques instants pour que les valeurs se stabilisent.

Ensuite on peut jouer avec la centrale en la bougeant dans tous les sens !

Le capteur à l'air assez précis, ce qui est une très bonne chose !

Pour la suite je vais essayer d'avoir une interface graphique qui analyse les données de la centrale inertielle. 

Salut,

Je propose ici un test du Kit robot à chenille avec encodeurs.

Il est déjà entièrement assemblé, le châssis est soudé et les moteurs montés comme le montre la photo.

Bon pour commencer on va faire fonctionner ce mini char sans les encodeurs présents sur les moteurs chaque chose en son temps ! 

C'est un peu dommage, mais pour l'utiliser il faudra d'abord rallonger les fils d'alimentation des moteurs qui sont trop courts pour être branchés sur un quelconque driver  .

Pour jouer avec ce petit char j'utilise : une radiocommande, un driver de moteur CC, un clone d'Arduino Uno et une batterie Li-Po.

Les branchements s'effectuent comme dans le test pour le driver puisque c'est le même.

Pour fixer les cartes sur le châssis, il y a plusieurs emplacement possible, il suffit d'en trouver un qui convient. Par contre comme les moteurs sont déjà montés et gènent un peu, c'est pas toujours évident pour positionner les vis et les entretoises.

Quelques images du robot avec les cartes :

J'ai commencé par faire un programme simple pour piloter uniquement le robot en avant ou en arrière en fonction des ordres de la radiocommande.

Je mets le code et une image une fois dans l'IDE (au cas ou le web editor ne fonctionne pas  ).

// Contrôle PWM simple
#define PB 3    // Contrôle vitesse moteur 1
#define B1 5    // Contrôle direction moteur 1
#define B2 6
#define PA 9    // Contrôle vitesse moteur 2
#define A1 10   // Contrôle direction moteur 2
#define A2 11 

                 // Déclaration des variables correspondantes
int ch2;        // aux différentes channels
int ch3;

unsigned int vitesse;    //vitesse de commande des moteurs

void stop()     //Stop
{
digitalWrite(PB,LOW);
digitalWrite(PA,LOW);
}

void avance(int vitesse) // En avant
{
analogWrite (PB,vitesse); // Contrôle de vitesse en PWM
digitalWrite(B1,LOW);
digitalWrite(B2,HIGH);
analogWrite (PA,vitesse);
digitalWrite(A1,LOW);
digitalWrite(A2,HIGH);
}

void recule (int vitesse) // En arrière
{
analogWrite (PB,vitesse);
digitalWrite(B1,HIGH);
digitalWrite(B2,LOW);
analogWrite (PA,vitesse);
digitalWrite(A1,HIGH);
digitalWrite(A2,LOW);
}


void setup() {

  pinMode(PB, OUTPUT);
  pinMode(B1, OUTPUT);
  pinMode(B2, OUTPUT);
  pinMode(PA, OUTPUT);
  pinMode(A1, OUTPUT);
  pinMode(A2, OUTPUT);
  
                      // Configuration des broches
  pinMode(4, INPUT); // comme entrées
  pinMode(7, INPUT);

  Serial.begin(9600); // Démarage de la liaison série  
}

void loop() {
                                 // Lit la largeur d'impulsion de 
  ch2 = pulseIn(4, HIGH, 25000); // chaque channel
  delay(5);
  ch3 = pulseIn(7, HIGH, 25000);
  delay(5);

  vitesse=map(ch3,980,2000,0,255);   //valeur vitesse de commande

  Serial.print("Channel 2:");
  Serial.println(ch2);

  Serial.print("Channel 3:");
  Serial.println(ch3);

  if(ch2==0){  //radiocommande éteinte
    stop();
  }

else{
  if ((ch2>1470) and (ch2<1490)){
     stop();   
  }
  if (ch2>1490){    //joystick en avant
     avance(vitesse);   
  }
  if (ch2<1470){   //joystick en arrière
     recule(vitesse);   
  }
}
}

J'ai essayé un programme pour ajouter une fonction de rotation au robot. Et là ça devient un peu plus compliqué avec la gestion des différentes positions des joysticks  .

// Contrôle PWM simple
#define PB 3 // Contrôle vitesse moteur 1
#define B1 5 // Contrôle direction moteur 1
#define B2 6
#define PA 9 // Contrôle vitesse moteur 2
#define A1 10 // Contrôle direction moteur 2
#define A2 11 

int ch1; // Déclaration des variables correspondantes
int ch2; // aux différentes channels
int ch3;

unsigned int vitesse;  //vitesse de commande des moteurs

void stop()     //Stop
{
digitalWrite(PB,LOW);
digitalWrite(PA,LOW);
}

void avance(int vitesse) // En avant
{
analogWrite (PB,vitesse); // Contrôle de vitesse en PWM
digitalWrite(B1,LOW);
digitalWrite(B2,HIGH);
analogWrite (PA,vitesse);
digitalWrite(A1,LOW);
digitalWrite(A2,HIGH);
}

void recule (int vitesse) // En arrière
{
analogWrite (PB,vitesse);
digitalWrite(B1,HIGH);
digitalWrite(B2,LOW);
analogWrite (PA,vitesse);
digitalWrite(A1,HIGH);
digitalWrite(A2,LOW);
}

void tourne_G (int vitesseB,int vitesseA) // Tourne à gauche
{
analogWrite (PB,vitesseB);
digitalWrite(B1,LOW);
digitalWrite(B2,HIGH);
analogWrite (PA,vitesseA);
digitalWrite(A1,LOW);
digitalWrite(A2,HIGH);
}

void tourne_D (int vitesseB,int vitesseA) // Tourne à droite
{
analogWrite (PB,vitesseA);
digitalWrite(B1,LOW);
digitalWrite(B2,HIGH);
analogWrite (PA,vitesseB);
digitalWrite(A1,LOW);
digitalWrite(A2,HIGH);
}


void tourne_G_AR (int vitesseB,int vitesseA) // Tourne à gauche en arrière
{
analogWrite (PB,vitesseB);
digitalWrite(B1,HIGH);
digitalWrite(B2,LOW);
analogWrite (PA,vitesseA);
digitalWrite(A1,HIGH);
digitalWrite(A2,LOW);
}

void tourne_D_AR (int vitesseB,int vitesseA) // Tourne à droite en arrière
{
analogWrite (PB,vitesseA);
digitalWrite(B1,HIGH);
digitalWrite(B2,LOW);
analogWrite (PA,vitesseB);
digitalWrite(A1,HIGH);
digitalWrite(A2,LOW);
}

void setup() {

  pinMode(PB, OUTPUT);
  pinMode(B1, OUTPUT);
  pinMode(B2, OUTPUT);
  pinMode(PA, OUTPUT);
  pinMode(A1, OUTPUT);
  pinMode(A2, OUTPUT);
  
  pinMode(2, INPUT); // Configuration des broches
  pinMode(4, INPUT); // comme entrées
  pinMode(7, INPUT);

  Serial.begin(9600); // Démarage de la liaison série  
}

void loop() {

  ch1 = pulseIn(2, HIGH, 25000); // Lit la largeur d'impulsion de 
  delay(5);
  ch2 = pulseIn(4, HIGH, 25000); // chaque channel
  delay(5);
  ch3 = pulseIn(7, HIGH, 25000);
  delay(5);

  vitesse=map(ch3,980,2000,0,255);      //valeur vitesse


  Serial.print("Channel 1:");
  Serial.println(ch1);

  Serial.print("Channel 2:");
  Serial.println(ch2);

  Serial.print("Channel 3:");
  Serial.println(ch3);

  if(ch2==0){   //radiocommande éteinte
    stop();
  }

else{
  if ((ch2>1470) and (ch2<1490)){
     stop();   
  }
  if (ch2>1490){    //joystick en avant
     avance(vitesse);    
  }
  if ((ch1>1490) and (ch2>1490)){    //joystick à droite en avant
    if (vitesse<128){
     tourne_D(vitesse,255-vitesse);
    }
    else{
      tourne_D(255-vitesse,vitesse);
    }
  }
  if ((ch1<1470) and (ch2>1490)){    //joystick à gauche en avant
    if(vitesse<128){
     tourne_G(vitesse,255-vitesse);
    }
    else{
      tourne_G(255-vitesse,vitesse);
    }
  }

  if (ch2<1470){      //joystick en arrière
     recule(vitesse);   
  }
    if ((ch1>1490) and (ch2<1470)){    //joystick à droite en arrière
      if(vitesse<128){
       tourne_D_AR(vitesse,255-vitesse);
      }
      else{
        tourne_D_AR(255-vitesse,vitesse);
      }
  }
  if ((ch1<1470) and (ch2<1470)){    //joystick à gauche en arrière
    if(vitesse<128){
     tourne_G_AR(vitesse,255-vitesse);   
    }
    else{
      tourne_G_AR(255-vitesse,vitesse);
    }
  }
} 
}

Finalement voici le robot en action :

Bon.. les commandes ne sont pas encore tout à fait au point mais il y a de l'évolution ! 

EDIT : Voici le tutoriel complet pour fabriquer votre char. 

Bonjour à tous !

Je propose un fil dédié au test du driver 20A pour deux moteurs CC présent sur le shop.

C’est un driver qui peut piloter un ou deux moteurs à courant continu fonctionnant entre 12V et 30V. Ce driver peut être utilisé par des microcontrôleurs en 3.3V ou 5V, d’ailleurs sa prise 5V fourni 200mA ce qui est suffisant pour alimenter une carte Arduino.

Ce driver contrôle chaque moteur à l’aide de 3 sorties numériques : 2 sorties qui contrôle la direction du moteur et une sortie en PWM qui pilote la vitesse du moteur.

Pour tester ce driver, j'ai utilisé : une carte clone Arduino Uno, un moteur à courant continu, et une batterie Li-Po.

Voici une illustration du montage que j'ai fait pour connecter tous les éléments (attention le driver n'est pas représentatif   ).

http://fritzing.org/projects/driver-moteur-cc

Avec le bon driver, les connections sont les suivantes :

• La broche GND de la carte Arduino reliée à celle du driver

• Une broche PWM de l’Arduino reliée à la broche PB du driver

• Deux broches numériques de la carte reliées aux broches B1 et B2 du driver.

Comment piloter la vitesse des moteurs avec ce driver ?

Sur ce driver, il y a deux puces de commande de moteurs (une pour chaque moteur) qui reprennent le principe du pont en H.

Les signaux de contrôle de la vitesse des moteurs sont de type PWM (Pulse Width Modulation), ce sont des signaux qui peuvent prendre deux états : l’état haut ou l’état bas. La vitesse est modulée en fonction de la durée de ces états, plus l’état haut dure longtemps et plus le moteur tourne vite.

Une fois le câblage terminé, j'ai écrit un programme qui permet de contrôler un moteur à l'aide des touches du clavier.

Je mets en dessous le code et une image une fois dans l'IDE (au cas ou le web editor ne fonctionne pas    ).

// Contrôle PWM simple
#define PB 3 // Contrôle vitesse moteur 1
#define B1 4 // Contrôle direction moteur 1
#define B2 5 

void stop() //Stop
{
digitalWrite(PB,LOW);
}

void advance(char a) // En avant
{
analogWrite (PB,a); // Contrôle de vitesse en PWM
digitalWrite(B1,HIGH);
digitalWrite(B2,LOW);
}

void advancem(char a) // En avant vitesse médiane
{
analogWrite (PB,a); // Contrôle de vitesse en PWM
digitalWrite(B1,HIGH);
digitalWrite(B2,LOW);
}

void back_off (char a) // En arrière
{
analogWrite (PB,a);
digitalWrite(B1,LOW);
digitalWrite(B2,HIGH);
}

void setup()
{
int i;
for(i=3;i<=5;i++)
pinMode(i, OUTPUT);
Serial.begin(9600); // Définit vitesse de transmission série
Serial.println("Execution du controle par clavier");
}

void loop()
{
if(Serial.available()){
char val = Serial.read(); //récupération des caractères sur le
if(val != -1)             //port série
{
switch(val)
{
case 'z':// En avant si touche "z"
advance (255); // en avant vitesse max
break;
case 'a':// En avant si touche "a"
advancem (128); // en avant vitesse médiane
break;
case 's':// En arrière si touche "s"
back_off (255); // en arrière vitesse max
break;
case 'x': // arrêt si touche "x"
stop();
break;
}
}
else stop();
}
}

Le résultat en vidéo :

Ce qui est sympa avec ce driver c'est qu'il possède des leds qui s'allument en fonction des différentes commandes. Cela peut paraître inutile mais c'est bien pratique pour voir comment fonctionne le driver et le programme.

Il y a deux leds par puce de commande : une verte qui fonctionne quand le moteur va en avant et une orange qui fonctionne dans l'autre sens.

Il y a aussi une led violette qui s'illumine lorsque la carte est sous tension.

Et voilà pour le fonctionnement de ce driver !

Bonjour !

Voici un nouveau sujet qui concerne le test de la radio commande 6 voies.

Déballage:

la télécommande dans son carton avec les caractéristiques au verso:

Passons à l'ouverture de la boîte:

La boîte contient : la télécommande, le récepteur avec un connecteur, un cd avec la notice.

La télécommande et les autres éléments sont contenu dans un emballage plastique qui possède la forme de la télécommande, plutôt pratique pour le rangement !

Mes impressions : La télécommande est facile à prendre en main et assez légère. Les joysticks ont une partie métallique qui permet une très bonne adhérence (attention toutefois à ne pas se griffer dessus lors des premières utilisations     ).

Il est temps de passer à la mise en marche !

J'observe les données transmises par la radiocommande. Pour ça, j'utilise une carte clone arduino uno que je relie au récepteur.

Les signaux émis par la radiocomande sont de type PWM (Pulse Width Modulation), donc les broches de signaux du récepteur sont connectées aux entrées digitales de l'Arduino.

Pour mesurer les largeurs d'impulsions qui correspondent aux différentes informations, on peut utiliser la fonction "pulseIn".

J'ai utilisé le programme suivant pour afficher les données :

Je mets en dessous le code et une image une fois dans l'IDE (au cas ou le web editor ne fonctionne pas  ).

int ch1; // Déclaration des variables correspondantes
int ch2; // aux différentes channels
int ch3;
int ch4;
int ch5;
int ch6;

void setup() {
  pinMode(2, INPUT); // Configuration des broches 2 à 7
  pinMode(3, INPUT); // comme entrées
  pinMode(4, INPUT);
  pinMode(5, INPUT);
  pinMode(6, INPUT);
  pinMode(7, INPUT);

  Serial.begin(9600); // Démarage de la liaison série  
}

void loop() {

  ch1 = pulseIn(2, HIGH, 25000); // Lit la largeur d'impulsion de 
  delay(5);
  ch2 = pulseIn(3, HIGH, 25000); // chaque channel
  delay(5);
  ch3 = pulseIn(4, HIGH, 25000);
  delay(5);
  ch4 = pulseIn(5, HIGH, 25000); 
  delay(5);
  ch5 = pulseIn(6, HIGH, 25000);
  delay(5);
  ch6 = pulseIn(7, HIGH, 25000);
  delay(5);

  Serial.print("Channel 1:"); // Affiche sur le moniteur série la 
  Serial.println(ch1);        // valeur de chaque channel

  Serial.print("Channel 2:");
  Serial.println(ch2);

  Serial.print("Channel 3:");
  Serial.println(ch3);

  Serial.print("Channel 4:");
  Serial.println(ch4);

  Serial.print("Channel 5:");
  Serial.println(ch5);

  Serial.print("Channel 6:");
  Serial.println(ch6);
  
//  delay(100); // Temps entre chaque mesures (ms)
}

En bref je la trouve plutôt complète et agréable à utiliser : elle est facilement programmable et possède pas mal de fonctionnalités notamment des réglages de courbes d'accélération pour les pilotes de drones.