Servomoteur à rotation continue

–

Mise à jour le 21/11/2019 : Dans cet article, vous trouverez toutes les informations nécessaires pour l’utilisation des servomoteurs à rotation continue. De nombreux programmes , en particulier pour les cartes Arduino , seront développés pour l’utilisation de ses servo, vous trouverez aussi les schémas électriques et les documentations techniques nécessaires pour réaliser éventuellement vos projets.

Sommaire :

Rappel du fonctionnement des servomoteurs à rotation continue.
Programme d’évaluation d’une rampe d’accélération automatique pour servomoteur a rotation continue.
- Tutoriel sur la création d’une rampe d’acceleration ( vidéo )
- Explication d’une rampe d’accélération par le dessin .
- Programme sur Arduino.
Programme de pilotage de 2 servomoteurs à rotation continue pour la traction d’un robot mobile.
Pour tout probléme
Retour au sommaire de l’article sur les servomoteurs.

Retour au sommaire

Rappel du fonctionnement des servomoteurs à rotation continue

Les servomoteurs à rotation continue se pilote de la même façon que les servomoteurs standards au moyen d’un signal « PWM » (avec des impulsions « hautes » comprises entre 1 à 2 ms env.).

Ces impulsions pourront être générées par un module arduino, Bluno Mega1280 etc …

Ne disposant d’aucune butée, ce servomoteur tourner dans les 2 sens de façon continue. Ainsi pour une largeur d’impulsion de l’ordre de 1,5 ms à son entrée, le servomoteur sera à l’arrêt.

Lorsque vous augmentez la largeur des impulsions, le servomoteur commencera à tourner dans un sens. Le servomoteur tourne de plus en plus vite au fur et à mesure que la largeur des impulsions d’approche des 2 ms (pour laquelle le servomoteur tournera alors à la vitesse max.).

Lorsque vous diminuez la largeur des impulsions (par rapport à la position médiane 1,5 ms), le servomoteur commencera à tourner dans l’autre sens. Le servomoteur tourne de plus en plus vite au fur et à mesure que la largeur des impulsions d’approche des 1 ms (pour laquelle le servomoteur tournera alors à la vitesse max.).

Quelques références de servomoteurs à rotation continue.

Hitec HSR-1425 vitesse max => 52 t/mm sous 6Vcc chez Lextronic
- Couple 3.1 Kg/cm sous 6Vcc
Feetech FS5103R vitesse max => 64 t/mm sous 6Vcc chez Gotronic
- Couple 3.2 Kg/cm sous 6Vcc
Feetech FS5113R vitesse max => 64 t/mm sous 6Vcc chez Gotronic
- Couple 14 kg/cm sous 6 Vcc

Retour au sommaire

Programme d’évaluation d’une rampe d’accélération automatique pour servomoteur a rotation continue

Dans cet article , nous allons traiter tout particulièrement des rampes d’accélération pour les servomoteurs à rotation continue. Ce genre de petit programme est très utile lorsqu’on veut éviter que les roues de vos robots patinent au démarrage. Vous trouverez ci-dessous le tutoriel vidéo de l’explication des rampes d’accélération mais aussi des schémas ,des illustrations techniques et le programme utilisé pour ce tuto.

Matériel nécessaire pour ce tuturiel :

Une carte Arduino Mega 2560 : est basée sur un ATMega2560 cadencé à 16 MHz. Elle dispose de 54 E/S dont 14 PWM, 16 analogiques et 4 UARTs.
Module Grove Mega Shield V1.2 103020027 : Le module Grove Mega Shield est une carte d’interface permettant de raccorder facilement sans soudure les capteurs et les actionneurs Grove de Seeedstudio sur une carte compatible Arduino Mega.
Servomoteur Feetech FS5113R à rotation sur 360° disposant d’un couple élevé et d’une pignonnerie métallique. Livré avec palonniers et vis de montage.

Rampe d’accélération pour servomoteur à rotation continue – RedOhm –

–

/*
 * 
 * 
 * RedOhm
 * 
 * Programme evaluation d'une rampe d'acceleration automatique  
 * pour servomoteur a rotation continue 
 * 
 * Version ID arduino 1.8.4
 * 
 * Le 08/09/2018
 * H.Mazelin
 * 
 */

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

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


// Variable qui enregistre l'état du signal pour activer le servomoteur
// par defaut la valeur est fixée à 1500 ce qui correspond en general à l'arret
// du servomoteur ( pour un servomoteur à rotation continue )
int arret = 1500;

// variable vitesse et de direction pour le servomoteur 
int temps = 0;

// Declaration de la variable pour la rampe de demarrage
int valeur_de_vitesse_demarrage;


// Declaration de la variable pour la vitesse rampe de demarrage
// unsigned long-> déclare une variable de type long non signé
unsigned long rampedemarrage = millis();


/* 
 * Un programme Arduino doit impérativement contenir cette fonction .
 * Elle ne sera exécutée qu'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 la variable rouedroite a sa broche en autre la numero 3   
  rouedroite.attach(3);

 // Écrit une valeur en microsecondes (uS) sur le servo, 
 // la valeur par defaut etant 1500 ce qui correspond en
 // general à l'arret
 rouedroite.writeMicroseconds(arret);   
 

}

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

 // valeur de la base de temps 1 -> 1000ms soit 1 seconde
 // la ligne if  effectue la difference entre le temps actuel et le 
 // temps de debut de boucle .Cette derniere n'est interrompue que lorsque 
 // cette différence = 100 millisecondes  
 if ((millis ()-rampedemarrage>100)& ( valeur_de_vitesse_demarrage <= 100))
 
 {
 rampedemarrage=millis();
 // incrementation de la variable valeur de 1 soit -> valeur = valeur+1
 valeur_de_vitesse_demarrage ++;
 
 Serial.print("valeur de la vitesse de demarrage =>"); 
 Serial.print(valeur_de_vitesse_demarrage);
 Serial.print(" valeur de la pente de demarrage =>");
 Serial.println(temps);
 }



 temps= valeur_de_vitesse_demarrage + arret ;  
 // envoie de la valeur au servomoteur pour la rotation ou l'arret
 rouedroite.writeMicroseconds(temps);

 


}

* RedOhm

* Programme evaluation d'une rampe d'acceleration automatique

* pour servomoteur a rotation continue

* Version ID arduino 1.8.4

* Le 08/09/2018

* H.Mazelin

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

#include <Servo.h>

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

Servo rouedroite;

// Variable qui enregistre l'état du signal pour activer le servomoteur

// par defaut la valeur est fixée à 1500 ce qui correspond en general à l'arret

// du servomoteur ( pour un servomoteur à rotation continue )

int arret = 1500;

// variable vitesse et de direction pour le servomoteur

int temps = 0;

// Declaration de la variable pour la rampe de demarrage

int valeur_de_vitesse_demarrage;

// Declaration de la variable pour la vitesse rampe de demarrage

// unsigned long-> déclare une variable de type long non signé

unsigned long rampedemarrage = millis();

* Un programme Arduino doit impérativement contenir cette fonction .

* Elle ne sera exécutée qu'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 la variable rouedroite a sa broche en autre la numero 3

rouedroite.attach(3);

// Écrit une valeur en microsecondes (uS) sur le servo,

// la valeur par defaut etant 1500 ce qui correspond en

// general à l'arret

rouedroite.writeMicroseconds(arret);

}

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

void loop() {

// valeur de la base de temps 1 -> 1000ms soit 1 seconde

// la ligne if effectue la difference entre le temps actuel et le

// temps de debut de boucle .Cette derniere n'est interrompue que lorsque

// cette différence = 100 millisecondes

if ((millis ()-rampedemarrage>100)& ( valeur_de_vitesse_demarrage <= 100))

{

rampedemarrage=millis();

// incrementation de la variable valeur de 1 soit -> valeur = valeur+1

valeur_de_vitesse_demarrage ++;

Serial.print("valeur de la vitesse de demarrage =>");

Serial.print(valeur_de_vitesse_demarrage);

Serial.print(" valeur de la pente de demarrage =>");

Serial.println(temps);

}

temps= valeur_de_vitesse_demarrage + arret ;

// envoie de la valeur au servomoteur pour la rotation ou l'arret

rouedroite.writeMicroseconds(temps);

}

Retour au sommaire .

–

Programme de pilotage de 2 servomoteurs à rotation continue pour la traction d’un robot mobile

–

Matériel nécessaire pour ce tuturiel :

Une carte Arduino Mega 2560 : est basée sur un ATMega2560 cadencé à 16 MHz. Elle dispose de 54 E/S dont 14 PWM, 16 analogiques et 4 UARTs.
Module Grove Mega Shield V1.2 103020027 : Le module Grove Mega Shield est une carte d’interface permettant de raccorder facilement sans soudure les capteurs et les actionneurs Grove de Seeedstudio sur une carte compatible Arduino Mega.
Servomoteur Feetech FS5113R à rotation sur 360° disposant d’un couple élevé et d’une pignonnerie métallique.
- ou
Servomoteur FS5103R à rotation continue
- ou
Servomoteur HSR1425CR à rotation continue

FS5113R	FS5103R	HSR1425CR
Alimentation : 4,8 à 6 Vcc. Course : 360° Couple : 14 kg.cm à 6 Vcc Vitesse à vide : 64 t/min à 6 Vcc Dimensions : 41 x 20 x 38 mm Poids : 56 gr.	Alimentation : 4,8 à 6 Vcc. Course : 360° Couple : 3,2 kg.cm à 6 Vcc Vitesse : 64 t/min en 6 Vcc Dimensions: 41 x 20 x 38 mm Poids: 46 gr	Alimentation : 4,8 à 6 Vcc. Course : 360°. Couple: 2,8 kg.cm. Vitesse : 43 t/min. Dimensions : 41 x 20 x 36 mm. Poids : 40 gr.

Commande disponible dans ce programme =>

a : Arrêt des servomoteurs
c : Démarrage en marche avant avec rampe d’accélération
v : Démarrage en marche arrière avec rampe d’accélération

/*
 * 
 * 
 * RedOhm
 * 
 * Programme de pilotage de 2 servomoteurs à rotation continue  
 * au menu mise en service de rampe d'acceleration , rotation   
 * avant et arriere , et pilotage de l'ensemble par 
 * clavier 
 *    
 * Peut être utilisé pour le deplacement d'un robot mobile
 * 
 * Version ID arduino 1.8.4
 * 
 * Le 14/09/2018
 * H.Mazelin
 * 
 */

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

// Crée un objet de type "Servo", nommé -> rouedroite
Servo rouedroite;
// Crée un objet de type "Servo", nommé -> rouegauche
Servo rouegauche;


// Variable qui enregistre l'état du signal pour activer le servomoteur
// par defaut la valeur est fixée à 1500 ce qui correspond en general à l'arret
// du servomoteur ( pour un servomoteur à rotation continue )
int arret = 1500;

// variable vitesse et de direction pour le servomoteur droit
int tempsdroite;
// variable vitesse et de direction pour le servomoteur gauche
int tempsgauche;

// Declaration de la variable pour la rampe de demarrage
int valeur_de_vitesse_demarrage;



// Declaration de la variable pour la vitesse rampe de demarrage
// unsigned long-> déclare une variable de type long non signé
unsigned long rampedemarrage = millis();


/* 
 * Un programme Arduino doit impérativement contenir cette fonction .
 * Elle ne sera exécutée qu'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 du terminal côté PC doit être réglée sur la même valeur.  
  Serial.begin(9600);
  Serial.println("*===========================================================*");
  Serial.println("*                                                           *");
  Serial.println("*Programme pour piloter                                     *");
  Serial.println("* 2 servomoteurs à rotation continue                        *");
  Serial.println("*                                                           *");
  Serial.println("*Fonctions disponibles                                      *");
  Serial.println("* a = arret des moteurs                                     *");
  Serial.println("* c = demarrage en marche avant avec rampe d'accélération   *");
  Serial.println("* v = demarrage en marche arriere avec rampe d'accélération *");
  Serial.println("*===========================================================*");

  // associe la variable rouedroite à sa broche numero 3   
  rouedroite.attach(3);
    // associe la variable rouegauche à sa broche numero 5 
  rouegauche.attach(5);

 // Écrit une valeur en microsecondes (uS) sur le servo, 
 // la valeur par defaut etant 1500 ce qui correspond en
 // general à l'arret
 rouedroite.writeMicroseconds(arret);  
  rouegauche.writeMicroseconds(arret);  
 

}

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


 
  

  //Obtenez le nombre d'octets (caractères) disponibles pour 
  //la lecture du port série.
  //dans notre cas soit la lettre w ou x ou a pour arret 
  //ou r pour arriere ou v pour avant  
 if(Serial.available())
  { 
  char commande = Serial.read();
 
  if (commande == 'a')
  
    // demande d'arret  
    {
    valeur_de_vitesse_demarrage = 0;
    Serial.println("Demande d'arret"); 
    }

   // demande de demarrage avec rampe d'acceleration
   // et marche avant 
   else if (commande == 'c')
   {

   // forçage de la variable valeur_de_vitesse_demarrage a = 0
   valeur_de_vitesse_demarrage = 0 ;
   // Les boucles while bouclent indéfiniment, jusqu'à ce que la condition
   // ou l'expression entre les parenthèses ( ) devient fausse. Quelque chose
   // doit modifier la variable testée, sinon la boucle while ne se terminera 
   // jamais. Cela peut être dans votre code, soit une variable incrémentée
   // , ou également une condition externe
   // dans notre programme la variable testée = valeur_de_vitesse_demarrage
   while(valeur_de_vitesse_demarrage < 100)

    {

    // valeur de la base de temps 1 -> 1000ms soit 1 seconde
    // la ligne if  effectue la difference entre le temps actuel et le 
    // temps de debut de boucle .Cette derniere n'est interrompue que lorsque 
    // cette difference = 1000 millisecondes soit 1 seconde 
    if ((millis ()-rampedemarrage>50)& ( valeur_de_vitesse_demarrage <= 100))
 
     {
         rampedemarrage=millis();
         // incrementation de la variable valeur de 1 soit -> valeur = valeur+1
         valeur_de_vitesse_demarrage ++;
     
         // Affichage sur le moniteur serie des informations
         //
         Serial.print("valeur de la vitesse de demarrage =>"); 
         Serial.print(valeur_de_vitesse_demarrage);
         Serial.print(" valeur de la pente de demarrage a droite =>");
         Serial.print(tempsdroite);
         Serial.print("  ");
         Serial.println(tempsgauche);
         
         // calcul pour la marche avant pour la roue gauche avec acceleration
         tempsgauche = arret + valeur_de_vitesse_demarrage  ;
         // calcul pour la marche avant pour la roue droite avec acceleration
         tempsdroite = arret - valeur_de_vitesse_demarrage  ;  
         
         // envoie de la valeur au 2 servomoteurs pour le 
         // demarrage avec rampe d'acceleration 
         rouedroite.writeMicroseconds(tempsdroite);
         rouegauche.writeMicroseconds (tempsgauche);
 
     }

    } 
     
   }

   // demande de demarrage avec rampe d'acceleration
   // et marche arriere
   else if (commande == 'v')
   {
    
   // forçage de la variable a = 0
   valeur_de_vitesse_demarrage = 0 ;
   while(valeur_de_vitesse_demarrage < 100)

    {

    // valeur de la base de temps 1 -> 1000ms soit 1 seconde
    // la ligne if  effectue la difference entre le temps actuel et le 
    // temps de debut de boucle .Cette derniere n'est interrompue que lorsque 
    // cette difference = 1000 millisecondes soit 1 seconde 
    if ((millis ()-rampedemarrage>50)& ( valeur_de_vitesse_demarrage <= 100))
 
     {
         rampedemarrage=millis();
         // incrementation de la variable valeur de 1 soit -> valeur = valeur+1
         valeur_de_vitesse_demarrage ++;
     
         // Affichage sur le moniteur serie des informations
         //
         Serial.print("valeur de la vitesse de demarrage =>"); 
         Serial.print(valeur_de_vitesse_demarrage);
         Serial.print(" valeur de la pente de demarrage a droite =>");
         Serial.print(tempsdroite);
         Serial.print("  ");
         Serial.println(tempsgauche);
         
         // calcul pour la marche arriere pour la roue gauche avec acceleration
         tempsgauche = arret - valeur_de_vitesse_demarrage  ;
         // calcul pour la marche arriere pour la roue droite avec acceleration
         tempsdroite = arret + valeur_de_vitesse_demarrage  ;  
         
         // envoie de la valeur au 2 servomoteurs pour le 
         // demarrage avec rampe d'acceleration en marche arriere 
         rouedroite.writeMicroseconds(tempsdroite);
         rouegauche.writeMicroseconds (tempsgauche);
 
     }

    } 
     
   }

   
      
    }
  
 tempsgauche = arret + valeur_de_vitesse_demarrage  ; 
 tempsdroite = arret - valeur_de_vitesse_demarrage  ;  
 // envoie de la valeur au 2 servomoteurs pour 
 rouedroite.writeMicroseconds(tempsdroite);
    rouegauche.writeMicroseconds (tempsgauche);
 


}

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

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

* RedOhm

* Programme de pilotage de 2 servomoteurs à rotation continue

* au menu mise en service de rampe d'acceleration , rotation

* avant et arriere , et pilotage de l'ensemble par

* clavier

* Peut être utilisé pour le deplacement d'un robot mobile

* Version ID arduino 1.8.4

* Le 14/09/2018

* H.Mazelin

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

#include <Servo.h>

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

Servo rouedroite;

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

Servo rouegauche;

// Variable qui enregistre l'état du signal pour activer le servomoteur

// par defaut la valeur est fixée à 1500 ce qui correspond en general à l'arret

// du servomoteur ( pour un servomoteur à rotation continue )

int arret = 1500;

// variable vitesse et de direction pour le servomoteur droit

int tempsdroite;

// variable vitesse et de direction pour le servomoteur gauche

int tempsgauche;

// Declaration de la variable pour la rampe de demarrage

int valeur_de_vitesse_demarrage;

// Declaration de la variable pour la vitesse rampe de demarrage

// unsigned long-> déclare une variable de type long non signé

unsigned long rampedemarrage = millis();

* Un programme Arduino doit impérativement contenir cette fonction .

* Elle ne sera exécutée qu'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 du terminal côté PC doit être réglée sur la même valeur.

Serial.begin(9600);

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

Serial.println("* *");

Serial.println("*Programme pour piloter *");

Serial.println("* 2 servomoteurs à rotation continue *");

Serial.println("* *");

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

Serial.println("* a = arret des moteurs *");

Serial.println("* c = demarrage en marche avant avec rampe d'accélération *");

Serial.println("* v = demarrage en marche arriere avec rampe d'accélération *");

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

// associe la variable rouedroite à sa broche numero 3

rouedroite.attach(3);

// associe la variable rouegauche à sa broche numero 5

rouegauche.attach(5);

// Écrit une valeur en microsecondes (uS) sur le servo,

// la valeur par defaut etant 1500 ce qui correspond en

// general à l'arret

rouedroite.writeMicroseconds(arret);

rouegauche.writeMicroseconds(arret);

}

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

void loop() {

//Obtenez le nombre d'octets (caractères) disponibles pour

//la lecture du port série.

//dans notre cas soit la lettre w ou x ou a pour arret

//ou r pour arriere ou v pour avant

if(Serial.available())

{

char commande = Serial.read();

if (commande == 'a')

// demande d'arret

{

valeur_de_vitesse_demarrage = 0;

Serial.println("Demande d'arret");

}

// demande de demarrage avec rampe d'acceleration

// et marche avant

else if (commande == 'c')

{

// forçage de la variable valeur_de_vitesse_demarrage a = 0

valeur_de_vitesse_demarrage = 0 ;

// Les boucles while bouclent indéfiniment, jusqu'à ce que la condition

// ou l'expression entre les parenthèses ( ) devient fausse. Quelque chose

// doit modifier la variable testée, sinon la boucle while ne se terminera

// jamais. Cela peut être dans votre code, soit une variable incrémentée

// , ou également une condition externe

// dans notre programme la variable testée = valeur_de_vitesse_demarrage

while(valeur_de_vitesse_demarrage < 100)

{

// valeur de la base de temps 1 -> 1000ms soit 1 seconde

// la ligne if effectue la difference entre le temps actuel et le

// temps de debut de boucle .Cette derniere n'est interrompue que lorsque

// cette difference = 1000 millisecondes soit 1 seconde

if ((millis ()-rampedemarrage>50)& ( valeur_de_vitesse_demarrage <= 100))

{

rampedemarrage=millis();

// incrementation de la variable valeur de 1 soit -> valeur = valeur+1

valeur_de_vitesse_demarrage ++;

// Affichage sur le moniteur serie des informations

Serial.print("valeur de la vitesse de demarrage =>");

Serial.print(valeur_de_vitesse_demarrage);

Serial.print(" valeur de la pente de demarrage a droite =>");

Serial.print(tempsdroite);

Serial.print(" ");

Serial.println(tempsgauche);

// calcul pour la marche avant pour la roue gauche avec acceleration

tempsgauche = arret + valeur_de_vitesse_demarrage ;

// calcul pour la marche avant pour la roue droite avec acceleration

tempsdroite = arret - valeur_de_vitesse_demarrage ;

// envoie de la valeur au 2 servomoteurs pour le

// demarrage avec rampe d'acceleration

rouedroite.writeMicroseconds(tempsdroite);

rouegauche.writeMicroseconds (tempsgauche);

}

// demande de demarrage avec rampe d'acceleration

// et marche arriere

else if (commande == 'v')

{

// forçage de la variable a = 0

valeur_de_vitesse_demarrage = 0 ;

while(valeur_de_vitesse_demarrage < 100)

{

// valeur de la base de temps 1 -> 1000ms soit 1 seconde

// la ligne if effectue la difference entre le temps actuel et le

// temps de debut de boucle .Cette derniere n'est interrompue que lorsque

// cette difference = 1000 millisecondes soit 1 seconde

if ((millis ()-rampedemarrage>50)& ( valeur_de_vitesse_demarrage <= 100))

{

rampedemarrage=millis();

// incrementation de la variable valeur de 1 soit -> valeur = valeur+1

valeur_de_vitesse_demarrage ++;

// Affichage sur le moniteur serie des informations

Serial.print("valeur de la vitesse de demarrage =>");

Serial.print(valeur_de_vitesse_demarrage);

Serial.print(" valeur de la pente de demarrage a droite =>");

Serial.print(tempsdroite);

Serial.print(" ");

Serial.println(tempsgauche);

// calcul pour la marche arriere pour la roue gauche avec acceleration

tempsgauche = arret - valeur_de_vitesse_demarrage ;

// calcul pour la marche arriere pour la roue droite avec acceleration

tempsdroite = arret + valeur_de_vitesse_demarrage ;

// envoie de la valeur au 2 servomoteurs pour le

// demarrage avec rampe d'acceleration en marche arriere

rouedroite.writeMicroseconds(tempsdroite);

rouegauche.writeMicroseconds (tempsgauche);

}

tempsgauche = arret + valeur_de_vitesse_demarrage ;

tempsdroite = arret - valeur_de_vitesse_demarrage ;

// envoie de la valeur au 2 servomoteurs pour

rouedroite.writeMicroseconds(tempsdroite);

rouegauche.writeMicroseconds (tempsgauche);

}

Retour au sommaire .

Pour tout problème

Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .

Facebook Twitter Youtube

Retour en haut de page