Archives de l’auteur : Hervé Mazelin

Mise à jour le 18/11/2021 : Le but de ces tutoriels doivent vous permettre de vous familiarisez avec le stokage de données dans la mémoire EEPROM de votre carte Arduino

Continuer la lecture →

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

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

Continuer la lecture →

Dynamixel XM430-W350-R

Mise à jour le 25/10/2019 : Les servomoteurs Dynamixel de la série XM-430 s’avèrent un peu moins puissant que les MX-106, ils constituent un renouvellement très appréciable de la série MX-28. Plus puissants, plus rapides, ils sont surtout beaucoup plus économes en énergie : 40 mA au lieu de 100 mA pour leurs prédécesseurs !

Continuer la lecture →

Robot Maya : Modification de l’ensemble du haut du bras

Mise à jour le 21/04/2019 .

Photo de Maya modification du bras Version 4-00 – 010

Sommaire :

Vue et repérage des pièces pour le haut du bras droit
Procédure de montage du bras droit
Procédure de montage haut du bras gauche
Plan des pièces mécanique.
Repérage filerie bras droit
Retour au menu principal

.bras

Vue et repérage des pièces pour le haut du bras droit

pièce 080_400 Épaule Droite V4.0

pièce 081_400 le haut du bras droit

pièce 082-400 Épaulette du bras droit

pièce 083-400 capot Mammoth droit

pièce 086-400 rondelle Haut du bras New Mammoth droit

Retour au sommaire

Procédure de montage du haut du bras droit

Fiche de montage V4-0006

Fiche de montage V4-0007

Fiche de montage V4-0008

Fiche de montage V4-0010

Fiche de montage V4-0012

Fiche de montage V4-0014

Fiche de montage V4-0016

Fiche de montage V4-0018

Fiche de montage V4-0020

Fiche de montage V4-0024

Fiche de montage V4-0026

Fiche de montage V4-0030

Fiche de montage V4-0032

Fiche de montage V4-0036

Fiche de montage V4-0038

Fiche de montage V4-0046

Procédure de montage du haut du bras gauche

Robot Maya .Fiche de montage bras gauche coté utilisateur V4-0106

Robot Maya .Fiche de montage bras gauche coté utilisateur V4-0107

Robot Maya .Fiche de montage bras gauche coté utilisateur V4-0110

Robot Maya .Fiche de montage bras gauche coté utilisateur V4-0112

Robot Maya .Fiche de montage bras gauche coté utilisateur V4-0114

Robot Maya .Fiche de montage bras gauche coté utilisateur V4-0116

en cours

Retour au sommaire

Plan des pièces mécaniques

Plan mécanique vis de rotation

Retour au sommaire

Repérage filerie bras droit

noir	pouce
violet	index
vert/blanc	majeur
jaune/blanc	annulaire
bleu/blanc	auriculaire
noir/blanc	rotation poignet
rouge/blanc	élévation poignet
marron/blanc	réserve

Retour au sommaire

Bras robotique Braccio T050000

.

Mise à jour le 28/03/2019 : Le bras motorisé et modulaire Braccio d’Arduino est livré en kit à assembler soi-même et se contrôle via une carte Arduino ou compatible.

Continuer la lecture →

DRI0027 . Contrôleur de Servomoteur Intelligent pour Arduino

.

Mise à jour le 31/03/2019 – Rubrique traitant du contrôleur de servomoteur intelligent pour Arduino DRI0027 avec une compatibilité sur les servomoteurs Dynamixel des séries AX et MX.

Continuer la lecture →

Nestor : Programmation des yeux

Mise à jour le 26/01/2019 :

Sommaire :

Programmation de l’œil droit ( étape 1 )
Dilatation de la pupilles ( étape 2 )

Retour au sommaire

Programmation de l’œil droit ( étape 1 )

Œil droit

//
//
//========================================================
//*       Programmation de l'oeil droit de Nestor        *
//*                                                      *
//*Etape 1                                               *
//*                                                      *
//*Le 26/01/2019                                         *
//*Par Hervé Mazelin                                     *
//*                                                      *
//========================================================  



// je charge la librairie SPI
// Cette librairie vous permet de communiquer avec des périphériques SPI
// La carte Arduino en tant que "maitre" par defaut 
#include <SPI.h>
// je charge la librairie TFT
// Cette bibliothèque permet à une carte Arduino de communiquer à
// l'écran LCD TFT 
#include <TFT.h> 
 
// Affectation des pins pour la communication Arduino-> afficheur  
#define cs   10
#define dc   9
#define rst  8
 
TFT screen = TFT(cs, dc, rst);

/* 
 * Un programme Arduino doit impérativement contenir cette fonction .
 * Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur
 * Elle sert à configurer globalement les entrées sorties  
 *  
 */
 
void setup()

{

 // initialisation de l'écran 
  screen.begin(); 
  
 // Efface l'ecran et met le fond en noir 
  screen.background(0,0,0);

 //defini la couleur pour tracer l'objet a dessiner 
 screen.stroke(255,255,255);
 
 // ******************** 1 anneau ****************************
 //
 // Anneau 1 exterieure bleu 
 // définition de la couleur de remplissage exemple bleu -> 128,255,255
 screen.fill(128,255,255);
 // Dessine un cercle sur l'écran.
 // Le cercle est tracé par rapport à son centre, 
 // ce qui signifie que le diamètre total sera toujours un nombre impair.
 screen.circle(88,64, 58);

 
 //****************** Dessin le rectangle *******************
 //
 //stroke = il définit la couleur des lignes et des bordures 
 //autour des formes.
 screen.stroke(0,0,0);
 //définition de la couleur de remplissage exemple noir -> 0,0,0
 screen.fill(0,0,0);
 screen.rect(73,109,30,20);

 // ******************** 2 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 46);

 // ******************** 3 anneau ****************************
 //dessine le cercle bleu foncé  
 screen.fill(19,56,236);
 screen.circle(88,64, 43);

 // ******************** 4 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 28);

 // ******************** 5 anneau ****************************
 //dessine le cercle bleu foncé  
 screen.fill(19,56,236);
 screen.circle(88,64, 25 );

 // ******************** 6 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 18);


}

/*
 *Le programme principal s’exécute par une boucle infinie appelée Loop () 
 * 
 */
 
void loop() {
  // vide pour le besoin de la demonstration
 
}

100

101

102

103

104

105

106

107

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

//* Programmation de l'oeil droit de Nestor *

//* *

//*Etape 1 *

//* *

//*Le 26/01/2019 *

//*Par Hervé Mazelin *

//* *

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

// je charge la librairie SPI

// Cette librairie vous permet de communiquer avec des périphériques SPI

// La carte Arduino en tant que "maitre" par defaut

#include <SPI.h>

// je charge la librairie TFT

// Cette bibliothèque permet à une carte Arduino de communiquer à

// l'écran LCD TFT

#include <TFT.h>

// Affectation des pins pour la communication Arduino-> afficheur

#define cs 10

#define dc 9

#define rst 8

TFT screen = TFT(cs, dc, rst);

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

* Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur

* Elle sert à configurer globalement les entrées sorties

void setup()

{

// initialisation de l'écran

screen.begin();

// Efface l'ecran et met le fond en noir

screen.background(0,0,0);

//defini la couleur pour tracer l'objet a dessiner

screen.stroke(255,255,255);

// ******************** 1 anneau ****************************

// Anneau 1 exterieure bleu

// définition de la couleur de remplissage exemple bleu -> 128,255,255

screen.fill(128,255,255);

// Dessine un cercle sur l'écran.

// Le cercle est tracé par rapport à son centre,

// ce qui signifie que le diamètre total sera toujours un nombre impair.

screen.circle(88,64, 58);

//****************** Dessin le rectangle *******************

//stroke = il définit la couleur des lignes et des bordures

//autour des formes.

screen.stroke(0,0,0);

//définition de la couleur de remplissage exemple noir -> 0,0,0

screen.fill(0,0,0);

screen.rect(73,109,30,20);

// ******************** 2 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 46);

// ******************** 3 anneau ****************************

//dessine le cercle bleu foncé

screen.fill(19,56,236);

screen.circle(88,64, 43);

// ******************** 4 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 28);

// ******************** 5 anneau ****************************

//dessine le cercle bleu foncé

screen.fill(19,56,236);

screen.circle(88,64, 25 );

// ******************** 6 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 18);

}

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

void loop() {

// vide pour le besoin de la demonstration

}

Retour au sommaire

Programmation de l’œil droit ( étape 2 )

Dilatation de la pupille

//
//
//========================================================
//*       Programmation de l'oeil droit de Nestor        *
//*                                                      *
//*             dilatation des pupilles                  *
//*Etape 2                                               *
//*                                                      *
//*Le 26/01/2019                                         *
//*Par Hervé Mazelin                                     *
//*                                                      *
//========================================================  



// je charge la librairie SPI
// Cette librairie vous permet de communiquer avec des périphériques SPI
// La carte Arduino en tant que "maitre" par defaut 
#include &lt;SPI.h>
// je charge la librairie TFT
// Cette bibliothèque permet à une carte Arduino de communiquer à
// l'écran LCD TFT 
#include &lt;TFT.h> 
 
// Affectation des pins pour la communication Arduino-> afficheur  
#define cs   10
#define dc   9
#define rst  8
 
TFT screen = TFT(cs, dc, rst);

// déclaration de l'entrée analogique 
// ou se trouve le module potentiometre Grove 
int potar_pin2 = 2; 
 int potar_pin3= 3;

// variable du type int pour stocker la valeur du cercle 
int cercle1 ;
int passage ;
int new1;

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

{

 //ouvre le port série et fixe le debit de communication à 9600 bauds
   Serial.begin(9600);

 // initialisation de l'écran 
  screen.begin(); 
  
 // Efface l'ecran et met le fond en noir 
  screen.background(0,0,0);

 //defini la couleur pour tracer l'objet a dessiner 
 screen.stroke(255,255,255);
 
 // ******************** 1 anneau ****************************
 //
 // Anneau 1 exterieure bleu 
 // définition de la couleur de remplissage exemple bleu -> 128,255,255
 screen.fill(128,255,255);
 // Dessine un cercle sur l'écran.
 // Le cercle est tracé par rapport à son centre, 
 // ce qui signifie que le diamètre total sera toujours un nombre impair.
 screen.circle(88,64, 58);

 
 //****************** Dessin le rectangle *******************
 //
 //stroke = il définit la couleur des lignes et des bordures 
 //autour des formes.
 screen.stroke(0,0,0);
 //définition de la couleur de remplissage exemple noir -> 0,0,0
 screen.fill(0,0,0);
 screen.rect(73,109,30,20);

 // ******************** 2 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 46);

 // ******************** 3 anneau ****************************
 //dessine le cercle bleu foncé  
 screen.fill(19,56,236);
 screen.circle(88,64, 43);

 // ******************** 4 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 28);

 // ******************** 5 anneau ****************************
 //dessine le cercle bleu foncé  
 screen.fill(19,56,236);
 screen.circle(88,64, 25 );

 // ******************** 6 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 18);


}

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


 
// lis la valeur de la tension analogique présente sur la broche 2
// et introduit le resultat dans la variable "variable"
cercle1 = analogRead(potar_pin2);
// la valeur du potentiometre est comprise entre 0 et 1023
// Etalonnage de la valeur du potentiometre en valeur de temps 
// valeur de temps comprise de 100 a 1200 milliseconde
// pour cela on utilise la fonction Map
// map (variable ,valeur basse de depart,valeur haute de depart ,new valeur basse, new valeur haute )
// valeur basse de depart = 1
// valeur haute de depart = 1023
// new valeur basse = 100
// new valeur haute = 1200
cercle1 =map( cercle1 ,0,800,10,0);



delay (10);

// Verification si on recoit l'ordre d'agrandir la pupille
if ( passage &lt; cercle1)
{
  Serial.println("Verification si on recoit l'ordre d'agrandir la pupille");
  Serial.print(passage);
  Serial.print(" &lt; ");
   Serial.println(cercle1); 
   
 // ******************** 6 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 18+cercle1);
 
 Serial.print("Nouvelle valeur de la pupille => ");
   new1=18+cercle1;
   Serial.println(new1);
}
 


// Verification de reduction de la pupille 
else if (passage > cercle1)
{
 Serial.println("Verification de reduction de la pupille");
 Serial.print(passage);
  Serial.print(" > ");
   Serial.println(cercle1);
    
 
 // ******************** 4 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 28);
 
 // ******************** 5 anneau ****************************
 //dessine le cercle bleu foncé  
 screen.fill(19,56,236);
 screen.circle(88,64, 25 );
 
 // ******************** 6 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 18+cercle1);
  Serial.print("Nouvelle valeur de la pupille => ");
   new1=18+cercle1;
   Serial.println(new1);
}

else if (passage == cercle1 )
{

   
}

passage = cercle1;
 
}




// --------------- Ensemble de sous programme ------------------
// 







void clignote_les_yeux ()
  
{

  delay (1000);
 //dessine le cercle noir  
 screen.fill(255,0,0);
 screen.circle(88,64, 18);

 delay(1000);                
 //dessine le cercle noir  
 screen.fill(233,209,223);
 screen.circle(88,64, 18);

  
}

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

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

//* Programmation de l'oeil droit de Nestor *

//* *

//* dilatation des pupilles *

//*Etape 2 *

//* *

//*Le 26/01/2019 *

//*Par Hervé Mazelin *

//* *

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

// je charge la librairie SPI

// Cette librairie vous permet de communiquer avec des périphériques SPI

// La carte Arduino en tant que "maitre" par defaut

#include <SPI.h>

// je charge la librairie TFT

// Cette bibliothèque permet à une carte Arduino de communiquer à

// l'écran LCD TFT

#include <TFT.h>

// Affectation des pins pour la communication Arduino-> afficheur

#define cs 10

#define dc 9

#define rst 8

TFT screen = TFT(cs, dc, rst);

// déclaration de l'entrée analogique

// ou se trouve le module potentiometre Grove

int potar_pin2 = 2;

int potar_pin3= 3;

// variable du type int pour stocker la valeur du cercle

int cercle1 ;

int passage ;

int new1;

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

{

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

Serial.begin(9600);

// initialisation de l'écran

screen.begin();

// Efface l'ecran et met le fond en noir

screen.background(0,0,0);

//defini la couleur pour tracer l'objet a dessiner

screen.stroke(255,255,255);

// ******************** 1 anneau ****************************

// Anneau 1 exterieure bleu

// définition de la couleur de remplissage exemple bleu -> 128,255,255

screen.fill(128,255,255);

// Dessine un cercle sur l'écran.

// Le cercle est tracé par rapport à son centre,

// ce qui signifie que le diamètre total sera toujours un nombre impair.

screen.circle(88,64, 58);

//****************** Dessin le rectangle *******************

//stroke = il définit la couleur des lignes et des bordures

//autour des formes.

screen.stroke(0,0,0);

//définition de la couleur de remplissage exemple noir -> 0,0,0

screen.fill(0,0,0);

screen.rect(73,109,30,20);

// ******************** 2 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 46);

// ******************** 3 anneau ****************************

//dessine le cercle bleu foncé

screen.fill(19,56,236);

screen.circle(88,64, 43);

// ******************** 4 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 28);

// ******************** 5 anneau ****************************

//dessine le cercle bleu foncé

screen.fill(19,56,236);

screen.circle(88,64, 25 );

// ******************** 6 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 18);

}

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

void loop() {

// lis la valeur de la tension analogique présente sur la broche 2

// et introduit le resultat dans la variable "variable"

cercle1 = analogRead(potar_pin2);

// la valeur du potentiometre est comprise entre 0 et 1023

// Etalonnage de la valeur du potentiometre en valeur de temps

// valeur de temps comprise de 100 a 1200 milliseconde

// pour cela on utilise la fonction Map

// map (variable ,valeur basse de depart,valeur haute de depart ,new valeur basse, new valeur haute )

// valeur basse de depart = 1

// valeur haute de depart = 1023

// new valeur basse = 100

// new valeur haute = 1200

cercle1 =map( cercle1 ,0,800,10,0);

delay (10);

// Verification si on recoit l'ordre d'agrandir la pupille

if ( passage < cercle1)

{

Serial.println("Verification si on recoit l'ordre d'agrandir la pupille");

Serial.print(passage);

Serial.print(" < ");

Serial.println(cercle1);

// ******************** 6 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 18+cercle1);

Serial.print("Nouvelle valeur de la pupille => ");

new1=18+cercle1;

Serial.println(new1);

}

// Verification de reduction de la pupille

else if (passage > cercle1)

{

Serial.println("Verification de reduction de la pupille");

Serial.print(passage);

Serial.print(" > ");

Serial.println(cercle1);

// ******************** 4 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 28);

// ******************** 5 anneau ****************************

//dessine le cercle bleu foncé

screen.fill(19,56,236);

screen.circle(88,64, 25 );

// ******************** 6 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 18+cercle1);

Serial.print("Nouvelle valeur de la pupille => ");

new1=18+cercle1;

Serial.println(new1);

}

else if (passage == cercle1 )

{

}

passage = cercle1;

}

// --------------- Ensemble de sous programme ------------------

void clignote_les_yeux ()

{

delay (1000);

//dessine le cercle noir

screen.fill(255,0,0);

screen.circle(88,64, 18);

delay(1000);

//dessine le cercle noir

screen.fill(233,209,223);

screen.circle(88,64, 18);

}

Retour au sommaire

Filament d’imprimante 3D TPC FLEX 45

Mise à jour le 21/01/2019 : Les enjeux de ce test sur le filament TPC FLEX 45 est la création de pneu ou de patin de chenille pour les nouvelles réalisations. Suivez régulièrement la progression de nos tests , vous pouvez nous faire part de vos remarques ou de votre savoir faire sur notre page FaceBook. Continuer la lecture →

Fiches de montages du châssis de Nestor

Mise à jour le 20/01/2019 : Ensemble des fiches de montage pour la construction du châssis de robot Nestor

Continuer la lecture →

Plan mécanique du châssis de Nestor.

.

Mise à jour le 30/12/2018 : Vous trouverez dans cet article l’ensemble des plans mécaniques qui compose le robot Nestor avec les cotations ainsi la liste des fournitures mécaniques

Continuer la lecture →