électronique

Contrôler un mini servo avec Arduino

servomotor                       
mini servo

Fonctionnement d’un servo moteur

Tout d’abord, il faut s’avoir qu’un servo permet d’effecter des déplacements en translation ou en rotation. De nombreux objets du quotidien utilisent des servo moteurs: voitures télécommandées, drône, électroménager, …
Les différents types de servos se distingue par 3 caractéristiques:
  • leur vitesse de rotation par seconde
  • leur course en degré
  • leur couple exprimé en kg.cm
Le fonctionnement d’un servo est relativement simple. Il suffit d’envoyer une impulsion dont la durée est comprise entre 0,5ms et 2,5ms au servo. Cette impulsion déterminera la position du guide du servo. Ainsi la valeur de 1,5ms donne au servomoteur la position centrale.
Ces impulsion doivent être envoyée de manière périodique, généralement toutes les 50ms.
Il n’y a rien de compliquer pour brancher un servo. Les servos ont généralement 3 fils:
  • un rouge: qui doit être branché au 5V (ou 12V suivant votre servo)
  • un noir : qui doit être branché à la masse
  • un orange (ou autre couleur) : qui  est le fil de tension de commande 0-5V
C’est donc via le fil orange que les commandes seront passées à votre servo. Ce fil devra obligatoire être relié à votre Arduino sur un pin PWN.
Voyons maintenant comment connecter un mini servo à notre Arduino.

Connecter un servo sur un Arduino

Voici le montage que j’ai réalisé pour tester mon mini servo:
arduino mini servo

Il suffit ensuite de charger le sketch suivant dans votre Arduino. Ce script utilise la librairie Servo nativement disponible dans l’outil de développement de votre Arduino.
Source code   
// Sweep
// by BARRAGAN <http://barraganstudio.com> 
// This example code is in the public domain.
 
#include <Servo.h> 
 
Servo myservo;  // create servo object to control a servo 
                // a maximum of eight servo objects can be created 
 
int pos = 0;    // variable to store the servo position 
 
void setup() 
{ 
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object 
} 
 
void loop() 
{ 
  for(pos = 0; pos < 180; pos += 1)  // goes from 0 degrees to 180 degrees 
  {                                  // in steps of 1 degree 
    myservo.write(pos);              // tell servo to go to position in variable 'pos' 
    delay(15);                       // waits 15ms for the servo to reach the position 
  } 
  for(pos = 180; pos>=1; pos-=1)     // goes from 180 degrees to 0 degrees 
  {                                
    myservo.write(pos);              // tell servo to go to position in variable 'pos' 
    delay(15);                       // waits 15ms for the servo to reach the position 
  } 
}
Ce sketch est issu des exemples fournis avec Arduino. Il permet de faire tourner votre servo de 0 à 180 degré.
===========================================================================
==========================================================================
Télécommande par infrarouge - Tutoriel Arduino

Matériel utilisé
  • 1 récepteur infra-rouge 3 broches 38 kHz (portée 18 fts), type WS 1838B seul ou module monté sur PCB avec led témoin (mieux pour vos premiers essais).
  • 1 petite télécommande IR standard à 20 boutons avec sa pile bouton (retirer la languette pour activer la pile).
  • 1 télécommande de téléviseur
  • 1 carte Arduino Uno R3
  • 1 breadboard et fils de câblage mâle/mâle à connecteur Dupont
* kit de télécommande

Image.Image.Image

Principe de fonctionnement
Une diode émet des pulses en infra-rouge pour transmettre un signal de télécommande codé, vers à un récepteur infra-rouge placé dans un appareil que l'on commande à distance.

C'est le principe de télécommande utilisé sur tous les téléviseurs, magnétoscopes, appareils photos...
On peut l'utiliser pour ses projets personnels de robotique, domotique... à partir d'une petite télécommande standard, ou en décodant sa propre télécommande de téléviseur par exemple.

La portée est de plusieurs mètres, en ligne droite sans obstacles, le signal est invisible à l'œil humain.

Il existe de nombreux protocoles de transmissions (NEC, Sony SIRC, Philips RC5, Philips RC6, données brutes...) et plusieurs manières de coder les informations. Certains protocoles demande de répéter trois fois l'information.
Heureusement une bonne librairie pour Arduino gère tout ça.

Les signaux IR sont modulés à 38 kHz pour éviter les interférences avec la lumière ambiante. Le récepteur 38 kHz gère cette modulation directement.
Ceci permet de ne pas brouiller les appareils IR entre eux et d'avoir plusieurs fonctions par télécommande (on/off, choix de chaîne, réglage du volume...).

Applications
  • Télécommande par infrarouge de ses projets (robot, commande de volet roulant, domotique, éclairage...)
  • Enregistrer les codes d'une télécommande existante et les ré-émettre à l'identique pour cloner la télécommande
  • Regrouper plusieurs télécommandes en une seule (TV + Magnétoscope + DVD + éclairage du salon + chauffage).
  • Utilisation d'une télécommande existante pour un autre appareil.
  • Remplacement d'une télécommande perdue

Emission infra-rouge

Pour l'émission on peut utiliser
  • Une télécommande existante (TV, magnétoscope DVD...) dont on analyse les codes.
  • Une simple diode infra-rouge branchée sur sortie numérique (pin3), avec une résistance R1 100 Ω pour limiter le courant.
  • Une petite télécommande standard (21 boutons) à usage assez universel (solution la plus pratique)

Réception du signal
Le détecteur (3 broches) est branché sur une broche digitale pin11.
Image.Image

Récepteur -->Arduino
  • De gauche à droite, vu de face, broches 1 OUT, 2 GND, 3 VCC sur le composant seul.
  • Attention, sur la plaquette PCB le brochage est inversé, de gauche à droite on a
    GND (indiqué -), VCC (au centre), OUT (indiqué S)
Ne pas inverser le câblage au risque de griller le récepteur.
Image

Le bon fonctionnement du récepteur est indiqué par une petite led rouge sur le PCB qui s'allume à chaque réception.

Câblage :
Image.Image

Image

Programmation
Télécharger et installer la librairie #include <IRremote.h>
Elle comporte deux fichiers IRremote.cpp et IRremote.h et un sous-répertoire examples
Il faut aussi installer la librairie IRremoteInt.h

Exemple de code de réception

Code: Tout sélectionner
#include <IRremote.h>

int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn(); // Initialise le recepteur
}

void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    irrecv.resume(); // Recoit la valeur suivante
  }
}


Utilisation
Le serial monitor de l'IDE Arduino va directement afficher les codes reçus par la télécommande.
La petite led témoin sur la plaquette du récepteur s'allume lors d'une réception de signal de télécommande IR.

Décodage des touches de la télécommande standard à 21 boutons
Petit modèle simple, assez universel et bon marché, qui convient à la plupart des projets.
Image

=======================================================================
=======================================================================
Capteur ultra son HC-SR04

Les caractéristiques techniques du module sont les suivantes :
- Alimentation : 5v.
- Consommation en utilisation : 15 mA.
- Gamme de distance : 2 cm à 5 m.
- Résolution : 0.3 cm.
- Angle de mesure : < 15°.
Le brochage du module est le suivant :
image
Le fonctionnement du module est le suivant :
Il faut envoyer une impulsion niveau haut (à + 5v) pendant au moins 10 µs sur la broche ‘Trig Input’; cela déclenche la mesure. En retour la sortie ‘Output’ ou ‘Echo’, va fournir une impulsion + 5v dont la durée est proportionnelle à la distance si le module détecte un objet. Afin de pouvoir calculer la distance en cm, on utilisera la formule suivante :
distance = (durée de l’impulsion (en µs) / 58
Voici une représentation graphique de la séquence de fonctionnement du module :
image

Après la théorie passons à la pratique; le câblage du module à l’Arduino sera le suivant :
- broche 12 de l’Arduino vers Trig.
- broche 11  de l’Arduino vers Echo.

Le programme sera le suivant :
/* Utilisation du capteur Ultrason HC-SR04 */
// définition des broches utilisées
int trig = 12;
int echo = 11;
long lecture_echo;
long cm;
void setup()
{
  pinMode(trig, OUTPUT);
  digitalWrite(trig, LOW);
  pinMode(echo, INPUT);
  Serial.begin(9600);
}
void loop()
{
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);
  lecture_echo = pulseIn(echo, HIGH);
  cm = lecture_echo / 58;
  Serial.print("Distance en cm : ");
  Serial.println(cm);
  delay(1000);
}

---------------------------------------------------------------------------------------------------------------_____________________________________________________________________________________________________________________________
_____________________________________________________________________________

 10 novembre 2012
par chamayou


Le robot doit être capable de détecter devant lui des obstacles. Pour cela, on placera deux contacteurs à l’avant.
Activité 1 :Réaliser l’organigramme de programmation
opendocument graphics - 12.2 ko
Activité 2 :Programmer le robot avec PhysicalEtoys avec liaison filaire
Exemple :
Activité 3 :Programmer le robot avec PhysicalEtoys sans liaison filaire
Il faut programmer physical etoys en changeant le mode de connexion. Il faut ensuite charger le programme principal (les sous-programmes seront aussi chargés).


Activité 4 :Programmer avec l’IDE arduino
// robot avance, tourne droit ou gauche si capteur droit ou gauche
// by f. chamayou

#include <Servo.h>

Servo servod;  // cree un objet servodroit
Servo servog;  // cree un objet servogauche
int captdroit = 2;
int captgauche = 3;

// setup : programme lu une seule fois
void setup()
{
 servod.attach(8);  // servo droit connecté sur sortie 8
 servog.attach(9);  // servo gauche connecté sur sortie 9
 pinMode(captdroit, INPUT);
 pinMode(captgauche, INPUT);

}

// loop : programme en boucle
void loop()
{
if (digitalRead(captdroit) == HIGH) {
recularret ();
retournegauche ();
} else if (digitalRead(captgauche) == HIGH) {
recularret ();
retournedroit (); // dit au servo gauche de prendre la position 0
} else avance();
}


void avance()
{
servod.write(180);   // dit au servo droit de prendre la position 180
servog.write(0);     // dit au servo gauche de prendre la position 0
delay(300);         // attendre 5000 ms (5s)
}

void recularret()
{
servod.write(99);
servog.write(101);
   delay(200);
servod.write(0);
servog.write(180);
   delay(1000);
}

void retournegauche()
{
servod.write(180);
servog.write(180);
   delay(600);    
}

void retournedroit()
{
servod.write(0);
servog.write(0);
   delay(600);    
}

Aucun commentaire:

Enregistrer un commentaire