Archives par étiquette : arduino 2560

Joy-it : KY-053 Convertisseur analogique digital

Mise à jour le 29/01/2020 : Rubrique traitant du module à 4 canaux permet de mesurer des tensions analogiques avec une précision de 16 bits. Il est basé sur un ADS1115 et communique avec un microcontrôleur via le bus I2C.

Continuer la lecture →

Grove : capteur Lidar de chez Seeedstudio ref-14991434

–

Mise à jour le 31/01/2018 – Rubrique traitant du capteur Lidar de chez Seeedstudio permettant de mesurer des distances de 0,3 à 12 mètres. Ce module communique avec un microcontrôleur type Arduino ou compatible via une liaison série TTL.

Capteur Grove Lidar 114991434

Sommaire :

Description du capteur Lidar de chez Seeedstudio
Logiciel – information constructeur –
en cours de réalisations
Retour au menu principal

Description du capteur Lidar de chez Seeedstudio

Caractéristiques et spécificités

Plage de tension applicable : de 4.5V à 6V
Consommation moyenne: 6 W
Plage de mesure: 0,3 à 12 mètres
Précision:
- moins de 6 m: 1 %
- entre 6 et 12 m: 2 %
Plage de fonctionnement maximale à 10% de réflectivité : 5m
Angle d’acceptation : 2.3°
Fréquence de mesure: jusqu’à 100 Hz
Résolution: 1 cm
Longueur d’onde: 850 nm
Interface: série TTL / UART 115200
Niveau de tension TTL du port série : 3,3 V
Courant de crête de LED : 800 mA
Température de service: – 20 à 60 °C
Sensibilité à la lumière : 70 000 lux
Dimensions: 45 x 15x 16 mm
Poids: 5 g
Compatibilité électromagnétique (CEM) : EN 55032 Classe B
Référence Seeedstudio: 114991434

La mesure de distance est basée sur la méthode Time-Of-Flight ce qui permet de mesurer précisément les distances grâce à des impulsions infrarouges.

ToF est l’abréviation de la technologie Time of Flight, et son principe de fonctionnement est le suivant: une lumière infrarouge modulée est émise par le capteur et réfléchie par un objet; la distance à l’objet à photographier peut être convertie avec le capteur en calculant la différence de temps ou la différence de phase entre l’émission de lumière et la réflexion de la lumière, de façon à produire l’information de profondeur.

Remarque: ce module doit être raccordé à un port série physique d’une carte Arduino. Les cartes basés sur un ATMega328 (Uno par exemple) ne possèdent qu’un seul port série physique, l’utilisation de ce capteur supprime la possibilité d’un retour sur le moniteur série et nécessite l’utilisation d’un écran LCD par exemple. Pour un retour sur le moniteur série, vous devez utilisez par exemple une carte Arduino Mega ou Seeeduino Lite qui comportent plusieurs ports série physiques.

Informations constructeur sur : http://wiki.seeed.cc/Grove-TF_Mini_LiDAR/

Retour au sommaire .

Logiciel – information constructeur –

en cours

Octet	Interprétation de l’encodage des données
Byte1	0x59, en-tête de trame
Byte2	0x59, en-tête de trame
Byte3
Byte4
Byte5
Byte6
Byte7	Temps d’intégration.
Byte8	Octets réservés
Byte9	Parité de somme de contrôle

Retour au sommaire .

A savoir sur l’utilisation des informations :

Les informations sur les caractéristiques et spécificités du capteur lidar qui sont fournis sur cette page correspondent aux informations des fiches techniques du constructeur si malgré le soin apporté à la réalisation de cet article une erreur s’est glissée dans ces lignes nous ne pourrions en être tenu responsable.

Les programmes , schémas et autres que ceux donnés par le constructeur font parti des montages utiles à nos applications si malgré le soin apporté à nos montages une erreur s’est glissée dans ces lignes nous ne pourrions en être tenu responsable .

L’ensemble des informations techniques de cet article a été utilisé pour nos applications, elles vous sont fournies comme un exemple de document de travail. Mais nous ne pourrions être tenu responsables d’une mauvaise utilisation de celle-ci.

Retour au sommaire .

Support 3 axes

Mise à jour le 20/09/2019 : C’est un support trois axes qui pourrait utiliser pour différentes réalisations. L’ensemble de ce projet a été réalisé pour que certaines pièces comme les cages des servomoteurs soient réutilisé dans d’autres applications.

Sommaire :

Présentation du projet .
Tutoriel de montage en photo .
1. Montage du servomoteur dans la base .
2. Montage du Palonnier type roue sur la cage .
3. Assemblage de la cage sur le servomoteur de la base .
4. Montage du servo porte bras .
5. Assemblage du bras .
6. Assemblage de la partie haute.
Ensemble des fichiers pour l’impression 3D.
1. Base du support 3 axes.
2. Cage support pour servomoteur partie bas .
3. Bras du support 3 axes
4. Cage pour servomoteur partie haute
5. Support supérieure
Programme pour tester les limites mini et maxi du support 3 axes
Schéma de branchement de l’ensembles des actionneurs et potentiomètre .
1. Montage avec une carte Arduino Mega 2560.
  1. Liste du matériel câblage classique .
  2. Liste du matériel avec utilisation du matériel Grove
  3. Schéma électrique de principe
  4. Exemple de programme sur Arduino Mega
2. Montage avec une carte Arduino Uno ( en cours )
  1. Exemple de programme sur Arduino Uno
  2. Liste du matériel avec utilisation du matériel Grove
  3. Schéma électrique de principe .
  4. Exemple de programme sur Arduino Uno
Retour au menu nos robots

Présentation du projet .

.

Vue

C’est un support trois axes qui pourrait utiliser pour différentes réalisations. L’ensemble de ce projet a été réalisé pour que certaines pièces comme les cages des servomoteurs soient réutilisé dans d’autres applications.

Retour au sommaire

Tutoriel de montage en photo .

1: Montage du servomoteur HS-422 dans sa base .

Nous pouvons aussi utiliser le servomoteur Hitec HS-645 MG en sachant que les 2 servo ne possèdent pas le même couple . Nous avons un couple de 4.7kg.cm pour le HS-422 et de 9.6kg.cm pour le HS-645 MG .

Montage du servomoteur HS-422 dans sa base

Montage du servomoteur HS-422 dans sa base (fig 2)

Montage du servomoteur HS-422 dans sa base (fig 3)

Retour au sommaire

2:Montage du Palonnier type roue sur la cage support du servomoteur ( en général ce type de palonnier est vendu avec son servo ) .

RedOhm : Montage du palonnier

Retour au sommaire

3:Assemblage de la cage sur le servomoteur de la base .

Redohm : On passe un petit tournevis dans l’orifice de la cage porte servo prévu pour ce type de montage

Redohm : Vue en gros plan

Retour au sommaire

4:Montage du servo porte bras .

Redohm : Montage du servo porte bras

Retour au sommaire

5:Assemblage du bras et montage du Palonnier type roue dans le bras ( en général ce type de palonnier est vendu avec son servo ) .

Redohm : Vue du bras fig.10

Redohm : Vue du bras fig.11

RedOhm : Montage du palonnier fig.20

RedOhm : Montage du palonnier fig.21

Redohm: Montage de l’ensemble fig.22

Redohm:Vue d’ensemble fig.23

Retour au sommaire

6:Assemblage de la partie haute .

Redohm:Support haut fig.60

Redohm: Support servomoteur superieur fig.61

Redohm : Vue d’ensemble fig.62

Redohm : Vue d’ensemble avec servomoteur et support fig.63

Redohm : Vue d’ensemble avec servomoteur et support fig.64

Retour au sommaire

Ensemble des fichiers pour l’impression 3D.

Piece 001 : Base du support 3 axes

Piece 001 : Base pour support 3 axes

Temps d’impression pour un remplissage de 30% ⇒ 7h21mm
Matière : PLA 120.01g
Résolution : 0.2mm

Télechargement de : Piece 001-Base du support 3 axes

Retour au sommaire

Piece 002 : Cage support servomoteur partie bras

Temps d’impression pour un remplissage de 30% ⇒ 1h17mm.
Matière : PLA 16.62g (0.037lb)
Résolution : 0.2mm

Télechargement de : Pièce 002-Cage servomoteur partie bras

Retour au sommaire

Piece 003 : Bras du support 3 axes

Bras pour support 3 axes

Temps d’impression pour un remplissage de 30% ⇒ 2h57mm
Matière : PLA 46.54g (0.103lb)
Résolution : 0.2mm

Télechargement de : Pieces 003-Bras pour support 3 axes

Retour au sommaire

Piece 004 : Cage pour servomoteur partie haute

Piece 004 – Cage pour servomoteur partie haute

Temps d’impression pour un remplissage de 30% ⇒ 1h06mm
Matière : PLA 14.43g (0.023lb)
Résolution : 0.2mm

Télechargement de : Piece 004-Cage servomoteur partie haute

Retour au sommaire

Piece 005 : Support supérieure

Piece 005- Support supérieure fig 005.1

Temps d’impression pour un remplissage de 30% ⇒ 00h21mm
Matière : PLA 6.64g (0.015lb)
Résolution : 0.2mm

Télechargement de : Piece 005-Support supérieure

Retour au sommaire

Programme pour tester les limites mini et maxi du support 3 axes

//
//
//

/*
 * RedOhm
 * 
 * 
 * Essai et reglage des servomoteurs a l'aide 
 * d'un potentiometre en vue de determiner les 
 * limites min et max 
 *              
 * Le 27/08/2016
 * H.Mazelin              
 */





// Cette librairie permet à une carte Arduino de contrôler des servomoteurs
#include &lt;Servo.h&gt;

 
// Crée un objet de type "Servo", nommé -&gt; monservo
Servo monservo;
// broche sur lequel est branche le potentiometre
int brochepotar_de_position=2;
// variable contenant la valeur de la potentiometre 
int valeur_potar_position;



/*
 *  Un programme Arduino doit impérativement contenir cette fonction 
 *  Elle ne sera exécuter une seule fois au démarrage du microcontroleur
 *  Elle sert à configurer globalement les entrées sorties
 *  
 */


void setup() {
  Serial.begin(9600);
// associe le servomoteur a la broche 3   
  monservo.attach(3); 
 
}


/*
 *Le programme principal s’exécute par une boucle infinie appelée Loop () 
 * 
 */
 

void loop() {
 // lecture de la valeur du potentiomètre (valeur entre 0 et 1023)  
  valeur_potar_position=analogRead( brochepotar_de_position); 
// mise a l'échelle (valeur entre 5 et 180)
// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position=map(valeur_potar_position,0,1023,5,180);
// définit la position d'asservissement du servomoteur 
// en fonction de la valeur à l'échelle  
  monservo.write(valeur_potar_position);
  Serial.println(valeur_potar_position);
// Réalise une pause dans l'exécution du programme pour une durée 
// de 20 millisecondes
// permettant au servomteur d'atteindre sa position  
  delay(20);
}

* RedOhm

* Essai et reglage des servomoteurs a l'aide

* d'un potentiometre en vue de determiner les

* limites min et max

* Le 27/08/2016

* H.Mazelin

// Cette librairie permet à une carte Arduino de contrôler des servomoteurs

#include <Servo.h>

// Crée un objet de type "Servo", nommé -> monservo

Servo monservo;

// broche sur lequel est branche le potentiometre

int brochepotar_de_position=2;

// variable contenant la valeur de la potentiometre

int valeur_potar_position;

* Un programme Arduino doit impérativement contenir cette fonction

* Elle ne sera exécuter une seule fois au démarrage du microcontroleur

* Elle sert à configurer globalement les entrées sorties

void setup() {

Serial.begin(9600);

// associe le servomoteur a la broche 3

monservo.attach(3);

}

*Le programme principal s’exécute par une boucle infinie appelée Loop ()

void loop() {

// lecture de la valeur du potentiomètre (valeur entre 0 et 1023)

valeur_potar_position=analogRead( brochepotar_de_position);

// mise a l'échelle (valeur entre 5 et 180)

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position=map(valeur_potar_position,0,1023,5,180);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

monservo.write(valeur_potar_position);

Serial.println(valeur_potar_position);

// Réalise une pause dans l'exécution du programme pour une durée

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

}

Retour au sommaire

Schéma de branchement de l’ensembles des actionneurs et potentiomètre .

1:Montage avec une carte Arduino Mega 2560

a) Liste du materiel pour câblage classique.

3 potentiomètre de 10kΩ
3 servomoteurs Hitec référence HS-645MG ou Hitec HS422
1 carte Arduino Mega 2560
1 alimentation variable régler a 6 Volt ou une alimentation fixe 6V
1 Alimentation pour la carte micro ( alimentation de 7 à 12 V sur connecteur alim = vin tension positive en entrée ne pas oublier la masse à brancher sur la pin Gnd ).Si on utilise plus de 12V, le régulateur de tension de la carte pourrait chauffer et en cascade détruire la carte )

b) Liste du matériel avec utilisation du matériel Grove :

1 Module Grove Mega Shield V1.2 référence -> 103020027 .Le module Grove Base Shield est une carte d’interface permettant de raccorder facilement, rapidement et sans soudure les capteurs et les actionneurs Grove de Seeedstudio sur une carte compatible Arduino.
3 Potentiomètre à glissière Grove 101020036 ou potentiomètre rotatif Grove 101020048
3 servomoteurs Hitec référence HS-645MG ou Hitec HS422
1 carte Arduino Mega 2560
1 alimentation variable régler a 6 Volt ou une alimentation fixe 6V
1 Alimentation pour la carte micro ( alimentation de 7 à 12 V sur connecteur alim = vin tension positive en entrée ne pas oublier la masse à brancher sur la pin Gnd ) .Si on utilise plus de 12V, le régulateur de tension de la carte pourrait chauffer et en cascade détruire la carte )

c) Schéma électrique de principe.

: Redohm : Schéma avec un Arduino Mega cliquez sur le dessin pour l’agrandir

d) Exemple de programme sur Arduino Mega

 /*
  *
  *
  *
  *RedOhm 
  *
  *
  *Programme pour piloter separement chaque moteur du support
  *trois axes
  *
  *le 27/08/2016
  *        H-Mazelin
  */
 
 
 




// Cette librairie permet à une carte Arduino de contrôler des servomoteurs
#include <Servo.h>

// Crée un objet de type "Servo" pour la rotation de la base, nommé -> servobase
Servo servobase;
// Crée un objet de type "Servo" pour l'elevation du bras, nommé -> servobras
Servo servobras;
// Crée un objet de type "Servo" pour la rotation de la tete, nommé -> servotete
Servo servotete;
// broche sur lequel est branche le potentiometre servant a piloter le servobase
int brochepotar_de_position_servobase=0;
// variable contenant la valeur du potentiometre pour le servobase
int valeur_potar_position_du_servobase; 

// broche sur lequel est branche le potentiometre servant a piloter le servobras
int brochepotar_de_position_servobras=2;
// variable contenant la valeur du potentiometre pour le servobras
int valeur_potar_position_du_servobras; 

// broche sur lequel est branche le potentiometre servant a piloter le servotete
int brochepotar_de_position_servotete=4;
// variable contenant la valeur du potentiometre pour le servotete
int valeur_potar_position_du_servotete; 

 /*
 *  Un programme Arduino doit impérativement contenir cette fonction 
 *  Elle ne sera exécuter une seule fois au démarrage du microcontroleur
 *  Elle sert à configurer globalement les entrées sorties
 *  
 */

void setup() {
  //  initialisation de la connexion série
  // IMPORTANT : la fenêtre terminal côté PC doit être réglée sur la même valeur
  Serial.begin(9600);
  // associe le servomoteur servobase a la broche 3   
  servobase.attach(3);
  // associe le servomoteur servobras a la broche 4   
  servobras.attach(4);
  // associe le servomoteur servotete a la broche 5   
  servotete.attach(5);
  Serial.println("**********************************");
  Serial.println("*                                *");
  Serial.println("*support 3 axes                  *");
  Serial.println("*              operationnel      *");
  Serial.println("*                                *");
  Serial.println("**********************************");
  Serial.println("                                  ");
  //pause presentation
  delay (5000);
}



// Le programme principal s’exécute par une boucle infinie appelée Loop () 



void loop() {

/*
 * 
 * traitement pour la position de la base
 */


  
  // lecture de la valeur du potentiomètre (valeur entre 0 et 1023)  
  valeur_potar_position_du_servobase=analogRead( brochepotar_de_position_servobase); 
// mise a l'échelle (valeur entre 5 et 180)
// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position_du_servobase=map(valeur_potar_position_du_servobase,0,1023,5,180);
// définit la position d'asservissement du servomoteur 
// en fonction de la valeur à l'échelle  
  servobase.write(valeur_potar_position_du_servobase);
// affiche le texte d'information sans retour a la ligne 
  Serial.print("position actuelle de la base ->  ");
// affiche la valeur de la position de la base avec retour a la ligne    
  Serial.println(valeur_potar_position_du_servobase);
// Réalise une pause dans l'exécution du programme pour une durée 
// de 20 millisecondes
// permettant au servomteur d'atteindre sa position  
  delay(20);


/*
 * 
 * traitement pour la position du bras
 */


  
  // lecture de la valeur du potentiomètre (valeur entre 0 et 1023)  
  valeur_potar_position_du_servobras=analogRead(brochepotar_de_position_servobras); 
// mise a l'échelle (valeur entre 5 et 180)
// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position_du_servobras=map(valeur_potar_position_du_servobras,0,1023,54,120);
// définit la position d'asservissement du servomoteur 
// en fonction de la valeur à l'échelle  
  servobras.write(valeur_potar_position_du_servobras);
// affiche le texte d'information sans retour a la ligne 
  Serial.print("position actuelle du bras ->  ");
// affiche la valeur de la position du bras avec retour a la ligne       
  Serial.println(valeur_potar_position_du_servobras);
// Réalise une pause dans l'exécution du programme pour une durée 
// de 20 millisecondes
// permettant au servomteur d'atteindre sa position  
  delay(20);


/*
 * 
 * traitement pour la position de la tete
 */


  
  // lecture de la valeur du potentiomètre (valeur entre 0 et 1023)  
   valeur_potar_position_du_servotete=analogRead(brochepotar_de_position_servotete); 
// mise a l'échelle (valeur entre 5 et 180)
// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
   valeur_potar_position_du_servotete=map( valeur_potar_position_du_servotete,0,1023,5,180);
// définit la position d'asservissement du servomoteur 
// en fonction de la valeur à l'échelle  
   servotete.write( valeur_potar_position_du_servotete);
// affiche le texte d'information sans retour a la ligne
   Serial.print("position actuelle de la tete ->  ");
// affiche la valeur de la position de la tete avec retour a la ligne    
   Serial.println( valeur_potar_position_du_servotete);
// Réalise une pause dans l'exécution du programme pour une durée 
// de 20 millisecondes
// permettant au servomteur d'atteindre sa position  
  delay(20);

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

*RedOhm

*Programme pour piloter separement chaque moteur du support

*trois axes

*le 27/08/2016

* H-Mazelin

// Cette librairie permet à une carte Arduino de contrôler des servomoteurs

#include <Servo.h>

// Crée un objet de type "Servo" pour la rotation de la base, nommé -> servobase

Servo servobase;

// Crée un objet de type "Servo" pour l'elevation du bras, nommé -> servobras

Servo servobras;

// Crée un objet de type "Servo" pour la rotation de la tete, nommé -> servotete

Servo servotete;

// broche sur lequel est branche le potentiometre servant a piloter le servobase

int brochepotar_de_position_servobase=0;

// variable contenant la valeur du potentiometre pour le servobase

int valeur_potar_position_du_servobase;

// broche sur lequel est branche le potentiometre servant a piloter le servobras

int brochepotar_de_position_servobras=2;

// variable contenant la valeur du potentiometre pour le servobras

int valeur_potar_position_du_servobras;

// broche sur lequel est branche le potentiometre servant a piloter le servotete

int brochepotar_de_position_servotete=4;

// variable contenant la valeur du potentiometre pour le servotete

int valeur_potar_position_du_servotete;

* Un programme Arduino doit impérativement contenir cette fonction

* Elle ne sera exécuter une seule fois au démarrage du microcontroleur

* Elle sert à configurer globalement les entrées sorties

void setup() {

// initialisation de la connexion série

// IMPORTANT : la fenêtre terminal côté PC doit être réglée sur la même valeur

Serial.begin(9600);

// associe le servomoteur servobase a la broche 3

servobase.attach(3);

// associe le servomoteur servobras a la broche 4

servobras.attach(4);

// associe le servomoteur servotete a la broche 5

servotete.attach(5);

Serial.println("**********************************");

Serial.println("* *");

Serial.println("*support 3 axes *");

Serial.println("* operationnel *");

Serial.println("* *");

Serial.println("**********************************");

Serial.println(" ");

//pause presentation

delay (5000);

}

// Le programme principal s’exécute par une boucle infinie appelée Loop ()

void loop() {

* traitement pour la position de la base

// lecture de la valeur du potentiomètre (valeur entre 0 et 1023)

valeur_potar_position_du_servobase=analogRead( brochepotar_de_position_servobase);

// mise a l'échelle (valeur entre 5 et 180)

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_du_servobase=map(valeur_potar_position_du_servobase,0,1023,5,180);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servobase.write(valeur_potar_position_du_servobase);

// affiche le texte d'information sans retour a la ligne

Serial.print("position actuelle de la base -> ");

// affiche la valeur de la position de la base avec retour a la ligne

Serial.println(valeur_potar_position_du_servobase);

// Réalise une pause dans l'exécution du programme pour une durée

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

* traitement pour la position du bras

// lecture de la valeur du potentiomètre (valeur entre 0 et 1023)

valeur_potar_position_du_servobras=analogRead(brochepotar_de_position_servobras);

// mise a l'échelle (valeur entre 5 et 180)

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_du_servobras=map(valeur_potar_position_du_servobras,0,1023,54,120);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servobras.write(valeur_potar_position_du_servobras);

// affiche le texte d'information sans retour a la ligne

Serial.print("position actuelle du bras -> ");

// affiche la valeur de la position du bras avec retour a la ligne

Serial.println(valeur_potar_position_du_servobras);

// Réalise une pause dans l'exécution du programme pour une durée

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

* traitement pour la position de la tete

// lecture de la valeur du potentiomètre (valeur entre 0 et 1023)

valeur_potar_position_du_servotete=analogRead(brochepotar_de_position_servotete);

// mise a l'échelle (valeur entre 5 et 180)

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_du_servotete=map( valeur_potar_position_du_servotete,0,1023,5,180);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servotete.write( valeur_potar_position_du_servotete);

// affiche le texte d'information sans retour a la ligne

Serial.print("position actuelle de la tete -> ");

// affiche la valeur de la position de la tete avec retour a la ligne

Serial.println( valeur_potar_position_du_servotete);

// Réalise une pause dans l'exécution du programme pour une durée

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

}

Retour au sommaire

2:Montage avec une carte Arduino Uno

Liste du materiel :

3 potentiomètre de 10kΩ
3 servomoteurs Hitec référence HS-645MG ou Hitec HS422
1 carte Arduino Uno
1 alimentation variable régler a 6 Volt ou une alimentation fixe 6V
1 Alimentation pour la carte micro ( alimentation de 7 à 12 V sur connecteur alim = vin tension positive en entrée ne pas oublier la masse à brancher sur la pin Gnd ).Si on utilise plus de 12V, le régulateur de tension de la carte pourrait chauffer et en cascade détruire la carte )

Liste du matériel avec utilisation du matériel Grove :

1 Module Grove Base Shield 103030000 . Le module Grove Base Shield est une carte d’interface permettant de raccorder facilement, rapidement et sans soudure les capteurs et les actionneurs Grove de Seeedstudio sur une carte compatible Arduino.
3 Potentiomètre à glissière Grove 101020036 ou potentiomètre rotatif Grove 101020048 .
3 servomoteurs Hitec référence HS-645MG ou Hitec HS422 .
1 Carte arduino Uno
1 alimentation variable régler a 6 Volt ou une alimentation fixe 6V .
1 Alimentation pour la carte micro ( alimentation de 7 à 12 V sur connecteur alim = vin tension positive en entrée ne pas oublier la masse à brancher sur la pin Gnd ).Si on utilise plus de 12V, le régulateur de tension de la carte pourrait chauffer et en cascade détruire la carte )