Archives de catégorie : Hardware/Software

Mise à jour le 25/02/2021 :

Sommaire :

Principe de fonctionnement pour le pilotage
Sélection de la résolution et du réglage du courant sur le driver
Pilotage sommaire d’un moteur pas à pas avec driver avec l’utilisation de la fonction delay()
Fonctionnement d’un moteur pas à pas avec Arduino avec la fonction micros
- Principe de pilotage d’un moteur pas à pas avec un Arduino et un driver de type DRI0043
- Matériel utile mais pas nécessaire pour la réalisation de ce tuto
- Schéma électrique
- Tutoriel sur le principe de pilotage d’un moteur pas à pas avec Arduino
- Programme pour le tuto
Pour tout probléme
Retour au menu

Principe de fonctionnement pour le pilotage avec Arduino

Lorsque la broche EN est à l’état bas sur le driver, le moteur n’est plus sous tension , il est en mode off-line . Dans ce mode, vous pouvez régler manuellement la position de l’arbre moteur

Lorsque la broche EN est à l’État haut on ne peut plus déplacer le moteur librement il est en mode automatique

La broche DIR permet de définir la direction du moteur

La broche PULSE permet de définir la vitesse et le nombre de pas sur le moteur.

Retour au sommaire

Sélection de la resolution et du réglage du courant

Réglage du courant

Pour un moteur donné, plus le courant du driver est élevé, plus le couple est élevé, mais cela n’entraîne plus d’échauffement dans le moteur et le driver. Par conséquent, le courant de sortie est en général ajusté de façon à éviter une surchauffe du moteur lors d’une utilisation prolongée. Le raccordement en série ou en parallèle des bobinages modifie de manière significative les inductances et résistance résultantes d’où l’importance d’en tenir compte lors du choix du courant de sortie.

L’intensité communiquée par le fabricant du moteur est importante pour sélectionner le courant, mais il faut également tenir compte du mode de raccordement.

Retour au sommaire

Pilotage sommaire d’un moteur pas à pas avec driver avec
l’utilisation de la fonction delay()

Commentaire sur le programme :

Dans ce programme, nous avons utilisé la fonction delay () car le principe de fonctionnement est relativement simple, mais qui a pour inconvénient de bloquer le programme pendant l’utilisation de celle-ci. Ce qui pose un problème lors d’autres exécutions comme par exemple des systèmes de synchronisation ou des mouvements qui doivent s’opérer en parallèle.
Il est donc plus intéressant dans un code plus élaboré d’utiliser la fonction Millis() ou Micros() qui est une fonction non bloquante

//
//
//***********************************************************
// RedOhm
// le 08/01/2021
// 
// Principe de pilotage d'un moteur pas a pas avec un Arduino et
// un driver de type DRI0043 (fonctionnement identique avec le DM860)
//
// Ce programme est un logiciel libre: vous pouvez le redistribuer 
// et / ou le modifier
// Ce programme est distribué dans l'espoir qu'il vous sera utile,
// mais sans aucune garantie de fonctionnement 
// 
// Par: Mazelin Herve 
// IDE Arduino 1.8.12 
//**********************************************************

// Affectation des sortie de la carte Ardunio pour le pilotage 
// du driver DRI0043 

int PUL=12; //define Pulse pin
int DIR=10; //define Direction pin
int ENA=11; //define Enable Pin



// Rappel sur les variables
// Les variables déclarées en tête de programme sont des variables globales
// et peuvent être utilisées partout dans le programme.
 
int basse_de_temps ;


//--------------------------------------------------------------------
// 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() 
{
  pinMode (PUL, OUTPUT);
  pinMode (DIR, OUTPUT);
  pinMode (ENA, OUTPUT);
  basse_de_temps = 4550;
}

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


void loop() {
  // Marche avant 
  digitalWrite(DIR,LOW);
  digitalWrite(ENA,HIGH);
  
  for (int i=0; i<3200; i++)    
  {
    
    digitalWrite(PUL,HIGH);
    delayMicroseconds(basse_de_temps);
    digitalWrite(PUL,LOW);
    delayMicroseconds(basse_de_temps);
    
  }
  
  delay (1000);

  digitalWrite(DIR,HIGH);
  digitalWrite(ENA,HIGH);
 
  for (int i=0; i<3200; i++)   
  {
    
    digitalWrite(PUL,HIGH);
    delayMicroseconds(basse_de_temps);
    digitalWrite(PUL,LOW);
    delayMicroseconds(basse_de_temps);
  }

  delay (1000);
}

//***********************************************************

// RedOhm

// le 08/01/2021

// Principe de pilotage d'un moteur pas a pas avec un Arduino et

// un driver de type DRI0043 (fonctionnement identique avec le DM860)

// Ce programme est un logiciel libre: vous pouvez le redistribuer

// et / ou le modifier

// Ce programme est distribué dans l'espoir qu'il vous sera utile,

// mais sans aucune garantie de fonctionnement

// Par: Mazelin Herve

// IDE Arduino 1.8.12

//**********************************************************

// Affectation des sortie de la carte Ardunio pour le pilotage

// du driver DRI0043

int PUL=12; //define Pulse pin

int DIR=10; //define Direction pin

int ENA=11; //define Enable Pin

// Rappel sur les variables

// Les variables déclarées en tête de programme sont des variables globales

// et peuvent être utilisées partout dans le programme.

int basse_de_temps ;

//--------------------------------------------------------------------

// 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()

{

pinMode (PUL, OUTPUT);

pinMode (DIR, OUTPUT);

pinMode (ENA, OUTPUT);

basse_de_temps = 4550;

}

// ----------------------------------------------------------------------

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

// ----------------------------------------------------------------------

void loop() {

// Marche avant

digitalWrite(DIR,LOW);

digitalWrite(ENA,HIGH);

for (int i=0; i<3200; i++)

{

digitalWrite(PUL,HIGH);

delayMicroseconds(basse_de_temps);

digitalWrite(PUL,LOW);

delayMicroseconds(basse_de_temps);

}

delay (1000);

digitalWrite(DIR,HIGH);

digitalWrite(ENA,HIGH);

for (int i=0; i<3200; i++)

{

digitalWrite(PUL,HIGH);

delayMicroseconds(basse_de_temps);

digitalWrite(PUL,LOW);

delayMicroseconds(basse_de_temps);

}

delay (1000);

}

Retour au sommaire

Fonctionnement d’un moteur pas à pas avec Arduino
avec la fonction micros

Principe de pilotage d’un moteur pas à pas avec un Arduino et un driver de type DRI0043

Création d’un générateur d’impulsion pour le déplacement et la vitesse du moteur ( avec la fonction micros() )
Création de la fonction débrayage du moteur
Inversion du sens de rotation du moteur
Création d’un bouton départ cycle

Matériel utile mais pas nécessaire pour la réalisation de ce tuto

Shield E/S Mega DFR0165

Shield d’expansion E/S de DFRobot permettant d’accéder à toutes les entrées/sorties d’une carte compatible Arduino Mega® via des connecteurs 3 broches (Vcc, Gnd, Signal). La carte est équipée de 3 connecteurs pour module Xbee ou compatible et d’un port micro-SD. Sélection de la source d’alimentation.

La carte possède un régulateur de tensions intégrées pour le 3,3V. Un bouton poussoir pour la réinitialisation de la carte et une led intégrée que l’on peut utiliser pour des tests ou pour debugger un programme.
Un connecteur d’alimentation externe pour servomoteur si vous deviez connecter une large gamme de servomoteur.
Un support de carte SD qui nous permet d’avoir une mémoire supplémentaire

Schéma electrique

Schema de principe – RedOhm –

Raccordement des boutons poussoir – RedOhm –

Tutoriel sur le principe de pilotage d’un moteur pas à pas avec Arduino

Programme pour le tuto .

//
//
//***********************************************************
// RedOhm
// le 30/01/2021
// 
// Principe de pilotage d'un moteur pas a pas avec un Arduino et
// un driver de type DRI0043 (fonctionnement identique avec le DM860)
// but : 
// 1 - creation d'un generateur d'impulsion pour le deplacement 
//     et la vitesse du moteur ( avec la fonction micros() ) 
// 2 - Creation de la fonction debrayage du moteur
// 3 - Inversion du sens de rotation du moteur 
// 4 - Creation d'un bouton depart cycle  
//  
// Ce programme est un logiciel libre: vous pouvez le redistribuer 
// et / ou le modifier
// Ce programme est distribué dans l'espoir qu'il vous sera utile,
// mais sans aucune garantie de fonctionnement 
// 
// Par: Mazelin Herve 
// IDE Arduino 1.8.12 
//**********************************************************

// Declaration des variables demarrage 
// unsigned long-> déclare une variable de type long non signé
// pour la base de temps il y a 1 000 microsecondes dans une milliseconde
//                     et
// 1 000 000 microsecondes dans une seconde.
unsigned long demarrage = micros();


// Declaration des variables 
// int -> declare une variable du type int (pour integer, entier en anglais)
// elles peuvent stocker des valeurs de - 32 768 à 32 767
int base_de_temps1 = 1 ;


// Affectation des sorties de la carte Ardunio pour le pilotage 
// du driver DRI0043 


// une impulsion montante ou descendante sur cette entrée fait
// avancer le moteur d’un pas. La tension de l’impulsion doit
// être de 4,5 à 5 V pour un état HAUT et 0 à 0,5 V pour un état BAS. 
// La largeur d’impulsion doit être de minimum 2,5 μs pour un
// fonctionnement correct.
int PUL=12; 
// Definit le sens de rotation en fonction de l'etat bas ou haut
int DIR=10;
// ce signal est utilisé pour permettre ou interdire l’utilisation du
// driver. Le moteur est hors tension
int ENA=11; 

// déclaration de l'entrée du bouton branché sur la broche 14
// de votre carte Arduino pour le bouton depart cycle avec la fonction
// telerupteur 
int bouton14 = 14;
// variable du type int pour stocker les valeurs de passage du bouton14
int bouton14v;
// creation d'une memoire_2 et forçage a 0 de la variable 
// etat du telerupteur 
int memoire_2=0;
// etat precedent du bouton et forçage a 0 de la variable 
int etat_bouton14v=0 ;

// déclaration de l'entrée du bouton branché sur la broche 15
// pour le debrayage du moteur
int bouton_debrayage = 15;
int bouton_debrayage_v;

// déclaration de l'entrée du bouton branché sur la broche 16
// de votre carte Arduino pour le bouton marche avant ou arriere  
int bp_avant_arriere = 16;
// variable du type int pour stocker les valeurs de passage du bouton
// bp_avant-arriere
int bp_avant_arrierev;
// creation d'une memoire_avant_arriere et forçage a 0 de la variable 
// etat du telerupteur 
int memoire_avant_arriere=0;
// etat precedent du bouton et forçage a 0 de la variable 
int etat_avant_arriere=0 ;

// Declaration de pin pour le voyant depart cycle 
int voyant_depart_cycle = 8; 

// Declaration de pin pour le voyant marche avant vert
int voyant_vert_mar = 20; 
// Declaration de pin pour le voyant marche arriere rouge
int voyant_rouge_arr = 21; 

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

void setup() 
{
  
// Configure la broche spécifiée pour qu'elle se comporte soit en entrée, 
// soit en sortie.

// Configuration des broches pour le driver
  pinMode (PUL, OUTPUT);
  pinMode (DIR, OUTPUT);
  pinMode (ENA, OUTPUT);


// Configuration des broches pour les boutons et le voyants
  pinMode(bouton14,INPUT);
  pinMode(bouton_debrayage,INPUT);
  pinMode(bp_avant_arriere,INPUT);
  pinMode(voyant_depart_cycle,OUTPUT);
  pinMode(voyant_vert_mar,OUTPUT);
  pinMode(voyant_rouge_arr,OUTPUT);

}



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

void loop()
{

// *******************************************
//      Demande de depart cycle
// *******************************************   

 bouton14v = digitalRead(bouton14);

// Creation un telerupteur 
// Compare la variable à gauche avec la valeur ou la variable
// à droite . Renvoie l'information vraie lorsque les deux
// variables ne sont pas égales. 
   if (bouton14v!=etat_bouton14v)
    {
       if (!bouton14v)
      {
        //Inversion de la valeur de la variable memoire 
        memoire_2=!memoire_2;
      } 
 
       //Inversion de la valeur de la variable memoire 
       memoire_2=!memoire_2;
     
    }

// operation consitant a memoriser l'anciennne valeur de la 
// variable     
etat_bouton14v=bouton14v;
  
if (  memoire_2 == 1)
  {
    digitalWrite(voyant_depart_cycle,HIGH);
    //appel de la fonction de deplacement moteur 
    deplacement();
     
  }
else if (  memoire_2 == 0)
  {
   digitalWrite(voyant_depart_cycle,LOW); 
  }
  
// **** Fin de demande de depart cycle *******



// *******************************************
//      Demande de debrayage du moteur
// ******************************************* 
// debrayage du moteur de son driver
bouton_debrayage_v = digitalRead(bouton_debrayage);
 if ( bouton_debrayage_v == 1 )
 {
 digitalWrite(ENA,LOW);  
 }

// ******* Fin de demande debrayage **********
 

// *******************************************
//      Selection du sens de deplacement 
//               de l'actionneur 
// ******************************************* 

// selection du sens de deplacement du moteur 
bp_avant_arrierev = digitalRead(bp_avant_arriere);

// Creation un telerupteur 
// Compare la variable à gauche avec la valeur ou la variable
// à droite . Renvoie l'information vraie lorsque les deux
// variables ne sont pas égales. 
   if (bp_avant_arrierev!=etat_avant_arriere)
    {
       if (!bp_avant_arrierev)
      {
        //Inversion de la valeur de la variable memoire 
        memoire_avant_arriere=!memoire_avant_arriere;
      } 
       //Inversion de la valeur de la variable memoire 
       memoire_avant_arriere=!memoire_avant_arriere;
     
    }

// operation consitant a memoriser l'anciennne valeur de la 
// variable     

etat_avant_arriere = bp_avant_arrierev;

if ( memoire_avant_arriere == 1 )
{
 digitalWrite(voyant_rouge_arr,LOW);
 digitalWrite(voyant_vert_mar,HIGH);
 // Marche avant
 digitalWrite(DIR,LOW);
 digitalWrite(ENA,HIGH);
}

else if (memoire_avant_arriere == 0)
{
 digitalWrite(voyant_vert_mar,LOW);   
 digitalWrite(voyant_rouge_arr,HIGH);
 // Marche arriere
 digitalWrite(DIR,HIGH);
 digitalWrite(ENA,HIGH); 
}

// **** Fin de la selection avant arriere ****     


}


//==============================================
//Fonction de deplacement du moteur 
//==============================================

void deplacement()
{
// la ligne if  effectue la difference entre le temps actuel et le 
// temps de debut de boucle .

if (micros()-demarrage>350)
{
//Inversion de la valeur de la variable memoire et envoie l'information
//a la broche  
digitalWrite(PUL,base_de_temps1=!base_de_temps1);
// on reinitialise la variable demarrage avec le contenu de micros()
demarrage=micros();

}

  
}

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

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

//***********************************************************

// RedOhm

// le 30/01/2021

// Principe de pilotage d'un moteur pas a pas avec un Arduino et

// un driver de type DRI0043 (fonctionnement identique avec le DM860)

// but :

// 1 - creation d'un generateur d'impulsion pour le deplacement

// et la vitesse du moteur ( avec la fonction micros() )

// 2 - Creation de la fonction debrayage du moteur

// 3 - Inversion du sens de rotation du moteur

// 4 - Creation d'un bouton depart cycle

// Ce programme est un logiciel libre: vous pouvez le redistribuer

// et / ou le modifier

// Ce programme est distribué dans l'espoir qu'il vous sera utile,

// mais sans aucune garantie de fonctionnement

// Par: Mazelin Herve

// IDE Arduino 1.8.12

//**********************************************************

// Declaration des variables demarrage

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

// pour la base de temps il y a 1 000 microsecondes dans une milliseconde

// et

// 1 000 000 microsecondes dans une seconde.

unsigned long demarrage = micros();

// Declaration des variables

// int -> declare une variable du type int (pour integer, entier en anglais)

// elles peuvent stocker des valeurs de - 32 768 à 32 767

int base_de_temps1 = 1 ;

// Affectation des sorties de la carte Ardunio pour le pilotage

// du driver DRI0043

// une impulsion montante ou descendante sur cette entrée fait

// avancer le moteur d’un pas. La tension de l’impulsion doit

// être de 4,5 à 5 V pour un état HAUT et 0 à 0,5 V pour un état BAS.

// La largeur d’impulsion doit être de minimum 2,5 μs pour un

// fonctionnement correct.

int PUL=12;

// Definit le sens de rotation en fonction de l'etat bas ou haut

int DIR=10;

// ce signal est utilisé pour permettre ou interdire l’utilisation du

// driver. Le moteur est hors tension

int ENA=11;

// déclaration de l'entrée du bouton branché sur la broche 14

// de votre carte Arduino pour le bouton depart cycle avec la fonction

// telerupteur

int bouton14 = 14;

// variable du type int pour stocker les valeurs de passage du bouton14

int bouton14v;

// creation d'une memoire_2 et forçage a 0 de la variable

// etat du telerupteur

int memoire_2=0;

// etat precedent du bouton et forçage a 0 de la variable

int etat_bouton14v=0 ;

// déclaration de l'entrée du bouton branché sur la broche 15

// pour le debrayage du moteur

int bouton_debrayage = 15;

int bouton_debrayage_v;

// déclaration de l'entrée du bouton branché sur la broche 16

// de votre carte Arduino pour le bouton marche avant ou arriere

int bp_avant_arriere = 16;

// variable du type int pour stocker les valeurs de passage du bouton

// bp_avant-arriere

int bp_avant_arrierev;

// creation d'une memoire_avant_arriere et forçage a 0 de la variable

// etat du telerupteur

int memoire_avant_arriere=0;

// etat precedent du bouton et forçage a 0 de la variable

int etat_avant_arriere=0 ;

// Declaration de pin pour le voyant depart cycle

int voyant_depart_cycle = 8;

// Declaration de pin pour le voyant marche avant vert

int voyant_vert_mar = 20;

// Declaration de pin pour le voyant marche arriere rouge

int voyant_rouge_arr = 21;

* Un programme Arduino doit impérativement contenir cette fonction

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

* Elle sert à configurer globalement les entrées sorties

void setup()

{

// Configure la broche spécifiée pour qu'elle se comporte soit en entrée,

// soit en sortie.

// Configuration des broches pour le driver

pinMode (PUL, OUTPUT);

pinMode (DIR, OUTPUT);

pinMode (ENA, OUTPUT);

// Configuration des broches pour les boutons et le voyants

pinMode(bouton14,INPUT);

pinMode(bouton_debrayage,INPUT);

pinMode(bp_avant_arriere,INPUT);

pinMode(voyant_depart_cycle,OUTPUT);

pinMode(voyant_vert_mar,OUTPUT);

pinMode(voyant_rouge_arr,OUTPUT);

}

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

void loop()

{

// *******************************************

// Demande de depart cycle

// *******************************************

bouton14v = digitalRead(bouton14);

// Creation un telerupteur

// Compare la variable à gauche avec la valeur ou la variable

// à droite . Renvoie l'information vraie lorsque les deux

// variables ne sont pas égales.

if (bouton14v!=etat_bouton14v)

{

if (!bouton14v)

{

//Inversion de la valeur de la variable memoire

memoire_2=!memoire_2;

}

//Inversion de la valeur de la variable memoire

memoire_2=!memoire_2;

}

// operation consitant a memoriser l'anciennne valeur de la

// variable

etat_bouton14v=bouton14v;

if ( memoire_2 == 1)

{

digitalWrite(voyant_depart_cycle,HIGH);

//appel de la fonction de deplacement moteur

deplacement();

}

else if ( memoire_2 == 0)

{

digitalWrite(voyant_depart_cycle,LOW);

}

// **** Fin de demande de depart cycle *******

// *******************************************

// Demande de debrayage du moteur

// *******************************************

// debrayage du moteur de son driver

bouton_debrayage_v = digitalRead(bouton_debrayage);

if ( bouton_debrayage_v == 1 )

{

digitalWrite(ENA,LOW);

}

// ******* Fin de demande debrayage **********

// *******************************************

// Selection du sens de deplacement

// de l'actionneur

// *******************************************

// selection du sens de deplacement du moteur

bp_avant_arrierev = digitalRead(bp_avant_arriere);

// Creation un telerupteur

// Compare la variable à gauche avec la valeur ou la variable

// à droite . Renvoie l'information vraie lorsque les deux

// variables ne sont pas égales.

if (bp_avant_arrierev!=etat_avant_arriere)

{

if (!bp_avant_arrierev)

{

//Inversion de la valeur de la variable memoire

memoire_avant_arriere=!memoire_avant_arriere;

}

//Inversion de la valeur de la variable memoire

memoire_avant_arriere=!memoire_avant_arriere;

}

// operation consitant a memoriser l'anciennne valeur de la

// variable

etat_avant_arriere = bp_avant_arrierev;

if ( memoire_avant_arriere == 1 )

{

digitalWrite(voyant_rouge_arr,LOW);

digitalWrite(voyant_vert_mar,HIGH);

// Marche avant

digitalWrite(DIR,LOW);

digitalWrite(ENA,HIGH);

}

else if (memoire_avant_arriere == 0)

{

digitalWrite(voyant_vert_mar,LOW);

digitalWrite(voyant_rouge_arr,HIGH);

// Marche arriere

digitalWrite(DIR,HIGH);

digitalWrite(ENA,HIGH);

}

// **** Fin de la selection avant arriere ****

}

//==============================================

//Fonction de deplacement du moteur

//==============================================

void deplacement()

{

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

// temps de debut de boucle .

if (micros()-demarrage>350)

{

//Inversion de la valeur de la variable memoire et envoie l'information

//a la broche

digitalWrite(PUL,base_de_temps1=!base_de_temps1);

// on reinitialise la variable demarrage avec le contenu de micros()

demarrage=micros();

}

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

Grabcad Thingiverse Cults

Servomoteur à rétroaction analogique

Mise à jour le 02/01/2021 : Etude sur le fonctionnement et la programmation d’un servomoteur à retour d’information

Continuer la lecture →

Présentation et Utilisation de la carte ArbotiX-M

Mise à jour le 08/10/2020 : Dans cet article vous trouverez les caractéristiques principales de la carte ArbotiX-M .Ce contrôleur de robot polyvalent est une solution de contrôle avancée pour les actionneurs basés sur BIOLOID et DYNAMIXEL

Carte ArbotiX-M

Sommaire :

Description de la carte ArbotiX-M
- Spécifications techniques de la carte
- Compatibilité avec les servo Dynamixel suivant
- Information complementaire sur la carte ArbotiX-M
Explication de la partie Hardware de la carte
- Cablage des entrées analogiques
- Alimentation du bus pour les servomoteurs type RC
Téléchargez Arduino 1.0.6 et installez
Comment connaitre les macro de la bibliotheque Bioloid
Table de controle de la zone EEPROM et RAM du servomoteur AX-12
- 0-Donne le numéro de modèle du servomoteur R
- 2-Version du firmware R
- 3-Identifiant du servomoteur R/W
  - Explication de l’identifiant
  - Tutoriel sur le changement d’idenfiant
  - Code source
- 4-vitesse de communication série entre un contrôleur et le servo R/W
  - Tableau de la vitesse de transmission des servomoteurs Dynamixel
  - Tutoriel pour la modification de la vitesse de communication
  - Code source pour le Tutoriel
- 5-Délai de réponse du servo R/W
- 6-Limite d’angle dans le sens horaire R/W
- 8-Limite d’angle anti-horaire R/W
- 11-Limite de température interne maximale R/W
- 12-Limite de tension d’entrée minimale R/W
- 13-Limite de tension d’entrée maximale R/W
- 14-Couple maximal R/W
- 16-Sélectionnez les types de déclaration de statut R/W
- 17-LED pour alarme R/W
- 18-Informations sur les erreurs d’arrêt R/W
- 24-Activation et désactivation du couple R/W
- 25-Allumez ou éteignez la LED du DYNAMIXEL. R/W
- 26-27-Controle d’erreur de deplacement R/W
- 28-29-Pente de conformité R/W
- 30-Position de l’objectif R/W
- 32-Vitesse de deplacement R/W
- 34-Limite du couple R/W
- 36-Position actuelle de votre servomoteur R
- 42-obtenir la tension actuelle du servo. R
- 43-obtenir la température actuelle du servo R
- 44-Macro permettant de savoir si le servo a une commande enregistrée R
Pilotage de la led sur le servomoteur
Exemple utilisation des moteurs Dynamixel
A savoir sur l’utilisation des informations de cette article .
Pour tout probléme
Retour au menu principal

Description de la carte ArbotiX-M

Ce contrôleur de robot polyvalent est une solution de contrôle avancée pour les actionneurs basés sur BIOLOID et DYNAMIXEL. En tant que microcontrôleur compatible Arduino, la carte contrôleur Arbotix bénéficie également d’une énorme communauté open source de bibliothèques et d’exemples. Depuis sa sortie en 2010, l’ArbotiX-M est rapidement devenu un favori parmi les constructeurs du monde entier, du loisir à la recherche de haut niveau.

Cette carte a été spécifiquement conçue pour contrôler les servomoteurs Dynamixel. La carte ArbotiX-M est plus qu’un remplaçant pour la carte de controle CM-5, il s’agit plutôt d’un outil de haut niveau dédié à la construction de robots plus sophistiqués.

Specifications techniques de la carte contrôleur robotique ArbotiX-M

microcontrôleur AVR 16 MHz (ATMEGA644p)
2 ports séries, 1 dédié aux servo-contrôleurs Dynamixel, l’autre au module radio XBEE
3 ports de style TTL DYNAMIXEL à 3 broches
28 E / S numériques, dont 8 peuvent également fonctionner comme entrées analogiques
Embases à 3 broches de style servo (gnd, vcc, signal) sur les 28 broches d’E / S
Cette carte nécessite un câble FTDI ou un FAI pour la programmation. Pour un câble FTDI, nous recommandons le câble Sparkfun FTDI – USB , vous pouvez également utiliser le programmeur AVR USB .
Avec une dimension de 7.11 x 7.11 cm (2.8″ x 2.8 « )

Compatibilité avec les servo Dynamixel suivant

AX-12A : Le servo robot AX-12A a la capacité de suivre sa vitesse, sa température, la position de l’arbre, la tension et la charge. De plus l’algorithme de contrôle utilisé pour maintenir la position de l’arbre sur l’actionneur ax-12 peut être ajusté individuellement pour chaque servo, vous permettant de contrôler la vitesse et la force de la réponse du moteur. Toute la gestion des capteurs et le contrôle de position sont gérés par le microcontrôleur intégré du servo. Cette approche distribuée laisse votre contrôleur principal libre d’effectuer d’autres fonctions.

AX-18A : Le servomoteur AX-18A est la prochaine étape par rapport servomoteur AX-12A, offrant près de deux fois la vitesse et 15% de couple en plus! Le servo robot AX-18A conserve le facteur de forme et toutes les mêmes caractéristiques que son prédécesseur: la possibilité de suivre sa vitesse, sa température, la position de l’arbre, la tension et la charge. L’algorithme de contrôle fonctionne de la méme façon que la version AX-12A

Compatibilité du moteur avec les cartes suivantes :
- Robot-contrôleur ArbotiX-M
- ROBOTIS CM-530
- ROBOTIS USB2DYNAMIXEL
- ROBOTIS CM-700
- ROBOTIS Open CM 9

AX-12W : Le servomoteur AX-12W de Robotis est une variante à roues du populaire AX-12A. Essentiellement, ce servo est un AX-12A avec un rapport d’engrenage inférieur, de sorte qu’un régime beaucoup plus élevé peut être atteint, ce qui le rend idéal pour une utilisation en mode roue par opposition au mode commun. Le servo robot AX-12W a la capacité de suivre sa température, sa tension et sa charge.L’algorithme de contrôle fonctionne de la méme façon que la version AX-12A , AX-18A

AX-12W Compatible carte ArbotiX-M -2

Tension de fonctionnement : 12V
Couple de décrochage : 2,0 kg-cm / 28 oz-in / 0,2 Nm
Vitesse à vide : 470 tr / min (mode roue)
Poids : 53g
Taille : 50 x 32 x 38 mm
Résolution : 0,29 °
Servos de résolution : 300 ° / 10 BITS
Compatibilité du moteur avec les cartes suivantes :
- Robot-contrôleur ArbotiX-M
- Module de controle Bioloid CM-5
- Adaptateur Robotis USB2Dynamixel

Information complementaire sur la carte ArbotiX-M

Vous ne pouvez pas programmer l’ArbotiX pendant qu’un XBee est branché sur l’ArbotiX ou l’UartSBee. Vous devez débrancher tout XBees de l’ArbotiX-M ou UartSBee pendant la programmation. En effet, le XBee et le câble FTDI sont connectés au même port série. Si vous souhaitez programmer la carte alors qu’un XBee est branché, vous devez utiliser la programmation ISP

Retour au sommaire

Explication de la partie Hardware de la carte

Cablage des entrée analogiques

Les broches analogiques font également office de broches d’E / S numériques. Vous pouvez y accéder dans l’IDE Arduino en adressant les broches numériques 24-31 pour accéder aux broches analogiques A0-A7.

Entrée analogique sur la carte Arbotix-M

Retour au sommaire

Alimentation du bus pour les servomoteurs type RC

Avoir ces quatre ports sur un bus d’alimentation séparé est idéal pour utiliser à la fois les servos RC et les servos DYNAMIXEL du même ArbotiX. La plupart des servos DYNAMIXEL ont besoin de 11-12V pour fonctionner, mais la plupart des servomoteurs RC fonctionnent à partir de 5-6v. Comme le régulateur 5v a une puissance de sortie limitée, il n’est pas judicieux d’alimenter les servomoteurs à partir du BUS 5v. En ajoutant une autre alimentation, il est facile d’alimenter en toute sécurité ses servos RC

Code pour le pilotage d’un servo RC et d’un servomoteur Dynamixel

//
//
//*************************************************************
//* 
//* IDE Arduino 1.0.6
//*
//* Exemple de pilotage d'un servo Dynamixel
//* et d'un servo Rc sur la meme carte 
//*       
//* H-Mazelin
//* 05/08/2020
//*
//*************************************************************



//librairie qui permet d'implémentez le code de communication série
//de bas niveau pour communiquer avec le bus Bioloid.  
#include <ax12.h>
//Cette librairies vous permet interagir avec les servos AX et MX  

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


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

 
/*
 *  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 ()

{

 //ouvre le port série et fixe le debit de communication à 9600 bauds
  Serial.begin(9600);
  // on attent que le port de communication soit pret
  delay(1000);
  // Information a l'operateur de l'ouverture du port de communication 
  // sur le moniteur serie 
  Serial.println("========================================");
  Serial.println("Communication etablie");
  Serial.println("========================================");   

  // associe le servomoteur a la broche 12   
  servo01.attach(12);


}

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

void loop()

{

// Exemple de mouvement du servomoteur 
// avec la commande SetPosition(identifiant,position)  
   SetPosition(2,250);
// Pilotage du servomoteur RC
   servo01.write (20);
    delay (2000);
// Pilotage du servomoteur Dynamixel
   SetPosition(2,800); 
// Pilotage du servomoteur RC retour en arriere a 170 degres     
   servo01.write(160); 
     delay (2000);
//
//
  
}

//*************************************************************

//*

//* IDE Arduino 1.0.6

//*

//* Exemple de pilotage d'un servo Dynamixel

//* et d'un servo Rc sur la meme carte

//*

//* H-Mazelin

//* 05/08/2020

//*

//*************************************************************

//librairie qui permet d'implémentez le code de communication série

//de bas niveau pour communiquer avec le bus Bioloid.

#include <ax12.h>

//Cette librairies vous permet interagir avec les servos AX et MX

// Cette librairie permet à une carte ArbotiX-M de contrôler des servomoteurs

#include <Servo.h>

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

Servo servo01;

* 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 ()

{

//ouvre le port série et fixe le debit de communication à 9600 bauds

Serial.begin(9600);

// on attent que le port de communication soit pret

delay(1000);

// Information a l'operateur de l'ouverture du port de communication

// sur le moniteur serie

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

Serial.println("Communication etablie");

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

// associe le servomoteur a la broche 12

servo01.attach(12);

}

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

void loop()

{

// Exemple de mouvement du servomoteur

// avec la commande SetPosition(identifiant,position)

SetPosition(2,250);

// Pilotage du servomoteur RC

servo01.write (20);

delay (2000);

// Pilotage du servomoteur Dynamixel

SetPosition(2,800);

// Pilotage du servomoteur RC retour en arriere a 170 degres

servo01.write(160);

delay (2000);

}

Retour au sommaire

Téléchargez Arduino 1.0.6 et installez

L’Arduino IDE est une application que vous pouvez utiliser pour programmer et interagir avec des microcontrôleurs basés sur Arduino comme l’ArbotiX-M. Les bibliothèques ArbotiX-M ont été minutieusement testées avec IDE Arduino 1.0.6. Les bibliothèques actuelle ne prenne pas en charge les anciennes versions d’Arduino (beta 18-23) ou Arduino 1.6. Les utilisateurs peuvent télécharger l’IDE Arduino compressé et le décompresser à l’emplacement de leur choix. Les utilisateurs de Windows peuvent également utiliser Windows Installer pour automatiser ce processus.

Retour au sommaire

Comment connaitre les macro de la bibliotheque Bioloid

Il est toujours très intéressant de connaître le contenu d’une bibliothèque et en l’occurrence du fichier d’en-tête. Quelquefois on peut passer à côté de certains codes ou macros qui sont très intéressantes.

De quoi est composée la bibliothèque.

C’est un dossier qui contient :

Le fichier d’entête. Repérable par « .h »
Le fichier sources. Repérable par « .cpp »
Le dossier « exemple ». Qui contient des codes sources des exemples.

Arduino
- libraries
  - Bioloid
    - ax12.ccp
    - ax12.h
    - BioloidController.cpp
    - BioloidController.h
    - keywords.txt

Quand vous avez trouvé l’emplacement du fichier « Bioloid.h », ouvrez-le.

A première vue, on a pas l’impression que ce fichier est un code programme car il est présenté sous format » texte ». De ce fait, il est exploitable par un éditeur de texte comme « NotePad », « WordPad » ou le « Bloc-notes ».

A savoir : N’apportez surtout pas de modifications à ce fichier et n’accepter jamais d’enregistrer d’éventuelles modifications car cela entraînerait à coup sûr un mauvais fonctionnement de la bibliothèque.

Vous pourrez constater que le fichier nous donne un grand nombre de macros et à droite des noms des macros vous avez le numéro de registre correspondant.

Retour au sommaire

Table de controle de la zone EEPROM et RAM du servo AX-12

Definition de la table de controle des servomoteurs.

La table de contrôle est une structure de données implémentée dans l’appareil. Les utilisateurs peuvent lire des données spécifiques pour obtenir l’état de l’appareil avec les paquets d’instructions de lecture, et modifier également les données pour contrôler l’appareil avec les paquets d’instructions WRITE.

Tableau de contrôle,données,adresse

La table de contrôle est une structure qui se compose de plusieurs champs de données pour stocker l’état ou pour contrôler le périphérique. Les utilisateurs peuvent vérifier l’état actuel de l’appareil en lisant des données spécifiques de la table de contrôle avec des paquets d’instructions de lecture. Les paquets d’instructions WRITE permettent aux utilisateurs de contrôler le périphérique en modifiant des données spécifiques dans la table de contrôle. L’adresse est une valeur unique lors de l’accès à des données spécifiques dans la table de contrôle avec des paquets d’instructions. Pour lire ou écrire des données, les utilisateurs doivent désigner une adresse spécifique dans le paquet d’instructions.

Zone EEPROM et RAM

La table de contrôle est divisée en 2 zones. Les données de la zone RAM sont réinitialisées à leurs valeurs initiales lorsque l’alimentation est réinitialisée (volatile). D’autre part, les données dans la zone EEPROM sont conservées même lorsque l’appareil est hors tension (non volatile).

.
AX_MODEL_NUMBER_L et AX_MODEL_NUMBER_H
Registre 0 et Registre 1 en EEPROM

Cette adresse stocke le numéro du modèle du servo Dynamixel.octet de poids faible

Adresse	Fonction	Exemple de lecture du registre	Objectif
0	Donne le numéro de modèle	ax12GetRegister (1, AX_MODEL_NUMBER_L, 1); ou ax12GetRegister (1,0,1);
0	Donne le numéro de modèle
Accès	-> Lecture	Valeur initiale en mémoire EEPROM ->	12

Exemple de code

//
//
   Serial.println("========================================"); 
// Cette adresse stocke le numéro de modèle de servomoteur DYNAMIXEL.  
// Déclare une variable de type int (pour integer, entier en anglais)
   int modele= ax12GetRegister (1, AX_MODEL_NUMBER_L, 1);
// ou l'ecriture ci dessous
// int modele= ax12GetRegister (1,0,1);
   Serial.print ("Modele de servomoteur : ");
     Serial.println (modele); 
//

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

// Cette adresse stocke le numéro de modèle de servomoteur DYNAMIXEL.

// Déclare une variable de type int (pour integer, entier en anglais)

int modele= ax12GetRegister (1, AX_MODEL_NUMBER_L, 1);

// ou l'ecriture ci dessous

// int modele= ax12GetRegister (1,0,1);

Serial.print ("Modele de servomoteur : ");

Serial.println (modele);

Retour au sommaire

AX_VERSION
Registre 2 en EEPROM

Cette adresse stocke la version du firmware du servomoteur Dynamixel.

Adresse	Fonction	Exemple de lecture du registre	Objectif
2	la version du firmware
Accès	-> Lecture

Retour au sommaire

AX_ID
Registre 3 en EEPROM

L’ID est une valeur unique dans le réseau pour identifier chaque DYNAMIXEL avec un paquet d’instructions. Les valeurs 0 ~ 252 (0xFC) peuvent être utilisées comme ID, et 254 (0xFE) sont occupées comme ID de diffusion. L’ID de diffusion (254, 0xFE) peut envoyer simultanément un paquet d’instructions à tous les DYNAMIXEL connectés.

Adresse	Fonction	Exemple d’ecriture dans le registre	Objectif
3	Lecture de l’identifiant
R/W

Exemple de code : Modification de l’identifiant du servo

//
//
// Registre 3 modifie l'identifiant du servo de 1 vers 2
//
// Procedure d'ecriture dans le registre 3 pour le changement d'identifiant
// Modification de la valeur par defaut 1 par l'identifiant 2
   ax12SetRegister(1, 3, 2);
    delay (100);
//

// Registre 3 modifie l'identifiant du servo de 1 vers 2

// Procedure d'ecriture dans le registre 3 pour le changement d'identifiant

// Modification de la valeur par defaut 1 par l'identifiant 2

ax12SetRegister(1, 3, 2);

delay (100);

Le but de ce tutoriel est de vous initier aux changements de l’identifiant sur les servomoteurs dynamixel par le biais de la carte Arbotix-M

//
//
//*************************************************************
//* 
//* IDE Arduino 1.0.6
//*
//* Lecture et ecriture du registre 3 (identifiant du servo)
//* But : 
//* Lecture de la valeur actuel dans le registre 3
//* Renplacement de la valeur par defaut par un nouvel identifiant
//* dans notre cas 2
//* Controle du remplacement 
//*
//* Par H-Mazelin le 02/08/2020
//*
//*************************************************************



//librairie qui permet d'utiliser le code de communication série
//de bas niveau pour communiquer avec le bus Bioloid.  
#include <ax12.h>
//Cette librairie vous permet interagir avec les servos AX et MX  
#include <BioloidController.h>

// Vitesse par defaut pour les servo AX-12 = 1000000
BioloidController bioloid = BioloidController(1000000);

// ---------------------------------------------------------------------------
// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécutee une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
// ---------------------------------------------------------------------------
void setup()
{
  //ouvre le port série et fixe le debit de communication à 9600 bauds
  Serial.begin(9600);
  // on attent que le port de communication soit pret
  delay(1000);
  // Information a l'operateur de l'ouverture du port de communication 
  // sur le moniteur serie 
  Serial.println("========================================");
  Serial.println("Communication etablie");
  Serial.println("========================================"); 
  
  //
  //
  // Registre 3 modifie l'identifiant du servo de 1 vers 2
  //
  // Procedure d'ecriture dans le registre 3 pour le changement d'identifiant
  // Modification de la valeur par defaut 1 par l'identifiant 2
  
  // Enlever le mode commentaire pour activer le changement d'identifiant 
  // dans la ligne ci-dessous 
  ax12SetRegister(1, 3, 2);
  
   delay (100);
  //
}
void loop ()
{
 
  // Lecture de l'identifiant actuel
  int identifiant =ax12GetRegister(2,3,1);
  // Affichage de la lecture du registre contenant l'identifiant 
  Serial.print("le servo possede l'idenifiant suivant : ");
   Serial.println (identifiant);  
  delay(1000);
  

// 
  
  
// Exemple de mouvement du servomoteur 
// avec la commande SetPosition(identifiant,position)  
   Serial.println("lancement du programme sur le servo");  
    Serial.println("en bas ");
   SetPosition(2,250);
   delay(2000);
   Serial.println("en haut ");
   SetPosition(2,650);
   delay(2000);
   Serial.println("");
    
}

//*************************************************************

//*

//* IDE Arduino 1.0.6

//*

//* Lecture et ecriture du registre 3 (identifiant du servo)

//* But :

//* Lecture de la valeur actuel dans le registre 3

//* Renplacement de la valeur par defaut par un nouvel identifiant

//* dans notre cas 2

//* Controle du remplacement

//*

//* Par H-Mazelin le 02/08/2020

//*

//*************************************************************

//librairie qui permet d'utiliser le code de communication série

//de bas niveau pour communiquer avec le bus Bioloid.

#include <ax12.h>

//Cette librairie vous permet interagir avec les servos AX et MX

#include <BioloidController.h>

// Vitesse par defaut pour les servo AX-12 = 1000000

BioloidController bioloid = BioloidController(1000000);

// ---------------------------------------------------------------------------

// Un programme Arduino doit impérativement contenir la fonction "setup"

// Elle ne sera exécutee une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

// ---------------------------------------------------------------------------

void setup()

{

//ouvre le port série et fixe le debit de communication à 9600 bauds

Serial.begin(9600);

// on attent que le port de communication soit pret

delay(1000);

// Information a l'operateur de l'ouverture du port de communication

// sur le moniteur serie

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

Serial.println("Communication etablie");

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

// Registre 3 modifie l'identifiant du servo de 1 vers 2

// Procedure d'ecriture dans le registre 3 pour le changement d'identifiant

// Modification de la valeur par defaut 1 par l'identifiant 2

// Enlever le mode commentaire pour activer le changement d'identifiant

// dans la ligne ci-dessous

ax12SetRegister(1, 3, 2);

delay (100);

}

void loop ()

{

// Lecture de l'identifiant actuel

int identifiant =ax12GetRegister(2,3,1);

// Affichage de la lecture du registre contenant l'identifiant

Serial.print("le servo possede l'idenifiant suivant : ");

Serial.println (identifiant);

delay(1000);

// Exemple de mouvement du servomoteur

// avec la commande SetPosition(identifiant,position)

Serial.println("lancement du programme sur le servo");

Serial.println("en bas ");

SetPosition(2,250);

delay(2000);

Serial.println("en haut ");

SetPosition(2,650);

delay(2000);

Serial.println("");

}

Retour au sommaire

AX_BAUD_RATE
Registre 4 en EEPROM

Le débit en bauds détermine la vitesse de communication série entre un contrôleur et les servomoteurs Dynamixel.

Adresse

Fonction

Exemple d’ecriture dans le registre

Objectif

R/W

Fixe la vitesse de communication valeur par defaut 1M avec une marge d’erreur de 0.000%

ax12SetRegister(1,4,1);

Valeur par defaut 1M bauds

A savoir : moins de 3% de la marge d’erreur du débit en bauds n’affectera pas la communication UART.

//
//
// Registre 4 modifie la vitesse entre le controleur et les 
// servomoteur Dynamixel
//
// Procedure d'ecriture dans le registre 4 pour le changement de la vitesse
// de communication
// modification de la valeur 34 par la valeur 1
// 1 parametre : numero de identifiant du servo
// 2 parametre : numero du registre a modifie
// 3 parametre : valeur de la vitesse de transmission 
   ax12SetRegister(1,4,1);
   delay (500);

// Registre 4 modifie la vitesse entre le controleur et les

// servomoteur Dynamixel

// Procedure d'ecriture dans le registre 4 pour le changement de la vitesse

// de communication

// modification de la valeur 34 par la valeur 1

// 1 parametre : numero de identifiant du servo

// 2 parametre : numero du registre a modifie

// 3 parametre : valeur de la vitesse de transmission

ax12SetRegister(1,4,1);

delay (500);

Vitesse de transmission des servomoteurs Dynamixel

Le but de ce tutoriel est de vous familiariser avec les commandes de changement de vitesse et d’identifiant pour les servomoteurs Dynamixel. Le problème est le suivant, la connexion d’un servomoteur MX-106 et d’un servo AX-12 sur la même carte. En sachant que ces deux servomoteurs ne possèdent pas la même vitesse de communication par défaut, et possèdent le même identifiant par défaut. Il faut donc changer la vitesse de communication dans un des servomoteurs pour que les deux fonctionnent sur le même réseau, et enfin que chacun des servomoteurs possède un identifiant propre.

//
//
//*************************************************************
//* 
//* IDE Arduino 1.0.6
//*
//* Fonctionnement d'un servomoteur Dynamixel MX-106
//* 1- modification de la vitesse de transmission
//*  2- de l'identifiant      
//*   3- insertion d'un servo AX-12
//*    4- fonctionnment de l'ensemble 
//*
//* RedOhm le 14/09/2020 par Herve Mazelin 
//* 
//*************************************************************


//librairie qui permet d'implémentez le code de communication série
//de bas niveau pour communiquer avec le bus Bioloid.  
#include <ax12.h>
//Cette librairies vous permet interagir avec les servos AX et MX  
#include <BioloidController.h>


// En parenthese le vitesse de communication
// Servo AX12 = 1000000
// dans le registre du servo AX12 = 1 par defaut
// Servo MX-106 = 57142.9
// dands le registre du servo MX-106 = 34 par defaut
//
BioloidController bioloid = BioloidController(1000000);


// ---------------------------------------------------------------------------
// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
// ---------------------------------------------------------------------------
void setup()
{
  
  //ouvre le port série et fixe le debit de communication à 9600 bauds
  Serial.begin(9600);
  // on attent que le port de communication soit pret
  delay(1000);
  // Information a l'operateur de l'ouverture du port de communication 
  // sur le moniteur serie 
  Serial.println("========================================");
  Serial.println("Communication etablie");
  Serial.println("========================================"); 

// Registre 4 modifie la vitesse entre le controleur et les 
// servomoteur Dynamixel
//
// Procedure d'ecriture dans le registre 4 pour le changement de la vitesse
// de communication
// modification de la valeur 34 par la valeur 1
// 1 parametre : numero de identifiant du servo
// 2 parametre : numero du registre a modifie
// 3 parametre : valeur de la vitesse de transmission 
   //ax12SetRegister(1,4,1);
   //delay (500);

// Registre 3 modifie l'identifiant du servo de 1 vers 3
//
// Procedure d'ecriture dans le registre 3 pour le changement d'identifiant
// Modification de la valeur par defaut 1 par l'identifiant 3
   
   //ax12SetRegister(1, 3, 3);
   //delay (100);  
}


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

void loop ()
{
//
// Registre 3 donne l'identifiant MX-106   
//
  int identifiant = ax12GetRegister(3,3,1);
   Serial.print ("Registre 3: identifiant du MX-106 : "); 
    Serial.println (identifiant);
    delay(50);  
//
// Registre 4 donne la vitesse de transmission MX-106  
//
  int vitesse = ax12GetRegister(3,4,1);
   Serial.print ("Registre 4:Vitesse de transmission du MX-106 : "); 
    Serial.println (vitesse);
    delay(1000);
  

// Exemple de mouvement du servomoteur MX-106
// avec la commande SetPosition(identifiant,position) 
// Attention resolution du moteur 4096 
   Serial.println("             --------            ");
   Serial.println("lancement du programme sur le servo MX-106");
   Serial.println("A gauche");
   SetPosition(3,10);
   delay(2000);
   Serial.println("A droit");
   SetPosition(3,4080);
   delay(2000);
   Serial.println(""); 

     
// Exemple de mouvement du servomoteur ax-12
// avec la commande SetPosition(identifiant,position)  
   
   Serial.println("lancement du programme sur le servo AX-12");
   Serial.println("A gauche");
   SetPosition(2,200);
   Serial.println("A droit");
   delay(2000);
   SetPosition(2,850);
   Serial.println(""); 
     Serial.println("");     
  
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

//*************************************************************

//*

//* IDE Arduino 1.0.6

//*

//* Fonctionnement d'un servomoteur Dynamixel MX-106

//* 1- modification de la vitesse de transmission

//* 2- de l'identifiant

//* 3- insertion d'un servo AX-12

//* 4- fonctionnment de l'ensemble

//*

//* RedOhm le 14/09/2020 par Herve Mazelin

//*

//*************************************************************

//librairie qui permet d'implémentez le code de communication série

//de bas niveau pour communiquer avec le bus Bioloid.

#include <ax12.h>

//Cette librairies vous permet interagir avec les servos AX et MX

#include <BioloidController.h>

// En parenthese le vitesse de communication

// Servo AX12 = 1000000

// dans le registre du servo AX12 = 1 par defaut

// Servo MX-106 = 57142.9

// dands le registre du servo MX-106 = 34 par defaut

BioloidController bioloid = BioloidController(1000000);

// ---------------------------------------------------------------------------

// Un programme Arduino doit impérativement contenir la fonction "setup"

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

// Elle sert à configurer globalement les entrées sorties

// ---------------------------------------------------------------------------

void setup()

{

//ouvre le port série et fixe le debit de communication à 9600 bauds

Serial.begin(9600);

// on attent que le port de communication soit pret

delay(1000);

// Information a l'operateur de l'ouverture du port de communication

// sur le moniteur serie

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

Serial.println("Communication etablie");

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

// Registre 4 modifie la vitesse entre le controleur et les

// servomoteur Dynamixel

// Procedure d'ecriture dans le registre 4 pour le changement de la vitesse

// de communication

// modification de la valeur 34 par la valeur 1

// 1 parametre : numero de identifiant du servo

// 2 parametre : numero du registre a modifie

// 3 parametre : valeur de la vitesse de transmission

//ax12SetRegister(1,4,1);

//delay (500);

// Registre 3 modifie l'identifiant du servo de 1 vers 3

// Procedure d'ecriture dans le registre 3 pour le changement d'identifiant

// Modification de la valeur par defaut 1 par l'identifiant 3

//ax12SetRegister(1, 3, 3);

//delay (100);

}

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

void loop ()

{

// Registre 3 donne l'identifiant MX-106

int identifiant = ax12GetRegister(3,3,1);

Serial.print ("Registre 3: identifiant du MX-106 : ");

Serial.println (identifiant);

delay(50);

// Registre 4 donne la vitesse de transmission MX-106

int vitesse = ax12GetRegister(3,4,1);

Serial.print ("Registre 4:Vitesse de transmission du MX-106 : ");

Serial.println (vitesse);

delay(1000);

// Exemple de mouvement du servomoteur MX-106

// avec la commande SetPosition(identifiant,position)

// Attention resolution du moteur 4096

Serial.println(" -------- ");

Serial.println("lancement du programme sur le servo MX-106");

Serial.println("A gauche");

SetPosition(3,10);

delay(2000);

Serial.println("A droit");

SetPosition(3,4080);

delay(2000);

Serial.println("");

// Exemple de mouvement du servomoteur ax-12

// avec la commande SetPosition(identifiant,position)

Serial.println("lancement du programme sur le servo AX-12");

Serial.println("A gauche");

SetPosition(2,200);

Serial.println("A droit");

delay(2000);

SetPosition(2,850);

Serial.println("");

}

Retour au sommaire

AX_TORQUE_ENABLE
Registre 24 en RAM

Adresse

Fonction

Exemple d’ecriture dans le registre

Objectif

R/W

pour activer / désactiver le couple au servo..

0 = Coupez le couple

1= le couple et verrouillez dans la zone RAM

Retour au sommaire

AX_LED
Registre 26 en RAM

Adresse

Fonction

Exemple d’ecriture dans le registre

Objectif

R/W

Macro pour activer / désactiver la LED sur le servo.

ax12SetRegister(1, 25, 1) ;

Allume la led

ax12SetRegister(1, 25, 0) ;

Retour au sommaire

AX_PRESENT_POSITION_L et AX_PRESENT_POSITION_H
Registre 36 et 37 en RAM

Position actuelle de votre servomoteur Dynamixel La plage de la valeur est 0 ~ 1023 (0x3FF) et l’unité est 0,29 [°].
ATTENTION : S’il est réglé sur Mode roue, la valeur ne peut pas être utilisée pour mesurer la distance de déplacement et la fréquence de rotation.

Adresse

Fonction

Exemple de lecture des registres

Objectif

Obtenir la position actuelle du servo

ax12GetRegister (1, AX_PRESENT_POSITION_L ,2);

…

Exemple de code.

//
// 
// Registre 36 et 27 vous donne la position actuelle de votre servo 
//
// registre donnant la valeur de la position actuelle du servomoteur
// La plage de la valeur est 0 ~ 1023 (0x3FF) et l'unité est 0,29 degre
// la taille de la memoire pour int est sur 2 octet soit 16 bits
   int position_l= ax12GetRegister (1, AX_PRESENT_POSITION_L ,2);
   Serial.print ("Position actuelle du servomoteur : ");
    Serial.println (position_l);
   //delay(100);  
//

// Registre 36 et 27 vous donne la position actuelle de votre servo

// registre donnant la valeur de la position actuelle du servomoteur

// La plage de la valeur est 0 ~ 1023 (0x3FF) et l'unité est 0,29 degre

// la taille de la memoire pour int est sur 2 octet soit 16 bits

int position_l= ax12GetRegister (1, AX_PRESENT_POSITION_L ,2);

Serial.print ("Position actuelle du servomoteur : ");

Serial.println (position_l);

//delay(100);

Retour au sommaire

AX_PRESENT_VOLTAGE
Registre 42 en RAM

C’est la valeur de la tension actuelle fournie. Cette valeur est 10 fois supérieure à la tension réelle. Par exemple, lorsque 10 V est fourni, la valeur des données est 100 (0x64) Si la valeur de la tension actuelle (42) est hors plage, le bit d’erreur de plage de tension (Bit0) du paquet d’état est renvoyé comme ‘1’ et l’alarme est déclenchée et définie. l’adresse 17 et réglez 1 sur le bit 0 de l’adresse 18.

Adresse	Fonction	Exemple de lecture du registre	Objectif
42	obtenir la tension actuelle du servo.	Ax12GetRegister (1, AX_PRESENT_VOLTAGE, 1)	Cette valeur est 10 fois superieur à la tension réelle il faut donc diviser la valeur par 10
	obtenir la tension actuelle du servo.	Ax12GetRegister (1, 42, 1)

Exemple de code pour lire la tension presente sur le servomoteur

// 
// Registre 42 pour obtenir la tension actuelle du servo. 
// 
// Macro pour obtenir la tension actuelle du servo.
// -> ax12GetRegister (1, AX_PRESENT_VOLTAGE, 1
// Lecture de la tension sur le servomoteur   
// Déclare la variable voltage de type "virgule-flottante",
// c'est à dire un nombre à virgule. 
  float voltage = (ax12GetRegister (1, AX_PRESENT_VOLTAGE, 1)) / 10.0;
// ou l'ecriture ci-dessous avec le numero de registre 
// float voltage = (ax12GetRegister (1, 42,1)) / 10.0;
   Serial.print("Registre42:Tension presente sur le servomoteur :");
    Serial.print (voltage);
      Serial.println (" volts.");
//

// Registre 42 pour obtenir la tension actuelle du servo.

// Macro pour obtenir la tension actuelle du servo.

// -> ax12GetRegister (1, AX_PRESENT_VOLTAGE, 1

// Lecture de la tension sur le servomoteur

// Déclare la variable voltage de type "virgule-flottante",

// c'est à dire un nombre à virgule.

float voltage = (ax12GetRegister (1, AX_PRESENT_VOLTAGE, 1)) / 10.0;

// ou l'ecriture ci-dessous avec le numero de registre

// float voltage = (ax12GetRegister (1, 42,1)) / 10.0;

Serial.print("Registre42:Tension presente sur le servomoteur :");

Serial.print (voltage);

Serial.println (" volts.");

Retour au sommaire

AX_PRESENT_TEMPERATURE
Registre 43 en RAM

Il s’agit de la température interne de DYNAMIXEL en Celsius.
La valeur des données est identique à la température réelle en degrés Celsius. Par exemple, si la valeur des données est 85 (0x55), la température interne actuelle est de 85 ° C.

Adresse	Fonction	Exemple lecture du registre	Objectif
43	obtenir la température actuelle du servo.	ax12GetRegister (1, AX_PRESENT_TEMPERATURE, 1)	la valeur donné est identique a la temperature réelle
43	obtenir la température actuelle du servo.	ax12GetRegister (1, AX_43, 1)

Exemple de code

//   
//
//Macro pour obtenir la température actuelle du servo.
//Déclare une variable de type int (pour integer, entier en anglais)
   int temperature = ax12GetRegister (1, AX_PRESENT_TEMPERATURE, 1);
//ou l'ecriture ci-dessous 
//int temperature = ax12GetRegister (1, 43, 1);  
      Serial.print ("Temperature actuelle en degres celsius : ");
       Serial.print (temperature);
         Serial.println ("") ; 
//

//Macro pour obtenir la température actuelle du servo.

//Déclare une variable de type int (pour integer, entier en anglais)

int temperature = ax12GetRegister (1, AX_PRESENT_TEMPERATURE, 1);

//ou l'ecriture ci-dessous

//int temperature = ax12GetRegister (1, 43, 1);

Serial.print ("Temperature actuelle en degres celsius : ");

Serial.print (temperature);

Serial.println ("") ;

Retour au sommaire

AX_REGISTERED_INSTRUCTION
Registre 44 en RAM

Adresse	Fonction	Exemple lecture du registre	Objectif
44	Macro permettant de savoir si le servo a une commande enregistrée	ax12GetRegister (1, AX_REGISTERED_INSTRUCTION,1); OU ax12GetRegister (1, 44,1);	Valeur = 0 L’instruction REG_WRITE n’est pas reçue
			Valeur = 1 L’instruction REG_WRITE est reçue

Exemple de code

//
//
// Macro permettant de savoir si le servo a une commande enregistrée.
// 0 = aucune commande enregistrée 1 = commande enregistrée
// Déclare une variable de type int (pour integer, entier en anglais)
    int commande_enregistree =  ax12GetRegister (1, AX_REGISTERED_INSTRUCTION,1);    
// ou l'ecriture ci-dessous
// int commande_enregistree =  ax12GetRegister (1, 44,1);
    Serial.print ("Commande enregistree : ");
    if (commande_enregistree=1) 
    {
     Serial.println ("oui");  
    }  
    else 
    {
    Serial.println ("non");
    }
//

// Macro permettant de savoir si le servo a une commande enregistrée.

// 0 = aucune commande enregistrée 1 = commande enregistrée

// Déclare une variable de type int (pour integer, entier en anglais)

int commande_enregistree = ax12GetRegister (1, AX_REGISTERED_INSTRUCTION,1);

// ou l'ecriture ci-dessous

// int commande_enregistree = ax12GetRegister (1, 44,1);

Serial.print ("Commande enregistree : ");

if (commande_enregistree=1)

{

Serial.println ("oui");

}

else

{

Serial.println ("non");

}

Retour au sommaire

AX_PAUSE_TIME

Adresse	Fonction	Exemple d’ecriture dans le registre	Objectif
45

Retour au sommaire

AX_MOVING

Adresse	Fonction	Exemple lecture du registre	Objectif
46

Retour au sommaire

Pilotage de la led sur le servomoteur avec la carte ArbotiX-M

//
//
//*************************************************************
//* 
//* IDE Arduino 1.0.6



//Cette librairies vous permet interagir avec les servos AX et MX  
//#include <BioloidController.h>



//librairie qui permet d'implémentez le code de communication série
//de bas niveau pour communiquer avec le bus Bioloid.  
#include <ax12.h>

// ---------------------------------------------------------------------------
// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
// ---------------------------------------------------------------------------
void setup()
{
  //ouvre le port série et fixe le debit de communication à 9600 bauds
  Serial.begin(9600);
  // on attent que le port de communication soit pret
  delay(1000);
  // Information a l'operateur de l'ouverture du port de communication 
  // sur le moniteur serie 
  Serial.println("========================================");
  Serial.println("Communication etablie");
  Serial.println("========================================"); 
  
}

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

{
  //Commande pour allumer la led sur le servo 
  //ax12SetRegister(1, 25, 1); 
  //1=> Correspond à l’adresse du servo cible
  //25=> Numéro de registre
  //1=> forçage de la variable a 1 la led s’allume 
  ax12SetRegister(1, 25, 1);
  delay(300);
  //Commande pour eteindre la led sur le servo 
  //ax12SetRegister(1, 25, 0); 
  //1=> Correspond à l’adresse du servo cible
  //25=> Numéro de registre
  //1=> forçage de la variable a 0 la led s’eteint 
  ax12SetRegister(1, 25, 0);
  delay(300);

//*************************************************************

//*

//* IDE Arduino 1.0.6

//Cette librairies vous permet interagir avec les servos AX et MX

//#include <BioloidController.h>

//librairie qui permet d'implémentez le code de communication série

//de bas niveau pour communiquer avec le bus Bioloid.

#include <ax12.h>

// ---------------------------------------------------------------------------

// Un programme Arduino doit impérativement contenir la fonction "setup"

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

// Elle sert à configurer globalement les entrées sorties

// ---------------------------------------------------------------------------

void setup()

{

//ouvre le port série et fixe le debit de communication à 9600 bauds

Serial.begin(9600);

// on attent que le port de communication soit pret

delay(1000);

// Information a l'operateur de l'ouverture du port de communication

// sur le moniteur serie

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

Serial.println("Communication etablie");

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

}

// ---------------------------------------------------------------------------

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

// ---------------------------------------------------------------------------

void loop()

{

//Commande pour allumer la led sur le servo

//ax12SetRegister(1, 25, 1);

//1=> Correspond à l’adresse du servo cible

//25=> Numéro de registre

//1=> forçage de la variable a 1 la led s’allume

ax12SetRegister(1, 25, 1);

delay(300);

//Commande pour eteindre la led sur le servo

//ax12SetRegister(1, 25, 0);

//1=> Correspond à l’adresse du servo cible

//25=> Numéro de registre

//1=> forçage de la variable a 0 la led s’eteint

ax12SetRegister(1, 25, 0);

delay(300);

Retour au sommaire

Exemple utilisation des moteurs Dynamixel

Robot hexapode

Retour au sommaire

Lien utile pour la carte contrôleur Arbotix

Fournisseur :

https://www.trossenrobotics.com/p/arbotix-robot-controller.aspx

Information technique :

Déscription de la table de contrôle du servo AX-12+,AX-12A par Robotis :

A savoir sur l’utilisation des informations de cette article

Les informations sur les caractéristiques et spécificités de la carte ArbotiX-M et ses interfaces associées 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

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

Grabcad Thingiverse Cults

Retour au sommaire

Servomoteur avec Feedback

Mise à jour le 04/01/2021 : Cet article traite des différentes façons d’utiliser les servomoteurs équipés d’un retour d’information appelée plus communément feedback. Continuer la lecture →

Arduino Uno wifi rev2

Mise à jour le 17/01/2020 :

Continuer la lecture →

Carte Raspberry Pi 4 B – 4 GB

Mise à jour le 13/01/2020 : La vitesse de son processeur et ses performances multimédia font du Raspberry Pi 4 B une bête de course. Il reste compatible avec son petit frère, le Raspberry Pi 3 B+.

Continuer la lecture →

Raspberry Pi3 b

Mise à jour le 09/01/2020 :Le Raspberry Pi3 est de 50 à 60 % plus performante que la carte de deuxième génération.Le Raspberry Pi3 B est un ordinateur monocarte pouvant se connecter à un téléviseur et à un clavier. Il dispose d’une connectivité WiFi et Bluetooth. Il se boote depuis la carte micro-SD et fonctionne sous OS Linux ou Windows 10 IoT.

Continuer la lecture →

Carte microcontroleur pour système embarqué

Mise à jour le 07/01/2020 : Dans cet article vous trouverez une partie des cartes microcontroleur pour système embarqué que RedOhm utilise pour ses applications , avec la documentation , les schémas , les programmes

Choisissez votre type de cartes

Carte Arduino

Arduino est une plate-forme électronique open-source composée de matériel et logiciel. Chaque aspect est conçu pour être simple, de sorte que vous puissiez apprendre à coder et à concevoir un projet rapidement et en toute simplicité.


Arduino Nano		Arduino UNO		Arduino Uno WiFi


Arduino Uno WIFI REV2		Arduino Yun 2		Arduino Mega

Carte chipKIT

La Plateforme compatible Arduino chipKIT uC32 est basée sur la populaire plateforme de prototypage en open source physique d’Arduino et y ajoute les performances du microcontrôleur Microchip PIC32.


ChipKIT Wi-FIRE

Cartes Teensy

Le Teensy est un système complet de développement de microcontrôleurs basé sur USB, dans un très faible encombrement, capable de mettre en œuvre de nombreux types de projets . Toute la programmation se fait via le port USB.


Teensy 3.2

Carte Raspberry Pi

Cette carte est destinée à encourager l’apprentissage de la programmation informatique ; elle permet l’exécution de plusieurs variantes de système d’exploitation libre GNU/Linux, notamment Debian, et des logiciels compatibles. Elle fonctionne également avec le système d’exploitation Microsoft Windows : Windows 10 IoT Core³ et celui de Google, Android Pi.


Raspberry Pi 3 B 1 GB		Raspberry Pi 3 B +		Raspberry Pi 4 B – 4 GB

CARTES LATTEPANDA

La carte de développement LattePanda est un ordinateur monocarte compatible Arduino, fonctionnant sous Windows 10 ou Linux.
Ces cartes embarquent également un ATMega32u4 compatible Arduino Leonardo se programmant directement à partir de Windows via le logiciel Arduino.


LattePanda DFR0418		Alpha 800s 8 GB DFR0545

CARTES ArbotiX-M

ArbotiX-M est au cœur de chaque robot Interbotix. Ce contrôleur de robot polyvalent est une solution de contrôle avancée pour les actionneurs basés sur BIOLOID et DYNAMIXEL mais pas que . En tant que microcontrôleur compatible Arduino, l’Arbotix bénéficie également d’une énorme communauté open source de bibliothèques et d’exemples.

ArbotiX-M

Capteur de flexion

Mise à jour le 28/12/2019 :

Sommaire :

Capteur Flexible unidirectionnel de type Flex Sensor
- Application des capteurs Flex Sensor
- Spécifications mécaniques
- Spécifications électriques
Application du capteur unidirectionnel
Definition d’un capteur Flexible bidirectionnel
Notes et références sur les capteurs de flexion

Definition d’un capteur Flexible unidirectionnel
de type Flex Sensor

Un côté du capteur est imprimé avec une encre polymère qui contient des particules conductrices. Lorsque le capteur est droit, les particules confèrent à l’encre une résistance d’environ 30k Ohms. Lorsque le capteur est plié à l’écart de l’encre, les particules conductrices s’éloignent davantage, augmentant cette résistance (à environ 50k-70K Ohms lorsque le capteur est plié à 90 ( principe de fonctionnement du capteur SEN-10264 en 2.2 pouce et le SEN-08606 en 4.5 pouce)

Capteur de flexion : Flex Sensor 2-2

Ce capteur flexible est une résistance variable pas comme les autres. La résistance du capteur de flexion augmente à mesure que le corps du composant se plie.

Les capteurs Flex sont disponibles en deux tailles: une de 2,2 « (5,588 cm) de long et une autre de 4,5 » (11,43 cm) de long .

Laissés à plat, ces capteurs ressembleront à une résistance de 30 kΩ. En se pliant, la résistance entre les deux bornes augmentera jusqu’à 70kΩ à un angle de 90 °..

Capteur de flexion : Flex Sensor 4-5

En combinant le capteur flexible avec une résistance statique pour créer un diviseur de tension , vous pouvez produire une tension variable qui peut être lue par le convertisseur analogique-numérique d’un microcontrôleur.

Application des capteurs Flex Sensor

Robotique
Jeux (Virtual Motion)
Équipement médical
Périphériques d’ordinateur
Instruments de musique
Thérapie physique

Spécifications mécaniques du Flex Sensor

Cycle de vie : > 1 million
Epaisseur : 0,43 mm (0,017 « )
Plage de température : -35 ° C à + 80 ° C

Spécifications électriques du capteur Flex Sensor

Résistance à plat : 10K Ohms ± 30%
Résistance à la flexion : minimum 2 fois supérieure à la résistance à plat à 180 ° de pincement.
Puissance nominale : 0,5 watts en continu; 1 Watt de pointe

Retour au sommaire

Application du capteur unidirectionnel

.

Retour au sommaire

Definition d’un capteur Flexible Bidirectionnel

Le Capteur Flexible Bidirectionnel est constitué d’un substrat revêtu, tel que le plastique, dont la conductivité électrique est modifiée lorsqu’il se plie. Les systèmes électroniques se connectent au capteur et mesure de manière précise la quantité de flexion ou de mouvement qui se produit. La conception de la couche unique du capteur flexible élimine la plupart des problèmes associés aux capteurs classiques, tels que la poussière, la saleté, les liquides ainsi que les effets de la chaleur et de la pression. Les surlaminés ou le surmoulage peuvent également être appliqués aux capteurs pour augmenter leur protection contre l’environnement.

Permet de mesurer le mouvement mécanique, le débit d’air, le débit d’eau et même les vibrations.
Peut être utilisé comme capteur de mouvement ou comme interrupteur très résistant et très fiable.
Ne comporte aucune pièce mobile et est complètement silencieux en fonctionnement

Retour au sommaire

Notes et références sur les capteurs de flexion

Fournisseur :

https://www.robotshop.com
https://learn.sparkfun.com

Information technique :

sparkfun pour le capteur unidirectionnel
spectrasymbol.com pour les capteurs de type FS2L095

en cours de réalisation

Retour au sommaire

Le langage Arduino :Les chaînes de caractères « string »

Mise à jour le 10/02/2023 : Une chaîne de caractères (appelée string en anglais) est une suite de caractères, c’est-à-dire un ensemble de symboles faisant partie du jeu de caractères, défini par le code ASCII. Voici donc une chaîne de caractère ou string => « bonjour »

Continuer la lecture →