Archives de l’auteur : Hervé Mazelin

Sommaire :

2022-11-05 : Mit inventor creation d’un joystick analogique pour Arduino – 1/5
2022-09-19 : Mit inventor le changement de page
2022-10-08 : Communication en bluetooth d’une tablette vers Arduino avec Mit Inventor
Retour au menu Vidéo

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

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-10-08- 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

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

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

Pilotage d’un moteur pas à pas avec frein

Mise à jour le 13/02/2022 .

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/09/2021 : Comment traiter le stockage d’informations en mémoire EEPROM sur arduino avec l’instruction EEPROM.put.

Sommaire :

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

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.

Le but de cet exemple est de montrer aussi l’instruction EEPROM.put() qui écrit des données sur EEPROM ou en utilisant également EEPROM.update() qui écrit des données uniquement si elles sont différentes du contenu précédent des emplacements à écrire. Le nombre d’octets écrits est lié au type de données ou à la structure personnalisée de la variable à écrire.

Retour au sommaire

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

Retour au sommaire

Video sur l’ecriture de la mémoire EEPROM

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