Archives de l’auteur : Hervé Mazelin

Arduino avec la Camera Sen0305 , la reconnaissance faciale

Mise à jour le 11/09/2021 : Dans cet article vous trouverez les caractéristiques principales du module AI HuskyLens Gravity SEN0305 avec utilisation de la reconnaissance faciale .

Sommaire :

En cours de realisation
Présentation du module AI HuskyLens Gravity SEN0305
Programme de reconnaissance faciale, de suivis de visage et du mode patrouille
Retour au sommaire.

Retour au sommaire

Présentation du module AI HuskyLens Gravity SEN0305

Le HuskyLens Gravity est un capteur visuel intelligent, économique, simple d’utilisation basé sur une caméra OV2640 associée à un afficheur 2″ IPS et à un processeur Kendryte K210.

Grâce au port UART / I2C, HuskyLens peut se connecter à Arduino et micro:bit pour vous aider à réaliser des projets très créatifs sans jouer avec des algorithmes complexes.

Spécification :

Processeur : Kendryte K210
Capteur d’images : Objectif Husky SEN0305 : OV2640 (appareil photo 2,0 mégapixels).
Tension d’alimentation : 3,3 ~ 5,0 V
Consommation : 320 mA à 3,3 V , 230 mA à 5,0 V (mode de reconnaissance faciale ; luminosité du rétroéclairage à 80 % ; lumière d’ appoint éteinte).
Port de communication : UART ; I2C
Affichage : écran IPS de 2,0 pouces avec une résolution de 320*240
Algorithmes intégrés : reconnaissance faciale, suivi d’objets, reconnaissance d’objets, suivi de lignes, reconnaissance de couleurs, reconnaissance de balises, classification d’objets
Dimensions : 52 mm x 44,5 mm (2,05 * 1,75 pouces)

Retour au sommaire

Programme de reconnaissance faciale, de suivis de visage et du mode patrouille

//
//
// *********************************************
//
// reconnaissance faciale
//  suivis de visage reconnu
//   mode patrouille 
//
// Arduino avec la Camera Sen0305
//
// 
// Code Modifié : Mazelin H
// RedOhm 
// Le 01/09/2021
// *********************************************



//  À utiliser pour déterminer s'il s'agit d'une flèche ou d'un bloc
//  -> COMMAND_RETURN_BLOCK : C'est un bloc
//  -> COMMAND_RETURN_ARROW : C'est une flèche
//
// Pour un bloc :
// xCenter : X Centre du bloc
// yCenter : Centre Y du bloc
// width : Largeur du bloc
// height : Hauteur du bloc

#include <Servo.h>
#include "HUSKYLENS.h"

HUSKYLENS huskylens;

void printResult(HUSKYLENSResult result);

// Variable de passage 
int passage_setup = 0 ;

// Crée un objet de type "Servo_X", nommé -> Servo_X
Servo servo_x;
Servo servo_y;

int position_x = 90 ;
int position_y = 90 ;

// variable pour le calcul de l'erreur de positionnement en x 
int erreur_x;
 // Variable pour La grandeur réglante en x. La valeur réglante est la grandeur de  
 // commande qui a été choisie pour contrôler la grandeur réglée
 int valeur_reglante_x;
// variable pour le calcul de l'erreur de positionnement en y 
int erreur_y; 
 // Variable pour La grandeur réglante en y. La valeur réglante est la grandeur de  
 // commande qui a été choisie pour contrôler la grandeur réglée
 int valeur_reglante_y;
// position du mode patrouille
int pos ;
 

// **********************************************************************
// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécutée 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 : le terminal côté PC doit être réglé sur la même valeur.
    Serial.begin(115200);
    // on attent que le port de communication soit pret
    while (!Serial) {
     ; 
    }

    
    // communication i2c
    Wire.begin();
    while (!huskylens.begin(Wire))
    {
        Serial.println(F("Échec du démarrage!"));
        Serial.println(F("1.Veuillez revérifier le \"Protocol Type\" in HUSKYLENS (General Settings>>Protocol Type>>I2C)"));
        Serial.println(F("2.Veuillez revérifier la connexion."));
        delay(100);
    }
   
// associe le servomoteur x à la broche 9   
   servo_x.attach(9);
 // associe le servomoteur x à la broche 9     
    servo_y.attach(8);
    delay(15);
// Positionne mes servomteurs à 90 (phase d'initialisation) 
   servo_x.write(position_x);
   servo_y.write(position_y);
// Réalise une pause dans l'exécution du programme pour une durée 
// de 50 millisecondes
// permettant au servomoteur d'atteindre sa position  
   delay(50);
} 



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

    
    // verifie la connexion
    if (!huskylens.request())
    {
      Serial.println(F("Échec de la demande de données à HUSKYLENS, revérifiez la connexion!"));
    }

    // controle si le module possède des enregistrements  
    else if(!huskylens.isLearned())
    {
      Serial.println(F("Je suis desolé il faut appuyer sur le bouton d'apprentissage "));
    }
    
    // on verifie si le systeme ne detecte rien dans son champs de vision 
    else if(!huskylens.available())
    {
      Serial.println(F("Aucun bloc ou flèche n'apparaît à l'écran! Oryon ne detecte rien "));
      
      // mise en service du mode patrouille 
      // pour la recherche d'un visage 
      // x < y (position_x est inferieur à y)
      if (( position_x < 170)&&( pos == 0))  
      {
      position_x = position_x +1;      
      servo_x.write(position_x);
      
      }  
      else if (( position_x < 171)&&(position_x > 10))
      {
      pos = 1 ;
      position_x = position_x -1;      
      servo_x.write(position_x);   
      }
      else if (position_x <= 10)
      {
      pos=0;  
      }
      delay(20);
      Serial.println (position_x);
    }
    
    else
    {
        Serial.println(F("###########"));
        while (huskylens.available())
        {
            HUSKYLENSResult result = huskylens.read();
            printResult(result);

            
           
        }    
    }
}


//
void printResult(HUSKYLENSResult result){
    if (result.command == COMMAND_RETURN_BLOCK){
          Serial.println(String()+F("Block:xCenter=")+result.xCenter+F(",yCenter=")+result.yCenter+F(",width=")+result.width+F(",height=")+result.height+F(",ID=")+result.ID);
           
           
            // Deplacement de la camera sur horizontal cote droit 
            // 
            // x > y (result.xCenter est supérieur à y)
            if (result.xCenter > 165)
            {
              
              // calcul de l'erreur de positionnement 
              erreur_x = result.xCenter - 165 ; 
              // valeur_reglante
              valeur_reglante_x= map(erreur_x,1,50,1,5);
              position_x =position_x+valeur_reglante_x ;
              servo_x.write(position_x);  
            }

            // Deplacement de la camera sur horizontal cote gauche 
            // 
            else if ( result.xCenter < 155)
            {  
              // calcul de l'erreur de positionnement 
              erreur_x = 155 - result.xCenter ;
              // valeur_reglante
              // map -> Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette
              // map (valeur, limite_basse_source, limite_haute_source, limite_basse_destination, limite_haute_destination)
              valeur_reglante_x= map(erreur_x,1,50,1,5);
              position_x = position_x - valeur_reglante_x ;
              
              servo_x.write(position_x);  
            }

            
            else if ((result.xCenter > 165)&&( result.xCenter < 155))
            {

            servo_x.write(position_x); 
            
            }
            // si la camera est trop haut
            if (result.yCenter < 115) 
            {
              // calcul de l'erreur de positionnement 
              erreur_y = 115-result.yCenter  ; 
              // valeur_reglante
              valeur_reglante_y= map(erreur_y,1,50,1,5); 
              position_y = position_y + valeur_reglante_y ;
              servo_y.write(position_y);       
            }

            // si la camera est trop basse 
            else if ( result.yCenter > 125)
            {  
              // calcul de l'erreur de positionnement pour la camera trop basse 
              erreur_y = result.yCenter -125  ; 
              // valeur_reglante
              valeur_reglante_y= map(erreur_y,1,50,1,5); 
              position_y = position_y -valeur_reglante_y ;
              servo_y.write(position_y);  
            }

           // Temporisation de stabilité 
           delay (100);
             
           
           // affectation du resultat a un prenom ( a une personne )
           if (result.ID == 1 )
           {
            Serial.println ("Bonjour Louis");
           }
           else if (result.ID == 2 ) 
           {
            Serial.println ("Bonjour Timeo");
           } 
           else if (result.ID == 3 ) 
           {
            Serial.println ("Bonjour au grand maitre ");
           } 
           else if (result.ID == 4 ) 
           {
            Serial.println ("Salut Johann ");
           }
           else if (result.ID == 5 ) 
           {
            Serial.println ("Bonjour Marie");
      
      
           }

    }      
    
    else if (result.command == COMMAND_RETURN_ARROW){
        Serial.println(String()+F("Arrow:xOrigin=")+result.xOrigin+F(",yOrigin=")+result.yOrigin+F(",xTarget=")+result.xTarget+F(",yTarget=")+result.yTarget+F(",ID=")+result.ID);
        
    }
    else{
        Serial.println("Objet inconnu!");
    }   
     
}

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

259

260

261

262

263

264

265

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

// reconnaissance faciale

// suivis de visage reconnu

// mode patrouille

// Arduino avec la Camera Sen0305

// Code Modifié : Mazelin H

// RedOhm

// Le 01/09/2021

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

// À utiliser pour déterminer s'il s'agit d'une flèche ou d'un bloc

// -> COMMAND_RETURN_BLOCK : C'est un bloc

// -> COMMAND_RETURN_ARROW : C'est une flèche

// Pour un bloc :

// xCenter : X Centre du bloc

// yCenter : Centre Y du bloc

// width : Largeur du bloc

// height : Hauteur du bloc

#include <Servo.h>

#include "HUSKYLENS.h"

HUSKYLENS huskylens;

void printResult(HUSKYLENSResult result);

// Variable de passage

int passage_setup = 0 ;

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

Servo servo_x;

Servo servo_y;

int position_x = 90 ;

int position_y = 90 ;

// variable pour le calcul de l'erreur de positionnement en x

int erreur_x;

// Variable pour La grandeur réglante en x. La valeur réglante est la grandeur de

// commande qui a été choisie pour contrôler la grandeur réglée

int valeur_reglante_x;

// variable pour le calcul de l'erreur de positionnement en y

int erreur_y;

// Variable pour La grandeur réglante en y. La valeur réglante est la grandeur de

// commande qui a été choisie pour contrôler la grandeur réglée

int valeur_reglante_y;

// position du mode patrouille

int pos ;

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

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

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

Serial.begin(115200);

// on attent que le port de communication soit pret

while (!Serial) {

;

}

// communication i2c

Wire.begin();

while (!huskylens.begin(Wire))

{

Serial.println(F("Échec du démarrage!"));

Serial.println(F("1.Veuillez revérifier le \"Protocol Type\" in HUSKYLENS (General Settings>>Protocol Type>>I2C)"));

Serial.println(F("2.Veuillez revérifier la connexion."));

delay(100);

}

// associe le servomoteur x à la broche 9

servo_x.attach(9);

// associe le servomoteur x à la broche 9

servo_y.attach(8);

delay(15);

// Positionne mes servomteurs à 90 (phase d'initialisation)

servo_x.write(position_x);

servo_y.write(position_y);

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

// de 50 millisecondes

// permettant au servomoteur d'atteindre sa position

delay(50);

}

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

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

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

void loop() {

// verifie la connexion

if (!huskylens.request())

{

Serial.println(F("Échec de la demande de données à HUSKYLENS, revérifiez la connexion!"));

}

// controle si le module possède des enregistrements

else if(!huskylens.isLearned())

{

Serial.println(F("Je suis desolé il faut appuyer sur le bouton d'apprentissage "));

}

// on verifie si le systeme ne detecte rien dans son champs de vision

else if(!huskylens.available())

{

Serial.println(F("Aucun bloc ou flèche n'apparaît à l'écran! Oryon ne detecte rien "));

// mise en service du mode patrouille

// pour la recherche d'un visage

// x < y (position_x est inferieur à y)

if (( position_x < 170)&&( pos == 0))

{

position_x = position_x +1;

servo_x.write(position_x);

}

else if (( position_x < 171)&&(position_x > 10))

{

pos = 1 ;

position_x = position_x -1;

servo_x.write(position_x);

}

else if (position_x <= 10)

{

pos=0;

}

delay(20);

Serial.println (position_x);

}

else

{

Serial.println(F("###########"));

while (huskylens.available())

{

HUSKYLENSResult result = huskylens.read();

printResult(result);

}

void printResult(HUSKYLENSResult result){

if (result.command == COMMAND_RETURN_BLOCK){

Serial.println(String()+F("Block:xCenter=")+result.xCenter+F(",yCenter=")+result.yCenter+F(",width=")+result.width+F(",height=")+result.height+F(",ID=")+result.ID);

// Deplacement de la camera sur horizontal cote droit

// x > y (result.xCenter est supérieur à y)

if (result.xCenter > 165)

{

// calcul de l'erreur de positionnement

erreur_x = result.xCenter - 165 ;

// valeur_reglante

valeur_reglante_x= map(erreur_x,1,50,1,5);

position_x =position_x+valeur_reglante_x ;

servo_x.write(position_x);

}

// Deplacement de la camera sur horizontal cote gauche

else if ( result.xCenter < 155)

{

// calcul de l'erreur de positionnement

erreur_x = 155 - result.xCenter ;

// valeur_reglante

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

// map (valeur, limite_basse_source, limite_haute_source, limite_basse_destination, limite_haute_destination)

valeur_reglante_x= map(erreur_x,1,50,1,5);

position_x = position_x - valeur_reglante_x ;

servo_x.write(position_x);

}

else if ((result.xCenter > 165)&&( result.xCenter < 155))

{

servo_x.write(position_x);

}

// si la camera est trop haut

if (result.yCenter < 115)

{

// calcul de l'erreur de positionnement

erreur_y = 115-result.yCenter ;

// valeur_reglante

valeur_reglante_y= map(erreur_y,1,50,1,5);

position_y = position_y + valeur_reglante_y ;

servo_y.write(position_y);

}

// si la camera est trop basse

else if ( result.yCenter > 125)

{

// calcul de l'erreur de positionnement pour la camera trop basse

erreur_y = result.yCenter -125 ;

// valeur_reglante

valeur_reglante_y= map(erreur_y,1,50,1,5);

position_y = position_y -valeur_reglante_y ;

servo_y.write(position_y);

}

// Temporisation de stabilité

delay (100);

// affectation du resultat a un prenom ( a une personne )

if (result.ID == 1 )

{

Serial.println ("Bonjour Louis");

}

else if (result.ID == 2 )

{

Serial.println ("Bonjour Timeo");

}

else if (result.ID == 3 )

{

Serial.println ("Bonjour au grand maitre ");

}

else if (result.ID == 4 )

{

Serial.println ("Salut Johann ");

}

else if (result.ID == 5 )

{

Serial.println ("Bonjour Marie");

}

else if (result.command == COMMAND_RETURN_ARROW){

Serial.println(String()+F("Arrow:xOrigin=")+result.xOrigin+F(",yOrigin=")+result.yOrigin+F(",xTarget=")+result.xTarget+F(",yTarget=")+result.yTarget+F(",ID=")+result.ID);

}

else{

Serial.println("Objet inconnu!");

}

Pilotage d’un moteur pas à pas avec frein

Mise à jour le 10/07/2021 .

Continuer la lecture →

Arduino comment créer un fichier sur une carte SD

Mise à jour le 14/06/2021 : La librairie SD sur Arduino permet de créer un fichier sur une carte SD , de lire et d’écrire ce même fichier .

Continuer la lecture →

Comment stocker des valeurs de plusieurs Octets

Mise à jour le 28/05/2021 : Comment traiter le stockage d’informations en mémoire EEPROM sur arduino

Sommaire :

But du tutoriel
Principe de capture et d’ecriture
Programme pour l’écriture et la lecture de la mémoire EEPROM
Pour tout probléme
Retour au menu principal
en cours de realisation

But du tutoriel

Dans le cadre du projet Oryon nous avons une partie programmation pour le système d’apprentissage du cobot. Le principe de l’apprentissage et d’enseigner au cobot les mouvements que l’on souhaite qu’il réalise en le manipulant simplement, et d’enregistrer des différents mouvements dans une mémoire afin qu’il nous les restitue quand on lui demande

Pour que l’on utilise le mode d’apprentissage il faut déjà ecrire un programme qui nous permettra que ce mode nous retranscrive automatiquement les déplacements de celui-ci. Voici un petit programme qui nous permet déjà d’avoir un petit aperçu de ce mode de stockage. La difficulté sur arduino étend de récupérer les valeurs du convertisseur 10 bits et de stocker la valeur des 2 octets en une seule fois dans la mémoire

Retour au sommaire

Principe de capture et d’ecriture en EEPROM de plusieurs octets

Retour au sommaire

.

Programme pour l’ecriture et la lecture en EEPROM de plusieurs octets

//
//
//******************************************************
//
//But : Lecture d'une valeur de 10 bits et enregistrement  
//      de celle-ci en memoire EEPROM
//
// Par H-Mazelin
// RedOhm
// Le 26/05/2021
//******************************************************


#include <EEPROM.h>


// le potentiomètre, branché sur la broche analogique 6
 int potentiometre1 = 6;
//int address = 0 ;
 int valeur_eeprom ;


// *************************************************************
// Declaration des entrees et des sorties pour l'enregistrement 
const int Led_enregistrement = 25 ;

// déclaration de l'entrée du bouton branché sur la broche 15
// de votre carte Arduino 
int bouton15 = 15;
// variable du type int pour stocker les valeurs de passage du bouton15
int bouton15v;



// *************************************************************
// Declaration des entrees et des sorties la lecture 
const int Led_lecture = 26;


// déclaration de l'entrée du bouton branché sur la broche 16
// de votre carte Arduino 
int bouton16 = 16;
// variable du type int pour stocker les valeurs de passage du bouton16
int bouton16v;





void setup() {
  
//****************************************
//Mise en service du port de com 
//****************************************

//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  
  while (!Serial) {
    ; 
  }

//****************************************
//Configuration des entrees pour les boutons de selection
//****************************************
pinMode (bouton15,INPUT );
pinMode (bouton16,INPUT );
  
//****************************************
//Configuration des sorties pour les Led
//****************************************
pinMode (Led_enregistrement,OUTPUT );
pinMode (Led_lecture,OUTPUT );

  
}

void loop() {


// ****************************************************
// creation de la commande enregistrement 
// ****************************************************

bouton15v = digitalRead(bouton15);

  if (bouton15v == 1)
  {
    digitalWrite (Led_enregistrement,HIGH);
    // appel de la fonction -> lecture de la position du servomoteur
    lecture_position();
  }
  
  else if (bouton15v == 0)
  {
  digitalWrite (Led_enregistrement,LOW);    
  } 

// ****************************************************
// creation de la commande de lecture
// ****************************************************
   
bouton16v = digitalRead(bouton16);
 



  if (bouton16v == 1)
  {
    digitalWrite (Led_lecture,HIGH);
    // appel de la fonction -> lecture de la memoire
    lecture_memoire_et_pilotage_servomoteur();
  }
  
  else if (bouton16v == 0)
  {
    digitalWrite (Led_lecture,LOW);
  } 
 
}


// Creation de la fonction lecture_position
// 
//*******************************************************
// Lecture des positions du servomoteur et enregistrement
//*******************************************************
//

void lecture_position()
{
 
Serial.println(" Attention lecture de la position et ecriture de la memoire dans 5 secondes : ");
delay (5000);
Serial.print ("");
Serial.println("c'est parti");



for (int i=0 ; i <= 32 ; i=i+2)
{
    
    
    // conversion de la tension de la borne 6 et transfert de la valeur 
    // numerique dans la variable valeur_eeprom

    valeur_eeprom=analogRead(potentiometre1); 
    delay(20);
    Serial.print("ecriture a l'adresse : ");Serial.print(i);
    Serial.print(" de la valeur => ");Serial.println(valeur_eeprom);
    // EEPROM.put permet d'ecrire n'importe quel type de données ou objet dans l'EEPROM.
    // la valeur de i permet de pointer l'adresse pour stocker la valeur 
    EEPROM.put (i,valeur_eeprom);
    delay(200); 
 }

    bouton15v == 0; 
    Serial.println("Fin d'enregistrement");
    delay(2000);
}



 
//********************************
// Lecture de la memoire EEPROM 
//********************************
//
// Creation de la fonction lecture_memoire_et_pilotage_servomoteur

void lecture_memoire_et_pilotage_servomoteur()
{
Serial.println("");
Serial.println(" Attention lecture de la memoire EEPROM dans 5 secondes");
delay (5000);

for (int i=0 ; i <= 32 ; i=i+2)
{
   
  // lire un octet à partir de l'adresse specifie dans la variable i
  EEPROM. get ( i , valeur_eeprom ) ;
  delay (100);
  Serial.print(i);
  Serial.print("\t");
  Serial.print(valeur_eeprom);
  Serial.println();
  
 }
  
 delay(500);
 bouton16v == 0;
 Serial.println("Fin de lecture ");
}

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

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

//But : Lecture d'une valeur de 10 bits et enregistrement

// de celle-ci en memoire EEPROM

// Par H-Mazelin

// RedOhm

// Le 26/05/2021

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

#include <EEPROM.h>

// le potentiomètre, branché sur la broche analogique 6

int potentiometre1 = 6;

//int address = 0 ;

int valeur_eeprom ;

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

// Declaration des entrees et des sorties pour l'enregistrement

const int Led_enregistrement = 25 ;

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

// de votre carte Arduino

int bouton15 = 15;

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

int bouton15v;

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

// Declaration des entrees et des sorties la lecture

const int Led_lecture = 26;

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

// de votre carte Arduino

int bouton16 = 16;

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

int bouton16v;

void setup() {

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

//Mise en service du port de com

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

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

while (!Serial) {

;

}

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

//Configuration des entrees pour les boutons de selection

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

pinMode (bouton15,INPUT );

pinMode (bouton16,INPUT );

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

//Configuration des sorties pour les Led

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

pinMode (Led_enregistrement,OUTPUT );

pinMode (Led_lecture,OUTPUT );

}

void loop() {

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

// creation de la commande enregistrement

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

bouton15v = digitalRead(bouton15);

if (bouton15v == 1)

{

digitalWrite (Led_enregistrement,HIGH);

// appel de la fonction -> lecture de la position du servomoteur

lecture_position();

}

else if (bouton15v == 0)

{

digitalWrite (Led_enregistrement,LOW);

}

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

// creation de la commande de lecture

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

bouton16v = digitalRead(bouton16);

if (bouton16v == 1)

{

digitalWrite (Led_lecture,HIGH);

// appel de la fonction -> lecture de la memoire

lecture_memoire_et_pilotage_servomoteur();

}

else if (bouton16v == 0)

{

digitalWrite (Led_lecture,LOW);

}

// Creation de la fonction lecture_position

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

// Lecture des positions du servomoteur et enregistrement

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

void lecture_position()

{

Serial.println(" Attention lecture de la position et ecriture de la memoire dans 5 secondes : ");

delay (5000);

Serial.print ("");

Serial.println("c'est parti");

for (int i=0 ; i <= 32 ; i=i+2)

{

// conversion de la tension de la borne 6 et transfert de la valeur

// numerique dans la variable valeur_eeprom

valeur_eeprom=analogRead(potentiometre1);

delay(20);

Serial.print("ecriture a l'adresse : ");Serial.print(i);

Serial.print(" de la valeur => ");Serial.println(valeur_eeprom);

// EEPROM.put permet d'ecrire n'importe quel type de données ou objet dans l'EEPROM.

// la valeur de i permet de pointer l'adresse pour stocker la valeur

EEPROM.put (i,valeur_eeprom);

delay(200);

}

bouton15v == 0;

Serial.println("Fin d'enregistrement");

delay(2000);

}

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

// Lecture de la memoire EEPROM

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

// Creation de la fonction lecture_memoire_et_pilotage_servomoteur

void lecture_memoire_et_pilotage_servomoteur()

{

Serial.println("");

Serial.println(" Attention lecture de la memoire EEPROM dans 5 secondes");

delay (5000);

for (int i=0 ; i <= 32 ; i=i+2)

{

// lire un octet à partir de l'adresse specifie dans la variable i

EEPROM. get ( i , valeur_eeprom ) ;

delay (100);

Serial.print(i);

Serial.print("\t");

Serial.print(valeur_eeprom);

Serial.println();

}

delay(500);

bouton16v == 0;

Serial.println("Fin de lecture ");

}

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

R2-D2 Anneau 1 et base

Mise à jour le 23/04/2021 : Voici les plans de montage du robot R2-D2 pour l’anneau 1 et la base .

Continuer la lecture →

R2-D2 – panneau arrière

Mise à jour le 23/04/2021 : Voici les plans de montage du robot R2-D2 pour le panneau arrière qui nous donne accès au système électronique du robot. Les fichiers n’appartiennent pas à RedOhm pour cela ,il faut s’inscrire sur le lien ci-dessous.
https://www.patreon.com/mrbaddeley

Seules les modifications réalisées par RedOhm sont disponibles sur le site :

https://www.redohm.fr/

Sommaire :

Fiche 002 : Panneau superieur
Fiche 003 : Panneau inferieur
Pour tout probléme
Retour au menu

002 – Panneau superieur

Retour au sommaire

003 – Panneau inferieur

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

Menu R2D2

Les fichiers STL n’appartiennent pas à RedOhm pour cela ,il faut s’inscrire sur le lien ci-dessous.
https://www.patreon.com/mrbaddeley

Seules les modifications réalisées par RedOhm sont disponibles sur le site ainsi que la documentation de montage qui est de RedOhm :

https://www.redohm.fr/

Sommaire principal :

Présentation de R2D2
Anneau 1 avec base
Panneau arriére qui donne accés au système électronique
Retour au menu nos robot

Pilotage d’un moteur pas à pas avec un joystick

Mise à jour le 03/03/2021 :

Sommaire :

Principe de fonctionnement
Programme pour le pilotage d’un moteur pas à pas avec Arduino et un joystick
Vidéo pour le tuto
Pour tout probléme
Retour au menu

Principe de fonctionnement

Le but de ce tutoriel est de piloter un moteur pas à pas avec un joystick.

Nous verrons comment définir la valeur des positions de notre joystick pour créer un mouvement de marche avant ou de marche arrière et de conserver le couple maintien quand notre manipulateur est dans un état statique.

Dans le programme vous pourrez retrouver :

La création d’un générateur d’impulsion qui nous permettra de définir la vitesse et le déplacement du moteur pas à pas

La gestion du couple maintien par l’intermédiaire d’un bouton

Et enfin le pilotage du moteur pas à pas en avant et en arrière avec le joystick par l’intermédiaire de la borne DIR se trouvant sur notre driver

Retour au sommaire

Programme pour le pilotage d’un moteur pas à pas avec Arduino
et un joystick

//
//
//***********************************************************
// RedOhm
// le 06/02/2021
// 
// Pilotage d'un moteur pas a pas avec joystick
// 
// 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
// 4 - Pilotage avec un Joystik 
//  
// 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.13 
//**********************************************************

// 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 15
// pour le debrayage du moteur
int bouton_debrayage = 15;
int bouton_debrayage_v;

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

// declaration de l'entree analogique 6 pour l'axe x
int JoyStick_X = 6; // axe x 

// declaration de la vitesse du joystick
int vitesse=0 ;


/*
 *  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 les voyants
  pinMode(bouton_debrayage,INPUT);
  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 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 **********
 



// *******************************************
//      Traitement du JoyStick
// ******************************************* 

int x;
// Lecture de l'entree analogique 
x=analogRead(JoyStick_X);
 if ((x>501)&&(x<518)&&(bouton_debrayage_v==0))
 {
 digitalWrite(voyant_vert_mar,LOW);   
 digitalWrite(voyant_rouge_arr,LOW);
 digitalWrite(ENA,HIGH);
 digitalWrite(DIR,HIGH); 
 digitalWrite(PUL,HIGH);   
 }
// si x est superieur a 520  les instructions comprises
// entre les accolades sont exécutées. 
else if (x>520)
{
 // Marche arriere 
 digitalWrite(voyant_vert_mar,LOW);   
 digitalWrite(voyant_rouge_arr,HIGH);
 digitalWrite(ENA,HIGH);
 digitalWrite(DIR,HIGH);
 vitesse = map ( x,520,1023,3500,5); 
 deplacement();
 
}
// sinon si x est inferieur a 500  les instructions comprises
// entre les accolades sont exécutées. 
else if (x<500)
{
 // Marche avant
 digitalWrite(voyant_rouge_arr,LOW);
 digitalWrite(voyant_vert_mar,HIGH);
 digitalWrite(DIR,LOW);
 digitalWrite(ENA,HIGH);
 vitesse = map ( x,500,0,3500,5); 
 deplacement();
}

// ***** Fin du traitement du JoyStick *********


}


//==============================================
//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>vitesse)
{
//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

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

// RedOhm

// le 06/02/2021

// Pilotage d'un moteur pas a pas avec joystick

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

// 4 - Pilotage avec un Joystik

// 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.13

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

// 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 15

// pour le debrayage du moteur

int bouton_debrayage = 15;

int bouton_debrayage_v;

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

// declaration de l'entree analogique 6 pour l'axe x

int JoyStick_X = 6; // axe x

// declaration de la vitesse du joystick

int vitesse=0 ;

* 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 les voyants

pinMode(bouton_debrayage,INPUT);

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

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

// Traitement du JoyStick

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

int x;

// Lecture de l'entree analogique

x=analogRead(JoyStick_X);

if ((x>501)&&(x<518)&&(bouton_debrayage_v==0))

{

digitalWrite(voyant_vert_mar,LOW);

digitalWrite(voyant_rouge_arr,LOW);

digitalWrite(ENA,HIGH);

digitalWrite(DIR,HIGH);

digitalWrite(PUL,HIGH);

}

// si x est superieur a 520 les instructions comprises

// entre les accolades sont exécutées.

else if (x>520)

{

// Marche arriere

digitalWrite(voyant_vert_mar,LOW);

digitalWrite(voyant_rouge_arr,HIGH);

digitalWrite(ENA,HIGH);

digitalWrite(DIR,HIGH);

vitesse = map ( x,520,1023,3500,5);

deplacement();

}

// sinon si x est inferieur a 500 les instructions comprises

// entre les accolades sont exécutées.

else if (x<500)

{

// Marche avant

digitalWrite(voyant_rouge_arr,LOW);

digitalWrite(voyant_vert_mar,HIGH);

digitalWrite(DIR,LOW);

digitalWrite(ENA,HIGH);

vitesse = map ( x,500,0,3500,5);

deplacement();

}

// ***** Fin du traitement du JoyStick *********

}

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

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

{

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

Vidéo pour le tuto

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

Robotis

Sommaire

Dynamixel changement de l’identifiant.
Harmonisation de la vitesse de communication entre actionneur et la carte
Lecture des registres de deplacement et de déverrouillage du couple.
Pilotage de moteur Dynamixel par joystick
Pour tout probléme
Retour au menu Vidéo.

2020/09/02 Changement de l’identifiant

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 . Cette carte est compatible avec l’IDE Arduino.

Retour au sommaire

2020/09/18 harmonisation de la vitesse de communication
entre actionneur et la carte

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.

Retour au sommaire

2020/11/02 Lecture du registre de déplacement et de
déverouillage du couple

Dans le cadre de ce tutoriel nous allons vous initiez à lire les registres se trouvant à l’intérieur du servomoteur qui nous permet de définir le déplacement de notre servo , ceci afin de déterminer la butée basse et haute que l’on devra appliquer par logiciel pour des deplacements future ainsi que le déverouillage du registre de couple .

Retour au sommaire

2021/01/03 Pilotage de moteur Dynamixel par Joystick

Ce tutoriel a pour but de vous initier à la programmation des servomoteurs Dynamixel . Nous avons pris comme base la tête de L3 -37 qui est une réalisation de RedOhm pour vous expliquer l’étalonnage et le fonctionnement pour piloter celle-ci avec un joystick. Le tuto s’articule en 4 phases : la première étant la présentation de la base de la tête, le câblage d’un joystick et la carte contrôleur, vous avez aussi une explication sur le fonctionnement de la manette de jeu, et enfin une explication détaillée du programme. Vous pourrez récupérer le programme sur notre site RedOhm.fr celui-ci est abondamment commenté.

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

Moteur pas à pas et Arduino

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