Archives par étiquette : arduino

Sommaire :

2023-01-08 : Contrôler votre Smartphone avec le capteur de luminosité
2022-11-05 : 1/5 – Mit inventor creation d’un joystick analogique pour Arduino
2023-01-19 : 2/5 – Mit inventor un joystick analogique pour Arduino ,decryptage de la chaine de positionnnement .
2022-10-11 : Mit Inventor création d’un controlPad
2022-10-08 : Communication en bluetooth d’une tablette vers Arduino
2022-09-16 : Mit inventor le changement de page
Retour au menu Vidéo

2023-01-08- Mit inventor contrôler votre Smartphone avec le capteur de luminosité

Dans ce tutoriel, nous allons étudier sur Mit Inventor comment contrôler votre smartphone avec le capteur de luminosité ou bien retranscrire ces informations vers votre carte Arduino ou tout autre carte microcontrôleur. Avec ce type de capteur, nous pouvons créer un luxmètre ou d’autres applications qui réagissent avec la lumière. On peut bien évidemment s’en servir aussi comme capteur de proximité

télécharger les fichiers Retour au sommaire

2022-11-05- Mit inventor creation d’un joystick analogique pour
Arduino – 1/5

Dans ce tutoriel nous allons étudier sur Mit Inventor comment créer un joystick analogique sur votre tablette ou sur un smartphone afin de pouvoir piloter en Bluetooth une unité mobile avec la carte microcontrôleur Arduino. Vous aurez donc un ensemble de 5 tutoriels traitant de ce type de pilotage.

télécharger les fichiers Retour au sommaire

2023-01-19- Mit inventor un joystick analogique pour Arduino decryptage de la chaine de positionnnement 2/5

Dans ce tutoriel, nous allons étudier comment décrypter une chaîne de caractères de type String envoyé par Bluetooth depuis votre smartphone ou votre tablette vers arduino. Cette chaîne sera donc décryptée par arduino pour extraire les valeurs x et y de déplacement du joystick virtuel de votre application nous permettant de piloter un robot mobile , une plateforme ou tout autre objet qui peut être piloté . Cette vidéo nous permet de mettre en lumière les fonctions ou les méthodes à utiliser comme indexOf , concat ,substring.

Retour au sommaire

2022-10-08- Communication en bluetooth d’une tablette vers Arduino avec Mit Inventor

Dans ce tuto ,nous allons travailler sur la communication entre une tablette sous Android et une carte Arduino équipée d’une carte bluetooth de type HC06

Nous allons donc étudier la partie interface sous Mit App Inventor pour la tablette et le traitement des informations avec l’ide Arduino

télécharger les fichiers . Retour au sommaire

2022-09-16- Mit inventor le changement de page

Vous trouverez dans cette vidéo les informations nécessaires pour la création de plusieurs pages sur Mit Inventor et surtout la possibilité de naviguer entre elle.

Mit App Inventor est un soft pour la création d’applications pour toutes les plateformes basées sur Microsoft , qui évite le langage complexe de codage en bloc de construction visuelle par glisser-déposer.

Retour au sommaire

Les servomoteurs et leurs accessoires en vidéo

Sommaire :

2022-04-05- Les servomoteur a alimentation séparée
2022-03-13- La création d’un retour d’information
2022-01-09- Arduino , augmenter le nombre de sorties PWM
Retour au menu Vidéo

2022-04-05- Les servomoteur a alimentation séparée

Dans cette nouvelle vidéo nous allons voir comment travailler avec des servomoteurs qui possèdent des alimentations séparées. Contrairement au servomoteur que l’on utilise en général et qui possède trois fils eux en possède 5 et ce sont de très gros servo. Nous allons étudier le câblage et le code Arduino . Pour illustrer le fonctionnement de ce type de servomoteur, nous l’avons intégré dans une application. Le but de cette appli est de piloter ce matériel avec simplement un joystick.

Retour au sommaire

2022-03-13- La création d’un retour d’information

Ce tuto vous explique comment un servomoteur standard peut être transformé en servomoteur possédant une rétroaction.
Vous pouvez peut-être vous poser la question suivante, qu’est-ce qu’une rétroaction ? Une rétroaction, retour d’information, feedback, ces termes définissent la même fonction pour connaître la position du servomoteur par l’intermédiaire d’un capteur qui est le reflet de la position exacte du servomoteur ou de l’actionneur en question Ces informations sont très utiles puisque cela nous permet d’améliorer la stabilité d’un système, ou bien utiliser cette fonction pour pouvoir enregistrer les positions de mouvement de l’actionneur en question.

Retour au sommaire

2022-01-09- Arduino , augmenter le nombre de sortie PWM

Ce tuto traite d’une carte de commande qui vous permet d’augmenter le nombre de sorties pwm quand votre carte Arduino devient trop juste pour répondre à vos besoins.

La carte de commande de chez Seeedstudio reference 108020102 possedant 16 canaux basée sur un PCA9685 permettant de contrôler jusqu’à 16 servomoteurs ou 16 leds via une liaison PWM. Ce module communique avec une carte Arduino ou compatible via le bus I2C.

Cette carte comporte jusqu’à 6 pontets à souder permettant de raccorder jusqu’à 64 PCA9685 sur un seul bus I2C. Une source d’alimentation externe est nécessaire pour les servomoteurs. Caractéristiques: Alimentation partie logique: 3,3 et 5 Vcc Alimentation partie servomoteur: 2,3 à 5,5 Vcc Commande: via le bus I2C Adresse I2C par défaut: 0x7f (configurable par pontet à souder) Compatible niveaux logiques 5 V Sorties servos/leds: connecteur mâle au pas de 2,54 mm Intensité maxi: – 25 mA par led – 400 mA au total pour tous les servos Dimensions: 65 x 45 x 13 mm

Retour au sommaire

Augmenter le nombres de vos sorties PWM sur Arduino

Mise à jour le 09/01/2022 : Cet article traite d’une carte de commande qui vous permet d’augmenter le nombre de sorties pwm quand votre carte Arduino devient trop juste pour répondre à vos besoins.

Sommaire :

Information technique
Tutoriel sur la carte de chez Seeed
Exemple de schema
- Pilotage d’un servomoteur avec retour d’informations
- Pilotage de 2 servomoteurs avec des tensions d’alimentations différentes
- Pilotage de 2 servos avec une tension d’alimentation de 12V et utilisation de 2 régulateurs pour s’adapter à la tension de service des actionneurs
Exemple de programme.
Pour tout probléme
Retour au menu systeme Grove

Information technique

Carte de commande de chez Seeedstudio reference 108020102 possedant 16 canaux basée sur un PCA9685 permettant de contrôler jusqu’à 16 servomoteurs ou 16 leds via une liaison PWM. Ce module communique avec une carte Arduino ou compatible via le bus I2C.

Cette carte comporte jusqu’à 6 pontets à souder permettant de raccorder jusqu’à 64 PCA9685 sur un seul bus I2C. Une source d’alimentation externe est nécessaire pour les servomoteurs.

Caractéristiques:

Alimentation partie logique: 3,3 et 5 Vcc
Alimentation partie servomoteur: 2,3 à 5,5 Vcc
Commande: via le bus I2C
- Adresse I2C par défaut: 0x7f (configurable par pontet à souder)
- Compatible niveaux logiques 5 V
Sorties servos/leds: connecteur mâle au pas de 2,54 mm
Intensité maxi:
– 25 mA par led
– 400 mA au total pour tous les servos
Dimensions : 65x45x13mm

Retour au sommaire

Tuto

Retour au sommaire

Exemple de schema

Pilotage d’un servomoteur avec retour d’informations à l’aide de la carte SEEED référence 108020102

Augmentation des sorties pwm via la carte 108020102

Pilotage de 2 servomoteurs avec des tensions d’alimentations différentes à l’aide de la carte SEEED référence 108020102 .

Augmentation des sorties pwm via la carte 108020102 . Schema avec des tensions d’alimentations différentes

Schema de 2 servos avec une tension d’alimentation de 12V et utilisation de 2 régulateurs pour s’adapter à la tension de service des actionneurs à l’aide de la carte SEEED référence 108020102.

Augmentation des sorties pwm via la carte 108020102 . Pilotage de 2 servomoteurs avec une tension d’alimentation de 12V et utilisation de 2 régulateurs pour s’adapter à la tension de service des actionneurs

Retour au sommaire

Exemple de programme

//
//
// *********************************************
//
//
//
// Arduino avec
//         une commande 16 canaux pour servos
//      I2C - basé sur un PCA9685
//
// Code: Mazelin Herve
// RedOhm
// Le 11/12/2021
// *********************************************


// chargement de la librairie pour l'utilisation de carte 
#include "PCA9685.h"
// chargement de la librairie pour la communication I2C 
#include <Wire.h>

ServoDriver servo;

int a ;

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

  Serial.begin(9600);
  // on attent que le port de communication soit pret
  while (!Serial)
  { ;
  }

  Serial.println("communication en service");

  // join I2C bus (I2Cdev la bibliothèque ne le fait pas automatiquement)
  Wire.begin();

  servo.init(0x7f);
  // Décommentez cette ligne si vous devez utiliser un servo spécial
  // servo.setServoPulseRange(600,2400,180);


}


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

  // premier parametre le numero de servo
  // second parametre le deplacement en degrée
  servo.setAngle(16, 10);
  delay (500);
  servo.setAngle(13, 10);
  delay(1000);
  servo.setAngle(9, 0);
  delay(1000);
  servo.setAngle(8, 0);
  delay(1000);
  servo.setAngle(1, 0);
  delay(1000);

  // premier parametre le numero de servo
  // second parametre le deplacement en degrée
  servo.setAngle(13, 140);
  servo.setAngle(9, 250);
  servo.setAngle(8, 250);
  servo.setAngle(1, 250);
  delay(1000);
  servo.setAngle(16, 250);
  delay (500);
  
  for (int i = 0; i <= 4; i++)
  {
    a=a+20;
    servo.setAngle(13, 140-a);
    delay (250);
  }
  a=0;

}

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

// Arduino avec

// une commande 16 canaux pour servos

// I2C - basé sur un PCA9685

// Code: Mazelin Herve

// RedOhm

// Le 11/12/2021

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

// chargement de la librairie pour l'utilisation de carte

#include "PCA9685.h"

// chargement de la librairie pour la communication I2C

#include <Wire.h>

ServoDriver servo;

int a ;

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

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

Serial.begin(9600);

// on attent que le port de communication soit pret

while (!Serial)

{ ;

}

Serial.println("communication en service");

// join I2C bus (I2Cdev la bibliothèque ne le fait pas automatiquement)

Wire.begin();

servo.init(0x7f);

// Décommentez cette ligne si vous devez utiliser un servo spécial

// servo.setServoPulseRange(600,2400,180);

}

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

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

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

void loop() {

// premier parametre le numero de servo

// second parametre le deplacement en degrée

servo.setAngle(16, 10);

delay (500);

servo.setAngle(13, 10);

delay(1000);

servo.setAngle(9, 0);

delay(1000);

servo.setAngle(8, 0);

delay(1000);

servo.setAngle(1, 0);

delay(1000);

// premier parametre le numero de servo

// second parametre le deplacement en degrée

servo.setAngle(13, 140);

servo.setAngle(9, 250);

servo.setAngle(8, 250);

servo.setAngle(1, 250);

delay(1000);

servo.setAngle(16, 250);

delay (500);

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

{

a=a+20;

servo.setAngle(13, 140-a);

delay (250);

}

a=0;

}

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 celles qui vous intéressent .

Facebook Twitter Youtube

Grabcad Thingiverse Cults

Retour à la page principal

Arduino & Sen0305 , le changement d’algorithmes

Dans ce code Arduino vous trouverez toutes les explications relatives à l’utilisation du changement de mode de fonctionnement de la caméra SEN0305 pour la reconnaissance faciale et la reconnaissnce d’objet .

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 changement d’algorithmes

Arduino avec la Camera Sen0305 , le changement d’algorithmes

Mise à jour le 11/11/2021 : Cet article traite du changement du mode d’algorithme de la camera SEN0305 ou de la SEN0336 version pro Continuer la lecture →

Arduino avec la Camera Sen0305 , la reconnaissance faciale

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

Sommaire :

Présentation du module AI HuskyLens Gravity SEN0305
Tuto sur la reconnaissance facial
Schéma de principe pour le cablage entre la carte Arduino Uno et la carte SEN0305
Programme de reconnaissance faciale, de suivis de visage et du mode patrouille
Retour au menu de la caméra.

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

Tuto sur la reconnaissance facial

Retour au sommaire

Schéma de principe pour le cablage entre la carte Arduino Uno et la carte SEN0305

Matériel :

Régulateur 7805 en boitier TO2020
- https://www.gotronic.fr/art-l7805cv-1578.htm
Module AI HuskyLens Gravity SEN0305
- https://www.gotronic.fr/art-module-ai-huskylens-gravity-sen0305-31965.htm
- https://fr.rs-online.com/
  - code article : 204-9898
Arduino UNO
- https://www.gotronic.fr/
  - code article : 25950

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 y à 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 y à 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!");

}

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

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 →

Robot Golbotth8 fiche de montage

Mise à jour le 18/11/2020 :

Sommaire :

001 – Présentation
002 – Vue de face et arriere
003 – Vue de coté
004 – Eclaté vue de dessus
005 – Vue eclatée avec repérage des pieces
006 – Vue eclatée de coté avec repérage des pieces
007 – 008 – Tourelle
009 – 010 – Base tourelle
011 – 012 – Pièce g012 plateau pour châssis
013 – capot tourelle
014 – Pièce g018 calandre arrière
015 – Pièce g019 calandre avant
018 – Led 8 mm RGB Grove V2.0 104020048
019 – 19A – Télémètre à ultrasons Grove 101020010
Retour a la page principale

Ce petit robot est destiné à vous initier à la programmation, nous l’appellerons Golbotth8. La construction de cet engin passe déjà par l’impression 3D, vous trouverez l’ensemble des fichiers STL sur notre site ainsi que la matière que nous avons utilisée et les différents conseils techniques. Vous aurez la possibilité de suivre des tutoriels sur Arduino avec ce module. Nous avons surtout essayé de minimiser le coût de l’ensemble.

Retour au sommaire

002-Vue de face et arriere

Retour au sommaire

Retour au sommaire.

Retour au sommaire

Pièce g010 tourelle – RedOhm

Filament : Pla
Constructeur du filament : https://www.arianeplast.com/
Poids : 335 g
Couleur : bi-ton gris et rouge
Temps d’impression : 21h00
Layer :0.19mm
Température : 205°

Retour au sommaire

009 – 010 – Base tourelle

Retour au sommaire

011 – 012 – Pièce g012 plateau pour châssis

Pièce g012 plateau pour châssis – RedOhm

Retour au sommaire

013 – Pièce g013 capot tourelle

Retour au sommaire

014 – Pièce g018 calandre arrière

Filament : Pla
Poids : 111g
Couleur : gris
Temps d’impression : 7h47
Layer : 0.19mm
Qualité : haute
Densité : 40%
Température : 205°

Retour au sommaire

015 –

Retour au sommaire

016 –

Retour au sommaire

017 –

Retour au sommaire

018 – Led 8 mm RGB Grove V2.0 104020048

Retour au sommaire

019 – Télémètre à ultrasons Grove 101020010

Télémètre à ultrasons Grove 101020010

Ce module dispose d’un émetteur à ultrasons et d’un récepteur à ultrasons afin que vous puissiez le considérer comme un émetteur-récepteur à ultrasons. Familier avec le sonar, lorsque l’onde ultrasonore de 40 KHz générée par l’émetteur rencontre l’objet, l’onde sonore sera renvoyée et le récepteur peut recevoir l’onde ultrasonore réfléchie. Il suffit de calculer le temps entre l’émission et la réception, puis de multiplier la vitesse du son dans l’air (340 m / s) pour calculer la distance du capteur à l’objet.

Comment fonctionne le capteur de distance à ultrasons?

Voici un exemple simple de la façon dont un capteur à ultrasons fonctionne pour mesurer la distance:

Tout d’abord, l’émetteur (trig pin) envoie une onde sonore
L’objet capte l’onde, la renvoyant vers le capteur.
Le récepteur (broche d’écho) le capte

Le lien pour le principe de fonctionnement : https://www.redohm.fr/2017/10/grove-telemetre-a-ultrasons-grove-101020010/

Téléchargez la bibliothèque UltrasonicRanger depuis Github.

Retour au sommaire

020 –

Retour au sommaire

Arduino : Coder la fonction d’un télerupteur

Mise à jour le 09/10/2020 : Ce tutoriel vous explique comment coder un télerupteur sur Arduino. 2 types de fonctionnement vous sont proposés.

Sommaire :

Principe de fonctionnement de la fonction
Programme support pour le tutoriel
Informations utiles pour la compréhension du code
Pour tout problème
Retour au menu principal .

Principe de fonctionnement de la fonction

2 types de fonctionnement vous sont proposés.

le premier étant le modèle standard : Lorsque l’on appuie sur le bouton poussoir, une impulsion met le télérupteur au travail, il ferme le circuit jusqu’à ce qu’une nouvelle impulsion l’ouvre et ainsi de suite. Les informations électriques qui font changer l’état du télérupteur sont du type front montant.
Il vous est donc proposé dans le programme fourni dans cet article ,un ensemble de codes composés de six lignes qui vous permet de créer cette fonction.

Telerupteur changement d’état sur le front montant

Deuxième montage. Lorsqu’on appuie sur le bouton poussoir, une impulsion met le télérupteur au travail met sur le front descendant. Il faut donc relâcher le bouton pour que le télérupteur soit actif. Lorsque nous avons une nouvelle impulsion toujours sur le front descendant le système se remet à l’état de repos et ainsi de suite.
Il vous faudra donc mettre une ligne en commentaire pour générer cette fonction dans le code fourni .

telerupteur changement d’état sur le front descendant

Retour au sommaire

Programme support pour le tutoriel

//
//
//************************************************
//
//RedOhm
//le 20/09/2020
//H-Mazelin
//
//Creation d'un telerupteur  
//
//
//IDE Arduino 1.8.10 
//************************************************

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

// 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_bouton6v=0 ;




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

// Configure la broche spécifiée pour qu'elle se comporte soit en entrée, 
// soit en sortie.Dans notre cas en entrée pour le bouton6
  pinMode(bouton6,INPUT);

}

void loop() {
  


bouton6v = digitalRead(bouton6);

// 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 (bouton6v!=etat_bouton6v)
    {
       if (!bouton6v)
      {
        //Inversion de la valeur de la variable memoire 
        memoire_2=!memoire_2;
      } 

       //si vous placez la ligne de code en commentaire 
       //alors le telerupteur fonctionnera sur les fronts
       //descendant des boutons poussoirs 
       //
       //Inversion de la valeur de la variable memoire 
       memoire_2=!memoire_2;
     
    }
// operation consitant a memoriser l'anciennne valeur de la 
// variable     
etat_bouton6v=bouton6v;



//======= Creation des offset pour le chronogramme ======== 
//
// affichage de la position du bouton 2
//
// ci joint le lien pour le tuto traitant de la fonction
// chronogramme
// https://www.youtube.com/watch?v=MBTEkbA6soI
//
bouton6v=bouton6v+2;



  Serial.print(bouton6v);
   Serial.print(",");
    Serial.print(memoire_2);
     Serial.println();


}

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

//RedOhm

//le 20/09/2020

//H-Mazelin

//Creation d'un telerupteur

//IDE Arduino 1.8.10

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

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

// de votre carte Arduino

int bouton6 = 6;

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

int bouton6v;

// 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_bouton6v=0 ;

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

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

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

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

// soit en sortie.Dans notre cas en entrée pour le bouton6

pinMode(bouton6,INPUT);

}

void loop() {

bouton6v = digitalRead(bouton6);

// 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 (bouton6v!=etat_bouton6v)

{

if (!bouton6v)

{

//Inversion de la valeur de la variable memoire

memoire_2=!memoire_2;

}

//si vous placez la ligne de code en commentaire

//alors le telerupteur fonctionnera sur les fronts

//descendant des boutons poussoirs

//Inversion de la valeur de la variable memoire

memoire_2=!memoire_2;

}

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

// variable

etat_bouton6v=bouton6v;

//======= Creation des offset pour le chronogramme ========

// affichage de la position du bouton 2

// ci joint le lien pour le tuto traitant de la fonction

// chronogramme

// https://www.youtube.com/watch?v=MBTEkbA6soI

bouton6v=bouton6v+2;

Serial.print(bouton6v);

Serial.print(",");

Serial.print(memoire_2);

Serial.println();

}

Retour au sommaire

Informations utiles pour la compréhension du code

! = Opérateurs de comparaison

Compare la variable à gauche avec la valeur ou la variable à droite de l’opérateur. Renvoie true lorsque les deux opérandes ne sont pas égaux. Veuillez noter que vous pouvez comparer des variables de différents types de données, mais que cela pourrait générer des résultats imprévisibles, il est donc recommandé de comparer des variables du même type de données incluant le type signé / non signé.

Syntaxe = x != y;

Paramètres :
x: variable. Autorisé types de données: int, float, double, byte, short, long.
y: variable ou constante. Autorisé types de données: int, float, double, byte, short, long.

!

Ce symbole peut être utilisé pour inverser la valeur booléenne

Syntaxe = x = !y;

Retour au sommaire

Pour tout problème

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

Facebook Twitter Youtube

Retour au sommaire