Aller au contenu


Contenu de mthibs

Il y a 27 élément(s) pour mthibs (recherche limitée depuis 04-avril 13)



#81631 Kit bras rotatif et pince robot [testé par mthibs]

Posté par mthibs sur 04 avril 2017 - 10:27 dans Robots en kits

La librairie Adafruit_PWMServoDriver.h permet de piloter le driver de servo avec des impulsions, tu peux utiliser la fonction "map" d'arduino pour faire une conversion impulsion/angle pour piloter le servo moteur plus facilement.

La librairie Wire.h gère la communication I2C avec le driver.

 

Après les servo pourront être pilotés pour que le bras récupère un objet par exemple  ^_^ .

Par contre il faut faire attention à ne pas atteindre les valeurs extrêmes trop brusquement pour ne pas arracher les fils des servo qui peuvent être un peu court (tout dépend de l'emplacement du driver après).




#81467 Kit bras rotatif et pince robot [testé par mthibs]

Posté par mthibs sur 31 mars 2017 - 08:55 dans Robots en kits

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.

 

bras-rotatif-pieces.jpg

 

Je mets quelques photos du montage :

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

bras-rotatif-montage-6.jpg

bras-rotatif-montage-5.jpg

 

Ensuite on passe à la partie supérieure

bras-rotatif-montage-10.jpg

bras-rotatif-montage-15.jpg

bras-rotatif-montage-16.jpg

 

Et enfin le montage de la pince

bras-rotatif-montage-20.jpg

bras-rotatif-montage-21.jpg

 

Le bras est monté !

bras-rotatif-fini-3.jpg

 

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

bras-rotatif-cartes.jpg

 

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  :D




#81455 Capteur de couleur GY-31 [testé par mthibs]

Posté par mthibs sur 31 mars 2017 - 07:19 dans Capteurs

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 !

 

feuille-bleue-capteur-couleur.jpg

feuille-jaune-capteur-couleur.jpg

 

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

calibration couleur.jpg

 

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




#81182 Petit probleme avec module HC-SR04

Posté par mthibs sur 27 mars 2017 - 12:42 dans Programmation

@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 :

post-melmet.jpg

 

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  ;)




#81174 Petit probleme avec module HC-SR04

Posté par mthibs sur 27 mars 2017 - 10:24 dans Programmation

Salut !

 

 

distance = (duration/2) / 29.1;

Je ne comprends pas trop le 29.1 ^^ j'aurais mis 0.34 qui est la vitesse du son en mm/µs (si u veux ta distance en mm).

Sinon tu peux essayer de mettre un TimeOut sur le signal de echoPin, pour voir si ça change quelquechose.

Peut être que le tutoriel sur le capteur ultrason pourrait t'aider ?  :)




#81172 Driver I2C 16 servomoteurs [testé par Jekert]

Posté par mthibs sur 27 mars 2017 - 10:00 dans Drivers de moteurs et actionneurs

Cool ! Merci pour la réponse Jekert et Path !  ;)




#81012 Driver I2C 16 servomoteurs [testé par Jekert]

Posté par mthibs sur 25 mars 2017 - 03:57 dans Drivers de moteurs et actionneurs

Salut !

Tu peux me dire à quoi sert la broche "OE" du driver stp?  ^_^




#80889 Capteur de couleur GY-31 [testé par mthibs]

Posté par mthibs sur 23 mars 2017 - 08:09 dans Capteurs

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é.

 

capteur-couleur-GY-31.jpg

GY-31-led-on.jpg

 

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 :

cablage-GY-31.jpg

cablage-GY-31-2.jpg

 

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 !   ;)




#80413 Emetteur récepteur radio [testé par mthibs]

Posté par mthibs sur 16 mars 2017 - 04:39 dans Présentations de produits robotique

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.

emetteur-radio.jpg

 

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.

recepteur-radio.jpg

 

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.

soudage-recepteur-radio-4.jpg

 

 

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 :

signal-recepteur-bouton-a.jpg

 

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é :

signal-recepteur-bouton-b.jpg

 

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  :o .

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 B) 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  ^_^ .




#80303 Driver L9110 pour moteur CC [testé par mthibs]

Posté par mthibs sur 13 mars 2017 - 02:22 dans Drivers de moteurs et actionneurs

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 !

driver-l9110.jpg

 

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.

taille-driver-9110.jpg

 

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.

 

driver-l9110-zoom.jpg

 

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 :

table-verite-driver-l9110.jpg

 

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.

driver-l9110-led.jpg

 

 

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 :D  :

 

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




#79907 Kit robot à chenille avec encodeurs [testé par mthibs]

Posté par mthibs sur 03 mars 2017 - 11:54 dans Robots en kits

Salut !

Au niveau du bruit, je le trouve plutôt silencieux mais tu peux juger par toi avec la vidéo :

Fichier joint  20170215_130750.zip   53,86 Mo   293 téléchargement(s)




#79906 Radio Commande 6 voies [testée par mthibs]

Posté par mthibs sur 03 mars 2017 - 11:41 dans Présentations de produits robotique

Oups, désolé pour l'attente de la réponse  :unsure:

1- Oui les 6 canaux c'est bien les axes des joysticks + VRA et VRB

2- les switchs servent pour l'attribution des canaux auxiliaires 5 et 6. Il y a la possibilité de controler ces canaux avec au choix : VRA, VRB, SWA, SWB, SWC, SWD.

3- Ils peuvent être transmis si on les sélectionne soit pour la voie 5 soit pour la voie 6

4- Il faut 8 piles AA LR6 1,5V pour alimenter la télécommande

5- La prise au dos sert pour l'update du firmware, par contre le cable est pas fournie avec la télécommande

6- La consommation du récepteur est de 24 mA en fonctionnement et 22 mA avec la télécommande éteinte. C'est donc négligeable si tu alimentes aussi des servos avec ton arduino.

 

J'espère avoir répondu à tes questions  ^_^




#79881 Pinces Robotiques Télécommandées

Posté par mthibs sur 03 mars 2017 - 01:01 dans Mécanique

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  :D )

signal-recepteur-bouton-a.jpg

 

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.

 

signal-recepteur-bouton-b.jpg

 

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  ^_^ .




#79690 Bouton d'arrêt d'urgence [testé par mthibs]

Posté par mthibs sur 27 février 2017 - 08:51 dans Présentations de produits robotique

Salut !
je propose un sujet de test sur le bouton d'arrêt d'urgence de la boutique.
 
Une fois qu'on l'a dans les mains il ressemble à ça :
20170221_110558.jpg
20170221_110546.jpg
20170221_110904.jpg
 
Je l'ai démonté pour voir un peu comment il fonctionne et il y a pas mal de pièces:
20170221_110723.jpg
20170221_113020.jpg
20170222_180555.jpg
 
 
Le bouton est facilement modulable et possède 4 borniers à vis de fixation, c'est plutôt pratique !
Il y a deux parties : une connexion NO (normalement ouverte) en vert sur l'image et une connexion NF (normalement fermée) en orange sur l'image.
Les deux parties permettent soit d'ouvrir le circuit lors d'un appui sur le bouton, soit le fermer. De quoi adapter ce bouton à pas mal d'applications =).
Il faut un trou de diamètre 24 mm pour pouvoir le monter.
 
J'ai fait une petite modélisation avec CatiaV5 pour que vous puissiez mieux l'imaginer :
bouton arret urgence.jpg
vue éclatée 2.jpg

 

 

téléchargement : Fichier joint  bouton arret urgence.zip   395,69 Ko   406 téléchargement(s)

 
Et une petite vidéo  ;) :

 

Je trouve que ce bouton est idéale pour des robots comme ceux de la coupe de France de robotique (sur lesquels un bouton d'arrêt d'urgence est obligatoire)




#79492 Le blog du shop

Posté par mthibs sur 22 février 2017 - 08:35 dans News, actus de la boutique

Un nouvel article est présent sur le blog ! Il s'agit d'un tutoriel sur le driver de moteur cc qui a été testé sur le forum : ici  ;)




#79468 Le blog du shop

Posté par mthibs sur 21 février 2017 - 08:37 dans News, actus de la boutique

L'article d'aujourd'hui vous donne quelques conseils pour bien souder en prenant pour exemple d'application des connecteurs de batterie LiPo !




#79438 Le blog du shop

Posté par mthibs sur 20 février 2017 - 07:51 dans News, actus de la boutique

Deux nouveaux articles ont été ajoutés sur le blog : l'un porte sur l'utilisation des batteries LiPo, l'autre explique comment commander des leds à distance !




#79351 Le blog du shop

Posté par mthibs sur 18 février 2017 - 12:15 dans News, actus de la boutique

Un nouveau tutoriel a été publié, il s'agit cette fois-ci d'utiliser un écran lcd couplé avec un capteur ou une radiocommande  ^_^ .



#79341 MPU-6050 [testé par mthibs]

Posté par mthibs sur 17 février 2017 - 08:39 dans Capteurs

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 :

 

dérive.png

 

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.

 

dérive2.png

 

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




#79331 MPU-6050 [testé par mthibs]

Posté par mthibs sur 17 février 2017 - 10:26 dans Capteurs

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.

 

temps.png

 

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 :

axes.jpg

 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 ;)




#79316 Le blog du shop

Posté par mthibs sur 16 février 2017 - 08:28 dans News, actus de la boutique

ça y est, les 30 jours du "I Love robotique" ont débutés depuis hier !

 

Vous aurez accès à des articles et des tutoriels liés aux produits de la boutique !

 

Je posterai le lien des articles sur ce sujet.

La première publication concernait la présentation de la radiocommande et son fonctionnement et la deuxième montre comment utiliser   la radiocommande avec une arduino   

 

A demain !  ;)




#79313 MPU-6050 [testé par mthibs]

Posté par mthibs sur 16 février 2017 - 08:03 dans Capteurs

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.

20170216_170809.jpg

 

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.

20170216_174835.jpg

 

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.

 

imu 2.png

 

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. 

 




#79282 Kit robot à chenille avec encodeurs [testé par mthibs]

Posté par mthibs sur 15 février 2017 - 08:20 dans Robots en kits

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.

 

20170213_171305.jpg

 

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  <_< .

 

20170213_181415.jpg

 

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 :

20170214_151755.jpg

20170214_151932.jpg

 

 

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);   
  }
}
}

tuto char.png

tuto char(2).png

 

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 !  :D

 

 

EDIT : Voici le tutoriel complet pour fabriquer votre char




#79278 Radio Commande 6 voies [testée par mthibs]

Posté par mthibs sur 15 février 2017 - 06:55 dans Présentations de produits robotique

Le signal PWM reçu permet de transmettre les informations de la radiocommande.

C'est un signal avec des impulsions carrées qui durent plus ou moins longtemps en fonction de la position des boutons de la télécommande.

 

Avec un oscilloscope ça donne ça : (j'ai branché la voie de l'oscilloscope sur la broche de signal du 1er canaux du récepteur)

 

20170207_170811.jpg

 

Il y a un état haut et un état bas qui peuvent être détectés par l'Arduino.




#79276 Driver 20A pour deux moteurs CC [testé par mthibs]

Posté par mthibs sur 15 février 2017 - 06:38 dans Drivers de moteurs et actionneurs

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.

 

20170209_182653.jpg

 

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  :unsure: ).

 

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

montage.png

 

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.

20170215_194704.jpg

 

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();
}
}

driver.png

driver2.png

 

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.

 

20170215_180346.jpg

20170215_174722.jpg

 

Et voilà pour le fonctionnement de ce driver !