Archives par étiquette : Arduino Mega 2560

.

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 →

Ecran Nextion : Fonctionnement d’un bouton poussoir fichier HMI

Description du tutoriel pour la tablette Nextion

L’objectif de ce programme très simple, est d’allumer ou éteindre une LED chaque fois qu’un bouton est pressé sur la tablette Nextion. Ici, nous utilisons la bibliothèque officielle, créée par ITEAD, qui permet de déclarer précisément le composant « bouton ». Comme il s’agit d’un composant de type « Button », il est possible de déclarer une fonction de type callback* sur l’événement « pression sur le bouton ». * Cette fonction est ainsi appelée automatiquement par la librairie officielle, lors de l’exécution de sa propre fonction nexLoop (qui doit donc impérativement être appelée dans la fonction loop de Arduino).

Continuer la lecture →

Ecran Nextion : Fonctionnement d’un bouton poussoir

–

Mise à jour le 07/07/2018 : L’objectif de ce programme, très simple, est d’allumer ou éteindre une LED chaque fois qu’un bouton est pressé sur la tablette Nextion.

Continuer la lecture →

Grove : Télémètre à ultrasons Grove 101020010

Mise à jour le 15/11/2020: Ce télémètre compatible Grove permet de mesurer la distance de 3cm à 4m avec une resolution de 1cm , sans contact à l’aide de transducteurs à ultrasons.

Continuer la lecture →

ROBOT MAYA – Automatisme de fonctionnement des yeux et de la bouche.

***

Mise à jour le 26/02/2017

Sommaire :

Présentation de l’article .
Les différentes étapes pour pouvoir appréhender le fonctionnement .
- étape 1 : le but étant est de faire apparaître sur l’écran des mots,on devra actionner un potentiomètre et c’est cette valeur analogique qui nous déterminera l’action à entreprendre.
  - Présentation de l’exercice
  - Schéma de raccordement de l’afficheur et de la carte Arduino 2560
  - Programme
- étape 2 : Le but est de faire apparaître sur l’écran les yeux suivant : le premier étend attentif, le second penaud et enfin d’effacer l’écran.

Retour au sommaire

Présentation de l’article .

Dans cet article, nous allons étudier comment les yeux et la bouche de Maya sont pilotés, mais je pense qu’il est important de faire un petit rappel des objectifs de fonctionnement et du résultat à obtenir.

Robot Maya de RedOhm

***

Comment transposer des expressions humaines à un robot ?

Nous avons donc pensé que les yeux étaient un bon départ pour déterminer des expressions humaines transposées à la machine .Ces expressions seront de plusieurs natures, un regard attentif, penaud, en colère etc. et même quelques expressions comme un clin d’œil .Nous avons donc développé rapidement quelques expressions, puis nous avons mis côte à côte 2 écrans pour imaginer le reste de la tête de Maya. Évidemment au premier coup d’œil il manquait quelque chose, la bouche, eh ! Oui c’est une partie du visage qui peut définir énormément d’expression ne serait-ce que déjà simulé la parole.

Enfin si on regarde l’ensemble de la tête de notre futur robot les deux yeux et la bouche sont d’un couple parfait comme chez l’humain d’ailleurs. Et oui de ce couple on peut créer des expressions un peu plus complexes avec des paliers.

Je m’explique dans la phase bonheur on peut avoir plusieurs types de bonheur comme par exemple être simplement souriant, avoir un petit sourire mignon qui pourrait être par exemple une bouche un peu plus ouverte ou un sourire heureux, ou très heureux.

Dans le désarroi, on peut avoir le boudeur, le déçu, mécontent, très mécontent.

Enfin on peut greffer d’autres types d’expression humaine comme l’admiration, la maladie, blasé, espiègle, une fausse innocente, divers types de gènes, brefs, tout un ensemble que l’on va pouvoir créer. Plus cette machine possédera d’expression humaine, plus sa différence nous surprendra.

Passons maintenant à la configuration de cet ensemble. Chaque œil est représenté par un écran LCD, qui est lui-même relié à une carte Arduino méga 2560 (cette carte a été choisie pour ne pas restreindre les applications futures). Ces deux cartes seront pilotées par une carte mère qui enverra les informations aux deux cartes esclaves par l’intermédiaire d’un bus I2C, cette même carte mère aura aussi la double fonction de piloter le mouvement des lèvres.

Nous allons donc étudier tout au long de cet article comment arriver au fonctionnement final, mais pour cela nous allons passer par des étapes intermédiaires.

Retour au sommaire

Etape n°1

Présentation de l’exercice

Le but est de faire apparaître sur l’écran des mots, le premier étend attentif, le second penaud et enfin d’effacer l’écran. Pour pouvoir passer d’un message à l’autre ou d’effacer l’écran, on devra actionner un potentiomètre et c’est cette valeur analogique qui nous déterminera l’action à entreprendre.

Schéma de raccordement de l’afficheur et de la carte Arduino 2560

Pour connecter l’écran LCD A000096 à une carte Arduino Mega, utilisez cette configuration de broche.

Maya : Pour connecter l’écran LCD A000096 – RedOhm

Schéma de raccordement de l’afficheur sur un Arduino 2560 – RedOhm

Programme

/*
 * 
 * 
 * 
 * le but est de faire apparaître sur l’écran des mots, le premier étend 
 * attentif, le second penaud et enfin d’effacer l’écran. Pour pouvoir 
 * passer d’un message à l’autre ou d’effacer l’écran, on devra actionner 
 * un potentiomètre et c’est cette valeur analogique qui nous déterminera 
 * l’action à entreprendre.
 * 
 * 
 * code projet : Affichage_texte
 * 
 * Herve Mazelin - RedOhm
 * 17/01/2017
 */





// je charge la librairie SPI
// Cette librairie vous permet de communiquer avec des périphériques SPI
// La carte Arduino en tant que "maitre" 
#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 
int analogPin = 0;

// variable de type int pour stocker la valeur du potentiometre
int val = 0;
// variable du type int pour stocker la valeur de passage dans le controle
// si la valeur val et strictement inférieure à 100
int cont1= 0;
// variable du type int pour stocker la valeur de passage dans le controle
// si la valeur val et strictement comprise de 105 a 200
int cont2= 0;




// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties 
void setup() {
  
  

  
  
  // initialisation de l'écran 
  screen.begin();

 
  // Efface l'écran LCD avec la couleur indiquée.
  // Peut être utilisée dans  loop () pour effacer l'écran.
  // Couleur du fond noir
  screen.background(0,0,0);
 
  

  
}

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

  
  // lit la valeur de la tension analogique présente sur la broche
  val = analogRead(analogPin); 

  // si la valeur val et strictement inférieure à 100
  // on affiche le texte Attentif
  if ((val<100) &&(cont1==0)){
      // Efface l'ecran couleur du fond noir  
      screen.background(0,0,0);
      // Dans ce cas defini la couleur du texte
      screen.stroke(255,255,255);
      // Définit la taille du texte qui suit. La taille par défaut
      // est "1". Chaque changement de taille augmente le texte
      // par 10 pixels en hauteur. Autrement dit, la taille 1 = 10
      // pixels, taille 2 = 20 pixels, et ainsi de suite. 
      screen.setTextSize(2);
      // Écrire un texte à l'écran aux coordonnées données. 
      screen.text("Attentif", 0, 0);
      // mise de la variable cont1 a 1 pour la confirmation du 
      // passage dans la boucle de test attentif
      cont1=1;
      // Remise a zero de la variable de controle Penaud 1
      cont2=0;
  }


  // si la valeur val et strictement inférieure à 100
  // on affiche le texte Penaud 1
  else if (((val>105)&&(val<200))&&(cont2==0)){
      // Efface l'ecran couleur du fond noir 
      screen.background(0,0,0);
      // Dans ce cas defini la couleur du texte
      screen.stroke(255,255,255);
      // Définit la taille du texte qui suit. La taille par défaut
      // est "1". Chaque changement de taille augmente le texte
      // par 10 pixels en hauteur. Autrement dit, la taille 1 = 10
      // pixels, taille 2 = 20 pixels, et ainsi de suite. 
      screen.setTextSize(2); 
      // Écrire un texte à l'écran aux coordonnées données.
      screen.text("Penaud 1 ", 0, 0);
      // mise de la variable cont2 a 1 pour la confirmation du 
      // passage dans la boucle de test Penaud 1
      cont2=1;
      // Remise a zero de la variable de controle attentif 
      cont1=0;
    
  }
 

  // si la valeur val et strictement superieure a 1000
  // on efface l'ecran avec la commande -> screen.background(0,0,0)
  else if (val>1000){
     // on efface l ecran 
     screen.background(0,0,0);
     // Remise a zero de la variable de controle attentif
     cont1=0;
     // Remise a zero de la variable de controle penaud
     cont2=0;
  }
 
 
}

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

* le but est de faire apparaître sur l’écran des mots, le premier étend

* attentif, le second penaud et enfin d’effacer l’écran. Pour pouvoir

* passer d’un message à l’autre ou d’effacer l’écran, on devra actionner

* un potentiomètre et c’est cette valeur analogique qui nous déterminera

* l’action à entreprendre.

* code projet : Affichage_texte

* Herve Mazelin - RedOhm

* 17/01/2017

// je charge la librairie SPI

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

// La carte Arduino en tant que "maitre"

#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

int analogPin = 0;

// variable de type int pour stocker la valeur du potentiometre

int val = 0;

// variable du type int pour stocker la valeur de passage dans le controle

// si la valeur val et strictement inférieure à 100

int cont1= 0;

// variable du type int pour stocker la valeur de passage dans le controle

// si la valeur val et strictement comprise de 105 a 200

int cont2= 0;

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

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

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

void setup() {

// initialisation de l'écran

screen.begin();

// Efface l'écran LCD avec la couleur indiquée.

// Peut être utilisée dans loop () pour effacer l'écran.

// Couleur du fond noir

screen.background(0,0,0);

}

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

void loop() {

// lit la valeur de la tension analogique présente sur la broche

val = analogRead(analogPin);

// si la valeur val et strictement inférieure à 100

// on affiche le texte Attentif

if ((val<100) &&(cont1==0)){

// Efface l'ecran couleur du fond noir

screen.background(0,0,0);

// Dans ce cas defini la couleur du texte

screen.stroke(255,255,255);

// Définit la taille du texte qui suit. La taille par défaut

// est "1". Chaque changement de taille augmente le texte

// par 10 pixels en hauteur. Autrement dit, la taille 1 = 10

// pixels, taille 2 = 20 pixels, et ainsi de suite.

screen.setTextSize(2);

// Écrire un texte à l'écran aux coordonnées données.

screen.text("Attentif", 0, 0);

// mise de la variable cont1 a 1 pour la confirmation du

// passage dans la boucle de test attentif

cont1=1;

// Remise a zero de la variable de controle Penaud 1

cont2=0;

}

// si la valeur val et strictement inférieure à 100

// on affiche le texte Penaud 1

else if (((val>105)&&(val<200))&&(cont2==0)){

// Efface l'ecran couleur du fond noir

screen.background(0,0,0);

// Dans ce cas defini la couleur du texte

screen.stroke(255,255,255);

// Définit la taille du texte qui suit. La taille par défaut

// est "1". Chaque changement de taille augmente le texte

// par 10 pixels en hauteur. Autrement dit, la taille 1 = 10

// pixels, taille 2 = 20 pixels, et ainsi de suite.

screen.setTextSize(2);

// Écrire un texte à l'écran aux coordonnées données.

screen.text("Penaud 1 ", 0, 0);

// mise de la variable cont2 a 1 pour la confirmation du

// passage dans la boucle de test Penaud 1

cont2=1;

// Remise a zero de la variable de controle attentif

cont1=0;

}

// si la valeur val et strictement superieure a 1000

// on efface l'ecran avec la commande -> screen.background(0,0,0)

else if (val>1000){

// on efface l ecran

screen.background(0,0,0);

// Remise a zero de la variable de controle attentif

cont1=0;

// Remise a zero de la variable de controle penaud

cont2=0;

}

Etape n°2

/*
 * 
 * 
 * 
 * le but est de faire apparaître sur l’écran les yeux suivant : le  premier 
 * étend attentif, le second penaud et enfin d’effacer l’écran. Pour pouvoir 
 * passer d’un dessin  à l’autre ou d’effacer l’écran, on devra actionner 
 * un potentiomètre et c’est cette valeur analogique qui nous déterminera 
 * l’action à entreprendre.
 * 
 * 
 * code projet : 0001-Affichage dessin attentif et penaud 
 * 
 * Herve Mazelin - RedOhm
 * 22/01/2017
 */





// je charge la librairie SPI
// Cette librairie vous permet de communiquer avec des périphériques SPI
// La carte Arduino en tant que "maitre" 
#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 
int analogPin = 0;

// variable de type int pour stocker la valeur du potentiometre
int val = 0;
// variable du type int pour stocker la valeur de passage dans le controle
// si la valeur val et strictement inférieure à 100
int cont1= 0;
// variable du type int pour stocker la valeur de passage dans le controle
// si la valeur val et strictement comprise de 105 a 200
int cont2= 0;
// variable du type int pour la boucle creation de l'oeil
int x;




// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties 
void setup() {
  
  

  
  
  // initialisation de l'écran 
  screen.begin();

 
  // Efface l'écran LCD avec la couleur indiquée.
  // Peut être utilisée dans  loop () pour effacer l'écran.
  // Couleur du fond noir
  screen.background(0,0,0);
 
  

  
}

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

  
  // lit la valeur de la tension analogique présente sur la broche
  val = analogRead(analogPin); 

  // si la valeur val et strictement inférieure à 100
  // on affiche le dessin de l'oeil attentif
  if ((val<100) &&(cont1==0)){
      // Appel de la fonction -> creation_de_oeil
      creation_de_oeil();
      // Mise a 1 de la variable cont1  qui determine que
      // l’on a déjà traversé cette instruction enfin 
      // d’éviter le clignotement de l’œil 
      cont1=1;
      // Remise a zero de la variable de controle Penaud 1
      cont2=0;
  }


  // si la valeur val et strictement inférieure à 200 
  // et superieur a 105 on affiche le texte Penaud 1
  else if (((val>105)&&(val<200))&&(cont2==0)){
      // Appel de la fonction -> creation_de_oeil
      creation_de_oeil();
      // Appel de la fonction -> creation_penaud
      creation_penaud();
      // Mise a 1 de la variable cont2  qui determine que
      // l’on a déjà traversé cette instruction enfin 
      // d’éviter le clignotement de l’œil 
      cont2=1;
      // Remise a zero de la variable de controle attentif 
      cont1=0;
    
  }
 

  // si la valeur val et strictement superieure a 1000
  // on efface l'ecran avec la commande -> screen.background(0,0,0)
  else if (val>1000){
     // on efface l ecran 
     screen.background(0,0,0);
     // Remise a zero de la variable de controle attentif
     cont1=0;
     // Remise a zero de la variable de controle penaud
     cont2=0;
  }
 
 
}


 
/*
 *  la creation de la fonction -> creation_de_oeil
 *  
 *  a savoir : la creation d'une fonction est independante du programme 
 *  principal.Elle sera donc en dehors du programme principal 
 *  
 */
 
void creation_de_oeil()
{
   // 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 exterieure bleu 
  // définition de la couleur de remplissage exemple bleu -> 128,255,255
  screen.fill(128,255,255);
  // je dessine un annneau exterieur dans le centre de l'écran
  // je prend la largeur de l'ecran que je divise par 2 
  // je prend la hauteur de l'ecran que je divise par 2
  screen.circle(screen.width()/2, screen.height()/2, 60);
 
 //dessine le trait horizontal et vertical
 //defini la couleur pour tracer l'objet a dessiner en noir
   screen.stroke(0,0,0);
  // Trace trois lignes horizontale qui traverse l'ecran
  for (x=0;x<3;x++)
  {
   screen.line(1,63+x,159,63+x); 
  } 
  // Trace une ligne verticale qui traverse l'ecran d'une epaisseur de 
  // 3 pixels
  for (x=0;x<3;x++)
  {
   screen.line (79+x,1,79+x,127); 
  } 
 
 
 
  
  // 2 cercle  
  // définit la couleur de remplissage exemple gris 127.127.127
  screen.fill(0,0,0);
  
  // je dessine un cercle dans le centre de l'écran
  screen.circle(screen.width()/2, screen.height()/2, 45);
  
 
   // 3 cercle  
  // définit la couleur de remplissage exemple gris 127.127.127
  screen.fill(136,136,136);
  // je dessine un cercle dans le centre de l'écran
  screen.circle(80, 64, 35);
 
  // 4 cercle  
  // définit la couleur de remplissage exemple noir 0.0.0
  screen.fill(0,0,0);
  // je dessine un cercle dans le centre de l'écran
  screen.circle(screen.width()/2, screen.height()/2, 25);
 
 
}

/*
 *  la creation de la fonction -> Dessin de l'oeil penaud
 *  
 *  a savoir : la creation d'une fonction est independante du programme 
 *  principal.Elle sera donc en dehors du programme principal 
 *  
 */


void creation_penaud()
{
 // je dessine un triangle 

  // Boucle comptant de 0 a 80 avec un increment de 1
  // for (initialisation ; condition ; increment)
  // entre crochet { instructions executees dans la boucle }
  for( x=0;x<80;x++){
     // définit la couleur de remplissage exemple noir 255.255.255
     screen.fill(255,255,255);
     // dessine une ligne entre deux points les parametres :
     // xStart) int, la position horizontale où la ligne commence
     // ystart) int, la position verticale où la ligne commence
     // xEnd) int, la position horizontale où la ligne se termine
     // yEnd) int, la position verticale où les extrémités de la ligne
     // screen.line (xStart,ystart,xEnd,yEnd); 
     screen.line (0,0,160,x); 
  }
  // je dessine le 2eme triangle je modifie la position verticale 
  // ou la ligne commence 


 // Boucle comptant de 0 a 20 avec un increment de 1
 // for (initialisation ; condition ; increment)
 // entre crochet { instructions executees dans la boucle }
   for( x=0;x<20;x++){
     // définit la couleur de remplissage exemple noir 255.255.255
     screen.fill(255,255,255);
     // dessine une ligne entre deux points les parametres :
     // xStart) int, la position horizontale où la ligne commence
     // ystart) int, la position verticale où la ligne commence
     // xEnd) int, la position horizontale où la ligne se termine
     // yEnd) int, la position verticale où les extrémités de la ligne
     // screen.line (xStart,ystart,xEnd,yEnd); 
     screen.line (0,x,160,79);        
  }


  
}

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

* le but est de faire apparaître sur l’écran les yeux suivant : le premier

* étend attentif, le second penaud et enfin d’effacer l’écran. Pour pouvoir

* passer d’un dessin à l’autre ou d’effacer l’écran, on devra actionner

* un potentiomètre et c’est cette valeur analogique qui nous déterminera

* l’action à entreprendre.

* code projet : 0001-Affichage dessin attentif et penaud

* Herve Mazelin - RedOhm

* 22/01/2017

// je charge la librairie SPI

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

// La carte Arduino en tant que "maitre"

#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

int analogPin = 0;

// variable de type int pour stocker la valeur du potentiometre

int val = 0;

// variable du type int pour stocker la valeur de passage dans le controle

// si la valeur val et strictement inférieure à 100

int cont1= 0;

// variable du type int pour stocker la valeur de passage dans le controle

// si la valeur val et strictement comprise de 105 a 200

int cont2= 0;

// variable du type int pour la boucle creation de l'oeil

int x;

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

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

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

void setup() {

// initialisation de l'écran

screen.begin();

// Efface l'écran LCD avec la couleur indiquée.

// Peut être utilisée dans loop () pour effacer l'écran.

// Couleur du fond noir

screen.background(0,0,0);

}

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

void loop() {

// lit la valeur de la tension analogique présente sur la broche

val = analogRead(analogPin);

// si la valeur val et strictement inférieure à 100

// on affiche le dessin de l'oeil attentif

if ((val<100) &&(cont1==0)){

// Appel de la fonction -> creation_de_oeil

creation_de_oeil();

// Mise a 1 de la variable cont1 qui determine que

// l’on a déjà traversé cette instruction enfin

// d’éviter le clignotement de l’œil

cont1=1;

// Remise a zero de la variable de controle Penaud 1

cont2=0;

}

// si la valeur val et strictement inférieure à 200

// et superieur a 105 on affiche le texte Penaud 1

else if (((val>105)&&(val<200))&&(cont2==0)){

// Appel de la fonction -> creation_de_oeil

creation_de_oeil();

// Appel de la fonction -> creation_penaud

creation_penaud();

// Mise a 1 de la variable cont2 qui determine que

// l’on a déjà traversé cette instruction enfin

// d’éviter le clignotement de l’œil

cont2=1;

// Remise a zero de la variable de controle attentif

cont1=0;

}

// si la valeur val et strictement superieure a 1000

// on efface l'ecran avec la commande -> screen.background(0,0,0)

else if (val>1000){

// on efface l ecran

screen.background(0,0,0);

// Remise a zero de la variable de controle attentif

cont1=0;

// Remise a zero de la variable de controle penaud

cont2=0;

}

* la creation de la fonction -> creation_de_oeil

* a savoir : la creation d'une fonction est independante du programme

* principal.Elle sera donc en dehors du programme principal

void creation_de_oeil()

{

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

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

screen.fill(128,255,255);

// je dessine un annneau exterieur dans le centre de l'écran

// je prend la largeur de l'ecran que je divise par 2

// je prend la hauteur de l'ecran que je divise par 2

screen.circle(screen.width()/2, screen.height()/2, 60);

//dessine le trait horizontal et vertical

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

screen.stroke(0,0,0);

// Trace trois lignes horizontale qui traverse l'ecran

for (x=0;x<3;x++)

{

screen.line(1,63+x,159,63+x);

}

// Trace une ligne verticale qui traverse l'ecran d'une epaisseur de

// 3 pixels

for (x=0;x<3;x++)

{

screen.line (79+x,1,79+x,127);

}

// 2 cercle

// définit la couleur de remplissage exemple gris 127.127.127

screen.fill(0,0,0);

// je dessine un cercle dans le centre de l'écran

screen.circle(screen.width()/2, screen.height()/2, 45);

// 3 cercle

// définit la couleur de remplissage exemple gris 127.127.127

screen.fill(136,136,136);

// je dessine un cercle dans le centre de l'écran

screen.circle(80, 64, 35);

// 4 cercle

// définit la couleur de remplissage exemple noir 0.0.0

screen.fill(0,0,0);

// je dessine un cercle dans le centre de l'écran

screen.circle(screen.width()/2, screen.height()/2, 25);

}

* la creation de la fonction -> Dessin de l'oeil penaud

* a savoir : la creation d'une fonction est independante du programme

* principal.Elle sera donc en dehors du programme principal

void creation_penaud()

{

// je dessine un triangle

// Boucle comptant de 0 a 80 avec un increment de 1

// for (initialisation ; condition ; increment)

// entre crochet { instructions executees dans la boucle }

for( x=0;x<80;x++){

// définit la couleur de remplissage exemple noir 255.255.255

screen.fill(255,255,255);

// dessine une ligne entre deux points les parametres :

// xStart) int, la position horizontale où la ligne commence

// ystart) int, la position verticale où la ligne commence

// xEnd) int, la position horizontale où la ligne se termine

// yEnd) int, la position verticale où les extrémités de la ligne

// screen.line (xStart,ystart,xEnd,yEnd);

screen.line (0,0,160,x);

}

// je dessine le 2eme triangle je modifie la position verticale

// ou la ligne commence

// Boucle comptant de 0 a 20 avec un increment de 1

// for (initialisation ; condition ; increment)

// entre crochet { instructions executees dans la boucle }

for( x=0;x<20;x++){

// définit la couleur de remplissage exemple noir 255.255.255

screen.fill(255,255,255);

// dessine une ligne entre deux points les parametres :

// xStart) int, la position horizontale où la ligne commence

// ystart) int, la position verticale où la ligne commence

// xEnd) int, la position horizontale où la ligne se termine

// yEnd) int, la position verticale où les extrémités de la ligne

// screen.line (xStart,ystart,xEnd,yEnd);

screen.line (0,x,160,79);

}

Retour au sommaire

En cours et à suivre .

ROBOT MAYA – Dossier pour la construction du robot

***

Mise à jour le 11/06/2017

Retrouvez sur cette page l’ensemble des articles concernant le robot Maya ( album photos des pièces , plan mécanique , fichier à télécharger pour l’impression 3D )

Maya version 1.00 – RedOhm

Sommaire :

Information
Vue éclatée de la tête de Maya pour le choix des pièces
Ensemble des fichiers à télécharger tête , cou, base du cou
- 001 – Encéphale gauche pièce 001
- 002 – Encéphale droit pièce 002
- 002A – Raccord encéphale ou raccord tête pièce 002A
- 003 – Mâchoire pièce 003
- 006 –Masque avant pièce 006 ( Version 3.00 )
- 007 – Masque après pièce 007
- 008 –Paupière pièce 008
- 009 – Globe fermé pièce 009 ( Version 3.00 )
- 010 – Écrin écran pièce 010 ( Version 5.00 )
- 011 – Support yeux pièce 011
- 012 – Capot encéphale pièce 012
Vue éclatée du cou et de la base du cou
Ensembles des fichiers à télécharger ou à acquérir pour le cou
- 025 – Base du cou plat pièce 025
- 026 – Le cou pièce 026
- 027 – Butée à bille référence 51115 pièce 027
- 028 – Servomoteur Hitec HS645MG ( double roulements à billes ) pièce 028
- 029 – Couronne vendue avec le servomoteur HS645MG pièce 029
Vue éclatée du thorax et des épaules de Maya pour le choix des pièces
Ensemble des fichiers à télécharger ou à acquérir du thorax
- 043 – Trapèze buste gauche pièces 043 (impression 3D)
- 044 – Thorax coté gauche pièce 044 (impression 3D)
- 046 – Thorax coté droit pièce 046 (impression 3D)
- 047 – Trapèze buste droit pièces 047 (impression 3D)
- 050 – Servomoteur pour coté gauche TopModel Mastodon 9944 pièce 050
- 051 – Servomoteur pour coté droit TopModel Mastodon 9944 pièce 051
- 054 – Support écran pièces 054 (impression 3D)
- 055 – Ecran pièce 055 Référence : en attente de validation
- 060 – Support carte pièce 060 (impression 3D)
- 062 – Carte Arduino Mega 2560 Bras gauche adresse 30 pièce 062
- 063 – Carte Arduino Mega 2560 Bras gauche adresse 31 pièce 063
- 064 – Carte EZ-Robot V4 adresse 0 pièce 064
- 065 – Carte EZ-Robot V4 adresse 1 pièce 065
Vue éclatée du bras droit pour le choix des pièces
Ensemble des fichiers à télécharger pour le bras droit
- 080 – L’épaule du bras droit pièce 080 (impression 3D)
- 081 – Le haut du bras droit pièce 081 (impression 3D)
- 082 – Épaulette du bras droit pièce 082 (impression 3D)
- 083 – Butée à rouleaux partie droite
- 084 – Servomoteur pour coté droit TopModel Mastodon 9944
- 085 – Pièce mécanique à réaliser voir plan en cours
- 086 – Rondelle pièce 086 (impression 3D)
- 087- Roulement MF126ZZ pièce 087
- 088- Servomoteur Hitec 805bb pièce 88
- 090 – Presse étoupe pièce 090
- 091 – Roulement MF126ZZ pièce 091
- 095 – Bas du bras pièce 095 (impression 3D)
- 096 – Servomoteur Hitec 645 MG pièce 096
- 097 – Butée à bille référence 51105 pièce 097
- 098 – Poignet droit pièce 098 (impression 3D)
- 099 – Rondelle haut du bras droit pièce 99 (impression 3D)
- 100 – Pièce mécanique à réaliser voir plan en cours
Vue éclatée du bras gauche pour le choix des pièces
Ensemble des fichiers à télécharger pour le bras gauche
- 110 – L’épaule du bras gauche pièce 110 (impression 3D)
- 111 – Le haut du bras gauche pièce 111 (impression 3D)
- 112 – Épaulette du bras gauche pièce 112 (impression 3D)
- 113 – Butée à rouleaux partie gauche
- 114 – Servomoteur pour coté gauche TopModel Mastodon 9944
- 115 – Pièce mécanique à réaliser voir plan en cours
- 116 – Rondelle pièce 116 (impression 3D)
- 117 – Roulement MF126ZZ pièce 117
- 118 – Servomoteur Hitec 805bb pièce 118
- 120 – Presse étoupe pièce 120
- 125 – Bas du bras pièce 125 (impression 3D)
- 121- Roulement MF126ZZ pièce 121
- 126 – Servomoteur Hitec 645 MG pièce 126
- 127 – Butée à bille référence 51105 pièce 127
- 128 – Poignet gauche pièce 128 (impression 3D)
- 129 – Rondelle haut du bras gauche pièce 129 (impression 3D)
- 130 – Pièce mécanique à réaliser voir plan en cours

Information

Vous avez sur cette page les principaux paramètres entre autre, la vitesse ,la température , la qualité d’impression ainsi que le poids de la matière et le temps pour réaliser votre pièce .L’ensemble de ces paramètres est applicable pour l’imprimante Replicator 2 en version PLA (il suffira d’adapter ces paramètres pour un autre type d’imprimante 3D ) .

Pour ses impressions nous avons utilisé du fil PLA 1.75 de chez Verbatim. Voir La liste pour les imprimantes compatibles . Voici le lien -> Verbatim imprimante.

Note : Pour ABS

Nous avons testé ces pièces en impression pour l’ABS

Utilisez une imprimante carénée avec une chambre d’impression chauffée de préférence .

Nous obtenons de bon résultat avec une température d’extrudeur de 220°C et avec un lit chauffé à 80°C ( si l’imprimante est carénée ) afin d’éviter les déformations dues au refroidissement du plastique lors de l’impression.

Pour les imprimantes non carénée la température du plateau chauffant recommandé (80 à 120°C).

Recommandation :

Vérifiez si votre plateau est de niveau .

Vérifiez que votre plateau soit bien droit et l’espace buse plateau soit respecté en tous points , sinon, mettez-le de niveau et réglez votre espace buse plateau .Ne lancez l’impression que lorsque l’imprimante et le plateau sont calibrés correctement.

Vérifiez que vous avez assez de filament .

Vérifiez que votre filament soit bien chargé sur son support à bobine , et contrôlez le poids de votre bobine moins la tare + 20% correspondant au poids total de la pièce à imprimer en fonction des paramètres joints sur le tableau récapitulatif.

Contrôle de l’extrudeur .

Il est important de vérifier si l’extrudeur et la buse sont propres surtout avant d’imprimer de grosse pièce.

Retour au sommaire

Vue éclatée de la tête de Maya pour le choix des pièces

Vue éclatée de la tête de Maya pour le choix des pièces – RedOhm

Retour au sommaire

Ensemble des fichiers à télécharger
tête , cou, base du cou

Encéphale gauche pièce 001

Robot Maya encéphale gauche pièce 001 – RedOhm

Information pour l’impression :
– Temps de réalisation : 68h20mm
– Matière : 830 g
– Type de Matière : PLA dans ce cas
– Remplissage : 40%
– Définition : Haute
– Température : configuration sur Z-GLASS pour du PLA pour imprimante Zortrax ou sur Replicator 210°C
– Note pour PLA : Un lit chauffé à 40°C

Remarque et modification : Préféré l’utilisation du PLA pour les objets de grande surface . Réalisation de la pièce sur imprimante Zortrax M200 Le temps de réalisation de la pièce dépend en grand partie du type de finition , exemple pour une finition normal le temps sera de 46h43mm et en matière 557g . A savoir sur l’imprimante Replicator 2 nous étions à 32 h10mm pour un remplissage de 20% et un poids de 490 g
Volume utile sur l’imprimante : 724 cm3
Longueur : 242 mmm	Largeur : 85 mm	Hauteur : 148 mm

Fichier à télécharger pour imprimer ->

Robot Maya : Encéphale gauche pièce 001

1 fichier·s 397.05 KB

Robot Maya : Encéphale gauche pièce 001

Retour au sommaire

Encéphale droit pièce 002

Robot Maya encéphale droit pièce 002 – RedOhm

Information pour l’impression :
– Temps de réalisation :68h25mm
– Matière : 845g
– Type de Matière : PLA dans ce cas
– Remplissage : 40%
– Définition : Haute
– Température : configuration sur Z-GLASS pour du PLA pour imprimante Zortrax ou sur Replicator 210°C
– Note pour PLA : Un lit chauffé à 40°C

Remarque et modification : Même commentaire que ci-dessus . Préféré l’utilisation du PLA pour les objets de grande surface . Réalisation de la pièce sur imprimante Zortrax M200 Le temps de réalisation de la pièce dépend en grand partie du type de finition , exemple pour une finition normal le temps sera de 46h52mm et en matière 570g . A savoir sur l’imprimante Replicator 2 nous étions à 32 h10mm pour un remplissage de 20% et un poids de 490 g
Volume utile sur l’imprimante : 726cm3
Longueur : 242 mm	Largeur : 85 mm	Hauteur : 148 mm

Fichier à télécharger pour imprimer ->

Robot Maya : Encéphale droit pièce 002

1 fichier·s 373.39 KB

Robot Maya : Encéphale droit pièce 002

–

Maya ensemble des 2 encéphales RedOhm ( Reproduit par Davy en PLA de chez Ariane-plas )

–

Fournisseur pour la réalisation ci-dessus : Ariane-plas

Retour au sommaire

Raccord tête ou raccord encéphale pièce 002A

Robot Maya raccord tête 002A – RedOhm

Information pour l’impression :
– Temps de réalisation :3h58mm
– Matière : 60.84 g (0.134ib)
– Type de Matière : ABS ou PLA ou HIPS
– Remplissage : 30%
– Définition : Haute
– Température : 250°C ABS / 210°C PLA
– Note pour ABS : Un lit chauffé à 80°C

Remarque et modification : Préféré l’utilisation de l’ABS ou du HIPS. L’ensemble des valeurs est donné à titre indicatif , hormis bien évidemment le volume et les dimensions utiles .
Volume utile sur l’imprimante : 65cm3
Longueur : 71mm	Largeur : 71mm	Hauteur :64

Fichier à télécharger pour imprimer ->

Robot Maya :Raccord tête ou raccord encéphale pièce 002A

1 fichier·s 6.71 KB

Robot Maya :Raccord tête ou raccord encéphale pièce 002A

Retour au sommaire

Mâchoire pièce 003

Robot Maya mâchoire pièce 003 – RedOhm

Information pour l’impression :
– Temps de réalisation :12h20mm
– Matière : 193.72 g (0.427ib)
– Type de Matière : ABS ou PLA
– Remplissage : 30%
– Définition : Haute
– Température : 220°C ABS / 210°C PLA
– Note pour ABS : Un lit chauffé à 80°C

Remarque et modification : 178 cm3
Volume utile sur l’imprimante :
Longueur : 155 mm	Largeur : 110 mm	Hauteur : 85 mm

Fichier à télécharger pour imprimer ->

Robot Maya : Mâchoire pièce 003

1 fichier·s 83.40 KB

Robot Maya : Mâchoire pièce 003

Retour au sommaire

Base du cou plat ( version 1.00 ) pièce 025

Robot Maya base de cou plat pièce 025 – RedOhm

Information pour l’impression :
– Temps de réalisation :14h50mm
– Matière : 262.31 g (0.578ib)
– Type de Matière : ABS ou PLA
– Remplissage : 30%
– Définition : Haute
– Température : 220°C ABS / 210°C PLA
– Note pour ABS : Un lit chauffé à 80°C

Remarque et modification : 03/12/2016 : Sur la version 1.00 , nous avons modifié la portée de la butée à billes, et nous avons ajouté une décoration à la base du support (papillon galactique symbole Maya)
Volume utile sur l’imprimante : 304 cm3
Longueur : 225 mm	Largeur : 150 mm	Hauteur : 30 mm

Fichier à télécharger pour imprimer ->

Robot Maya : Base du cou plat pièce 025

1 fichier·s 0.12 KB

Robot Maya : Base du cou plat pièce 025 V2017-04-07

Retour au sommaire

Le cou pièce 026

Robot Maya cou pièce 026 – RedOhm

Information pour l’impression :
– Temps de réalisation :15h59mm
– Matière : 263.49 g (0.581ib)
– Type de Matière : ABS ou PLA ou HIPS
– Remplissage : 30%
– Définition : Haute
– Température : configuration sur Z-GLASS pour du PLA pour imprimante Zortrax ou sur Replicator 210°C
– Note pour ABS : Un lit chauffé à 80°C

Remarque et modification : Préféré l’utilisation de l’ABS ou du HIPS. L’ensemble des valeurs est donné à titre indicatif , hormis bien évidemment le volume et les dimensions utiles .
Volume utile sur l’imprimante : 533 cm3
Longueur : 117 mm	Largeur : 117 mm	Hauteur : 144 mm

Fichier à télécharger pour imprimer ->

Robot Maya :Le cou pièce 026

1 fichier·s 1.73 MB

Robot Maya :Le cou pièce 026 V2017-04-07

Retour au sommaire

Masque avant pièce 006 ( Version 3.00 )

Robot Maya masque avant pièce 006 – RedOhm

Information pour l’impression :
– Temps de réalisation :7h18mm
– Matière : 114.66 g (0.253b)
– Type de Matière : ABS ou PLA
– Remplissage : 30%
– Définition : Haute
– Température : 220°C ABS / 210°C PLA
– Note pour ABS : Un lit chauffé à 80°C

Remarque et modification : Le 09/12/2016 : Version 3.00 . Préféré l’utilisation de l’ABS ou du HIPS. L’ensemble des valeurs est donné à titre indicatif , hormis bien évidemment le volume et les dimensions utiles .
Volume utile sur l’imprimante : 152cm3
Longueur : 110 mm	Largeur : 80 mm	Hauteur : 62 mm

Fichier à télécharger pour imprimer ->

Robot Maya : Masque avant pièce 006 Version 3.00

1 fichier·s 85.58 KB

Robot Maya : Masque avant pièce 006 Version 3.00

Retour au sommaire

Masque après pièce 007 (Version 2.00 )

Information pour l’impression :
– Temps de réalisation :5h18mm
– Matière : 63 g
– Type de Matière :ABS ou PLA ou HIPS
– Remplissage : 40%
– Définition : Haute
– Température :configuration sur Z-GLASS pour du PLA pour imprimante Zortrax ou sur Replicator 210°C
– Note pour PLA : Un lit chauffé à 40°C

Remarque et modification : 18 cm3 Dans notre cas la réalisation à était effectuée en PLA . L’ensemble des valeurs est donné à titre indicatif , hormis bien évidemment le volume et les dimensions utiles
Volume utile sur l’imprimante :
Longueur : 108 mm	Largeur : 77mm	Hauteur : 23 mm

Fichier à télécharger pour imprimer ->

Robot Maya V1.00 - Masque après pièce 007 (Version 2.00 )

1 fichier·s 183.96 KB

Robot Maya V1.00 - Masque après pièce 007 (Version 2.00 )

Retour au sommaire

Paupière pièce 008

Maya : Paupière pièce 008 – RedOhm

Information pour l’impression :
– Temps de réalisation :14h17mm
– Matière : 152 g
– Type de Matière :ABS ou PLA ou HIPS
– Remplissage : 20%
– Définition : Haute
– Température :configuration sur Z-GLASS pour du PLA pour imprimante Zortrax ou sur Replicator 210°C
– Note pour PLA : Un lit chauffé à 40°C

–

Remarque et modification : Dans notre cas , la réalisation a était effectuée en PLA . L’ensemble des valeurs est donné à titre indicatif , hormis bien évidemment le volume et les dimensions utiles
Volume utile sur l’imprimante : 140 cm3
Longueur : 257 mm	Largeur : 77mm	Hauteur : 23 mm

Fichier à télécharger pour imprimer ->

Robot Maya V1.00 – paupières Piece 008 Version V2-00

1 fichier·s 0.14 KB

Robot Maya V1.00 – paupières Piece 008 Version V2-00

–

Maya paupiere piece 008 RedOhm ( Reproduit par Davy en PLA de chez Ariane-plas )

–

Retour au sommaire

Globe fermé pièce 009 Version 3.00

Robot Maya globe fermé piéce 009 – RedOhm

Information pour l’impression :
– Temps de réalisation :0h50mm
– Matière : 13 g (0.029ib)
– Type de Matière : ABS ou PLA
– Remplissage : 30%
– Définition : Haute
– Température : 220°C ABS / 210°C PLA
– Note pour ABS : Un lit chauffé à 80°C

Remarque et modification : L’ensemble des valeurs est donné à titre indicatif , hormis bien évidemment le volume et les dimensions utiles
Volume utile sur l’imprimante : 7 cm3
Longueur : 60 mm	Largeur : 42 mm	Hauteur : 12 mm

Fichier à télécharger pour imprimer ->

Robot Maya : globe fermé piece 009 Version 3.00

1 fichier·s 344.07 KB

Robot Maya : globe fermé piece 009 Version 3.00

Retour au sommaire

Écrin pour écran pièce 010 Version 5.00

Écrin pour écran pièce 010 Version 5.00 – RedOhm

Information pour l’impression :
– Temps de réalisation :1h09mm
– Matière : 16.21 g (0.036ib)
– Type de Matière : ABS ou PLA
– Remplissage : 30%
– Définition : Haute
– Température : 220°C ABS / 210°C PLA
– Note pour ABS : Un lit chauffé à 80°C

Remarque et modification : L’ensemble des valeurs est donné à titre indicatif , hormis bien évidemment le volume et les dimensions utiles
Volume utile sur l’imprimante : 15 cm3
Longueur : 60mm	Largeur : 60mm	Hauteur : 35mm

Fichier à télécharger pour imprimer ->

Robot Maya V1.00 – Écrin pour écran pièce 010 Version V5-00

1 fichier·s 212.12 KB

Robot Maya V1.00 – Écrin pour écran pièce 010 Version V5-00

Retour au sommaire

Support yeux pièce 011

Robot Maya support yeux piece 011 – RedOhm

Information pour l’impression :
– Temps de réalisation :6h30mm
– Matière : 103.27 g (0.228ib)
– Type de Matière : ABS ou PLA
– Remplissage : 30%
– Définition : Haute
– Température : 220°C ABS / 210°C PLA
– Note pour ABS : Un lit chauffé à 80°C

Remarque et modification :
Volume utile sur l’imprimante :
Longueur en cm	Largeur en cm	Hauteur en cm

Fichier à télécharger pour imprimer ->

Robot Maya : Support yeux pièce 011 Version 3.00

1 fichier·s 0.12 KB

Robot Maya : Support yeux pièce 011 Version 3.00

Retour au sommaire

Vue éclatée du cou et de la base du cou de Maya
pour le choix des pièces

–

Vue éclatée du cou et de la base du cou de Maya

Information :

Le 07-04-2017 : Le numéro des pièces a changé mais celle-ci reste identique à ce jour

Retour au sommaire

Vue éclatée du thorax et des épaules de Maya
pour le choix des pièces

Après une série d’essais sur le fonctionnement des épaules Maya, nous nous sommes aperçus qu’il fallait limiter les charges verticales sur l’axe du moteur de l’épaule. Nous avons donc opéré une modification des épaules de Maya, afin d’y insérer une butée à rouleaux pour limiter les contraintes.

Maya vue éclatée du thorax et des épaules version 01-06-2017 – RedOhm

Nomenclature des pièces :

043 – Trapèze buste gauche pièces 043 (impression 3D)
044 – Thorax coté gauche pièce 044 (impression 3D)
046 – Thorax coté droit pièce 046 (impression 3D)
047 – Trapèze buste droit pièces 047 (impression 3D)
050 – Servomoteur pour coté gauche TopModel Mastodon 9944 pièce 050
051 – Servomoteur pour coté droit TopModel Mastodon 9944 pièce 051
054 – Support écran pièces 054 (impression 3D)
055 – Ecran pièce 055 Référence : en attente de validation
060 – Support carte pièce 060 (impression 3D)
062 – Carte Arduino Mega 2560 Bras gauche adresse 30 pièce 062
063 – Carte Arduino Mega 2560 Bras gauche adresse 31 pièce 063
064 – Carte EZ-Robot V4 adresse 0 pièce 064
065 – Carte EZ-Robot V4 adresse 1 pièce 065

Retour au sommaire

Ensemble des fichiers à télécharger du thorax

Ensemble des 4 pièces composant le buste 043, 044 , 046 , 047

–

Maya version rouge de Davy . Pla de chez Arianeplast Rouge métallisé	Maya version rouge de Davy . Pla de chez Arianeplast Rouge métallisé
Maya le thorax chez RedOhm . Pla de chez Arianeplast Aluminium métallisé

Numéro de pièce	Poids	Temps d’impression	Volume de la pièce	Longueur de la pièce	Largeur de la pièce	Hauteur de la pièce
043	212g	40h20mm	530 cm3	150 mm	149.9 mm	150 mm
044	139 g	41h32mm	342 cm3	210.59 mm	123.38 mm	126 mm
046	139 g	41h17mm	340 cm3	210.59 mm	123.38 mm	126 mm
047	211 g	40h23mm	534 cm3	150 mm	149.9 mm	150 mm
Remarque et modification :
Profile sur Zortrax : Z-Glass sans utilisation de Z-temp Layer : 0.19 mm

–

Fichier à télécharger pour imprimer Version 01-06-2017 ->
En cours

Retour au sommaire

Support écran pièce 054

–

Fichier à télécharger pour imprimer ->

Retour au sommaire

Support carte pièce 060

Maya support carte thorax – RedOhm 001 . Pla de chez Arianeplast Aluminium métallisé	Maya support carte thorax – RedOhm 002 . Pla de chez Arianeplast Aluminium métallisé

Remarque et modification :
Poids de la pièce en : Pla de chez Arianeplast Aluminium métallisé 112 g Temps d’impression sur Zortrax M300 : 21h28mm Profile sur Zortrax : Z-Glass sans utilisation de Z-temp Layer : 0.19 mm Volume utile : 131.13 cm3
Longueur en mm	Largeur en mm	Hauteur en mm
158.8 mm	192.98 mm	37mm

Fichier à télécharger pour imprimer ->

Robot Maya V1.00 & V2.00 support carte pour le thorax pièce 060 V03-04-17

1 fichier·s 324.85 KB

Support carte pour le thorax piece 060 V03-04-17

Retour au sommaire

Archive pour les construction avant le 01/06/2017 Vue éclatée du thorax et des épaules de Maya pour le choix des pièces Vue éclatée du thorax et des épaules de Maya . Construction avant le 01/06/2017
Nous laissons à disposition les anciens fichiers avant la modification validée du 01/06/2017. Dans ce dossier archives, vous retrouverez l’ancien éclaté ainsi que les fichiers de la même époque pour la réalisation du thorax.
Ensemble des 4 pièces composant le buste 043, 044 , 046 , 047 pour la version avant le 01/06/2017 Fichier à télécharger pour imprimer -> Robot Maya V1.00 & V2.00 ensemble du buste 1 fichier·s 0.14 KB Ensemble des 4 pièces composant le buste 043-044-046-047

Retour au sommaire

Vue éclatée du bras droit pour le choix des pièces

Maya éclaté du bras droit pour le choix des pièces – RedOhm 003

Nomenclature des pieces :

080 – L’épaule du bras droit pièce 080 (impression 3D)
081 – Le haut du bras droit pièce 081 (impression 3D)
082 – Épaulette du bras droit pièce 082 (impression 3D)
085 – Pièce mécanique à réaliser voir plan en cours
086 – Rondelle pièce 086 (impression 3D)
087- Roulement MF126ZZ pièce 087
090 – Presse étoupe pièce 090
091 – Roulement MF126ZZ pièce 091
095 – Bas du bras pièce 095 (impression 3D)
096 – Servomoteur Hitec 645 MG pièce 096
097 – Butée à bille référence 51105 pièce 097
098 – Poignet droit pièce 098 (impression 3D)

Retour au sommaire

Ensemble des fichiers à télécharger du bras droit

Épaule droite pièce 080

Robot Maya épaule droite pièce 080 – RedOhm

—

Information pour l’impression
Numéro de pièce	Poids	Temps d’impression	Volume de la pièce	Longueur de la pièce	Largeur de la pièce	Hauteur de la pièce
080	331g	19h17mm	725 cm3	159 mm	92 mm	138 mm
081	792g	65h45mm	1019 cm3	98 mm	290 mm	123 mm
082	127g	32h23mm	425 cm3	165 mm	192 mm	92 mm
086	3g	0h24mm	1.54 cm3	28 mm	3 mm	29 mm
095	819g	71h41mm	954 cm3	123 mm	277 mm	106 mm
098	60g	6h	55 cm3	79 mm	71 mm	61 mm
099	2g	0h15mm	0.59 cm3	24 mm	2 mm	24 mm
Type de matière : Pla de chez Arianeplast Aluminium métallisé Qualité paramètre Zortrax : Haute Profile sur Zortrax : Z-Glass sans utilisation de Z-temp ( la matière à un aspect plus foncé ) Profile sur Zortrax : Z-Glass avec utilisation de Z-temp avec un offset de -20 ° ( la matière à un aspect plus brillant )

Fichier à télécharger pour imprimer ->
en cours le 11/06/2017

Retour au sommaire

Vue éclatée du bras gauche pour le choix des pièces
Version du 01/06/2017

Maya vue du bras gauche éclatée Version du 01-06-2017 RedOhm

Nomenclature des pièces :

110 – L’épaule du bras gauche pièce 110 (impression 3D)
111 – Le haut du bras gauche pièce 111 (impression 3D)
112 – Épaulette du bras gauche pièce 112 (impression 3D)
113 – Butée à rouleaux partie gauche
114 – Servomoteur pour coté gauche TopModel Mastodon 9944
115 – Pièce mécanique à réaliser voir plan en cours
116 – Rondelle pièce 116 (impression 3D)
117 – Roulement MF126ZZ pièce 117
118 – Servomoteur Hitec 805bb pièce 118
120 – Presse étoupe pièce 120
125 – Bas du bras pièce 125 (impression 3D)
121- Roulement MF126ZZ pièce 121
126 – Servomoteur Hitec 645 MG pièce 126
127 – Butée à bille référence 51105 pièce 127
128 – Poignet gauche pièce 128 (impression 3D)
129 – Rondelle haut du bras gauche pièce 129 (impression 3D)
130 – Pièce mécanique à réaliser voir plan en cours

Retour au sommaire

Programme pour piloter séparement chaque moteur du support trois axes

Version 1.00
Mise à jour le 27/08/2016

 /*
  *
  *
  *
  *RedOhm 
  *
  *
  *Programme pour piloter separement chaque moteur du support
  *trois axes
  *
  *le 27/08/2016
  *        H-Mazelin
  */
 
 
 




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

// Crée un objet de type "Servo" pour la rotation de la base, nommé -> servobase
Servo servobase;
// Crée un objet de type "Servo" pour l'elevation du bras, nommé -> servobras
Servo servobras;
// Crée un objet de type "Servo" pour la rotation de la tete, nommé -> servotete
Servo servotete;
// broche sur lequel est branche le potentiometre servant a piloter le servobase
int brochepotar_de_position_servobase=0;
// variable contenant la valeur du potentiometre pour le servobase
int valeur_potar_position_du_servobase; 

// broche sur lequel est branche le potentiometre servant a piloter le servobras
int brochepotar_de_position_servobras=2;
// variable contenant la valeur du potentiometre pour le servobras
int valeur_potar_position_du_servobras; 

// broche sur lequel est branche le potentiometre servant a piloter le servotete
int brochepotar_de_position_servotete=4;
// variable contenant la valeur du potentiometre pour le servotete
int valeur_potar_position_du_servotete; 

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

void setup() {
  //  initialisation de la connexion série
  // IMPORTANT : la fenêtre terminal côté PC doit être réglée sur la même valeur
  Serial.begin(9600);
  // associe le servomoteur servobase a la broche 3   
  servobase.attach(3);
  // associe le servomoteur servobras a la broche 4   
  servobras.attach(4);
  // associe le servomoteur servotete a la broche 5   
  servotete.attach(5);
  Serial.println("**********************************");
  Serial.println("*                                *");
  Serial.println("*support 3 axes                  *");
  Serial.println("*              operationnel      *");
  Serial.println("*                                *");
  Serial.println("**********************************");
  Serial.println("                                  ");
  //pause presentation
  delay (5000);
}



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



void loop() {

/*
 * 
 * traitement pour la position de la base
 */


  
  // lecture de la valeur du potentiomètre (valeur entre 0 et 1023)  
  valeur_potar_position_du_servobase=analogRead( brochepotar_de_position_servobase); 
// mise a l'échelle (valeur entre 5 et 180)
// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position_du_servobase=map(valeur_potar_position_du_servobase,0,1023,5,180);
// définit la position d'asservissement du servomoteur 
// en fonction de la valeur à l'échelle  
  servobase.write(valeur_potar_position_du_servobase);
// affiche le texte d'information sans retour a la ligne 
  Serial.print("position actuelle de la base ->  ");
// affiche la valeur de la position de la base avec retour a la ligne    
  Serial.println(valeur_potar_position_du_servobase);
// Réalise une pause dans l'exécution du programme pour une durée 
// de 20 millisecondes
// permettant au servomteur d'atteindre sa position  
  delay(20);


/*
 * 
 * traitement pour la position du bras
 */


  
  // lecture de la valeur du potentiomètre (valeur entre 0 et 1023)  
  valeur_potar_position_du_servobras=analogRead(brochepotar_de_position_servobras); 
// mise a l'échelle (valeur entre 5 et 180)
// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position_du_servobras=map(valeur_potar_position_du_servobras,0,1023,54,120);
// définit la position d'asservissement du servomoteur 
// en fonction de la valeur à l'échelle  
  servobras.write(valeur_potar_position_du_servobras);
// affiche le texte d'information sans retour a la ligne 
  Serial.print("position actuelle du bras ->  ");
// affiche la valeur de la position du bras avec retour a la ligne       
  Serial.println(valeur_potar_position_du_servobras);
// Réalise une pause dans l'exécution du programme pour une durée 
// de 20 millisecondes
// permettant au servomteur d'atteindre sa position  
  delay(20);


/*
 * 
 * traitement pour la position de la tete
 */


  
  // lecture de la valeur du potentiomètre (valeur entre 0 et 1023)  
   valeur_potar_position_du_servotete=analogRead(brochepotar_de_position_servotete); 
// mise a l'échelle (valeur entre 5 et 180)
// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
   valeur_potar_position_du_servotete=map( valeur_potar_position_du_servotete,0,1023,5,180);
// définit la position d'asservissement du servomoteur 
// en fonction de la valeur à l'échelle  
   servotete.write( valeur_potar_position_du_servotete);
// affiche le texte d'information sans retour a la ligne
   Serial.print("position actuelle de la tete ->  ");
// affiche la valeur de la position de la tete avec retour a la ligne    
   Serial.println( valeur_potar_position_du_servotete);
// Réalise une pause dans l'exécution du programme pour une durée 
// de 20 millisecondes
// permettant au servomteur d'atteindre sa position  
  delay(20);

}

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

*RedOhm

*Programme pour piloter separement chaque moteur du support

*trois axes

*le 27/08/2016

* H-Mazelin

// Cette librairie permet à une carte Arduino de contrôler des servomoteurs

#include <Servo.h>

// Crée un objet de type "Servo" pour la rotation de la base, nommé -> servobase

Servo servobase;

// Crée un objet de type "Servo" pour l'elevation du bras, nommé -> servobras

Servo servobras;

// Crée un objet de type "Servo" pour la rotation de la tete, nommé -> servotete

Servo servotete;

// broche sur lequel est branche le potentiometre servant a piloter le servobase

int brochepotar_de_position_servobase=0;

// variable contenant la valeur du potentiometre pour le servobase

int valeur_potar_position_du_servobase;

// broche sur lequel est branche le potentiometre servant a piloter le servobras

int brochepotar_de_position_servobras=2;

// variable contenant la valeur du potentiometre pour le servobras

int valeur_potar_position_du_servobras;

// broche sur lequel est branche le potentiometre servant a piloter le servotete

int brochepotar_de_position_servotete=4;

// variable contenant la valeur du potentiometre pour le servotete

int valeur_potar_position_du_servotete;

* Un programme Arduino doit impérativement contenir cette fonction

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

* Elle sert à configurer globalement les entrées sorties

void setup() {

// initialisation de la connexion série

// IMPORTANT : la fenêtre terminal côté PC doit être réglée sur la même valeur

Serial.begin(9600);

// associe le servomoteur servobase a la broche 3

servobase.attach(3);

// associe le servomoteur servobras a la broche 4

servobras.attach(4);

// associe le servomoteur servotete a la broche 5

servotete.attach(5);

Serial.println("**********************************");

Serial.println("* *");

Serial.println("*support 3 axes *");

Serial.println("* operationnel *");

Serial.println("* *");

Serial.println("**********************************");

Serial.println(" ");

//pause presentation

delay (5000);

}

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

void loop() {

* traitement pour la position de la base

// lecture de la valeur du potentiomètre (valeur entre 0 et 1023)

valeur_potar_position_du_servobase=analogRead( brochepotar_de_position_servobase);

// mise a l'échelle (valeur entre 5 et 180)

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

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_du_servobase=map(valeur_potar_position_du_servobase,0,1023,5,180);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servobase.write(valeur_potar_position_du_servobase);

// affiche le texte d'information sans retour a la ligne

Serial.print("position actuelle de la base -> ");

// affiche la valeur de la position de la base avec retour a la ligne

Serial.println(valeur_potar_position_du_servobase);

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

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

* traitement pour la position du bras

// lecture de la valeur du potentiomètre (valeur entre 0 et 1023)

valeur_potar_position_du_servobras=analogRead(brochepotar_de_position_servobras);

// mise a l'échelle (valeur entre 5 et 180)

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

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_du_servobras=map(valeur_potar_position_du_servobras,0,1023,54,120);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servobras.write(valeur_potar_position_du_servobras);

// affiche le texte d'information sans retour a la ligne

Serial.print("position actuelle du bras -> ");

// affiche la valeur de la position du bras avec retour a la ligne

Serial.println(valeur_potar_position_du_servobras);

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

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

* traitement pour la position de la tete

// lecture de la valeur du potentiomètre (valeur entre 0 et 1023)

valeur_potar_position_du_servotete=analogRead(brochepotar_de_position_servotete);

// mise a l'échelle (valeur entre 5 et 180)

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

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_du_servotete=map( valeur_potar_position_du_servotete,0,1023,5,180);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servotete.write( valeur_potar_position_du_servotete);

// affiche le texte d'information sans retour a la ligne

Serial.print("position actuelle de la tete -> ");

// affiche la valeur de la position de la tete avec retour a la ligne

Serial.println( valeur_potar_position_du_servotete);

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

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

}

Réalisation de la main gauche de Inmoov

***

Mise à jour 04/06/2022 : Plusieurs améliorations ont été apportées au projet initial de la main gauche de Inmoov. La mise en place d’un pouce ajustable pour permettre la fermeture complète de la main et l’amélioration du système de tension des tendons.

Continuer la lecture →

Arduino + LCD 3,5”

Carte mère Uno avec écran

Mise à jour 09/02/2015

Caractéristiques générales:

Alimentation: 6 à 9 Vcc via le connecteur alimentation
Consommation: 200 mA
Mémoire Flash de 4 Mb pour le stockage d’images
Rétro-éclairage par led
Contraste: 500:1
Dimensions: 77 x 77 x 20 mm

Arduino:

Compatible avec la carte Arduino Uno R3
Microcontrôleur: ATMega328P
E/S digitales: 14 dont 6 PWM
Entrées analogiques: 6
Mémoire:
– Flash: 32 k
– SRAM: 2 k
– EEPROM: 1 k

Affichage tactile:

Microcontrôleur 16 bits
Contrôleur LCD RGB
Mémoire de stockage de 256 k
Résolution: 320 x 240 pixels
65536 couleurs
Ecran tactile résistif

Démarrage Arduino + LCD 3,5”

– Etape 1

Assurez-vous que vous avez la dernière version IDE Arduino .
Ci-joint le lien : http://www.arduino.cc/

Avant de commencer, effectuer le téléchargement des fichiers et Installer les pilotes de votre arLCD
Ci-joint le lien : http://www.earthlcd.com/

Branchez la carte écran « arLCD » dans un port USB libre et attendez quelques secondes. Windows reconnaît le nouveau matériel et l’affiche dans votre gestionnaire de disque. L’utilitaire arLCD a construit un disque Flash de 4 MO qui sera installé automatiquement à l’aide d’un pilote intégré Windows. Vous devez installer le driver EarthMake se trouvant sur votre carte afficheur ou sur le site du constructeur.

– Etape 2

Après avoir branché le ARLCD et installé avec succès le driver, un port COM sera disponible.
Ce port COM sera affiché dans le gestionnaire de périphériques, sous ports, vous verrez divers dispositifs tels que :

– Etape 3 : Mettre à jour les fichiers système .

Afin de tirer le meilleur parti de votre arLCD, il est recommandé de mettre à jour le système de fichiers. Vous avez peut-être déjà téléchargé le dernier système de fichiers à l’étape 1. Ouvrez le fichier zip nommé : « ArLCD_Filesystem_ {date} .zip » et copier l’ensemble des fichiers dans le répertoire racine de votre arLCD. Lorsque Windows vous demande d’écraser les fichiers existants, cliquez sur oui. Redémarrez le arLCD ou appuyer sur le bouton reset de votre carte.

006- ARLCD

– Etape 4 : Installation des fichiers de la bibliothèque de votre carte arLCD dans le programme IDE Arduino.

La carte arLCD est livré avec une bibliothèque pour être utilisé avec l’Arduino IDE, ce qui rend la programmation de l’afficheur très facile. Dans le fichier nommé arLCD_Library_{date}.zip que vous avez téléchargé plutôt. Vous trouverez un dossier nommé ezLCD. Ce dossier contient les fichiers de la bibliothèque et un exemple de programmation. Localisez le dossier de l’Arduino IDE sur votre ordinateur et copier le dossier ezLCD dans le dossier des bibliothèques .

– Etape 5 : Chargement d’un exemple de programme dans votre arLCD

Avant de communiquer avec votre afficheur arLCD, vous devez vérifier que le fichier startup.ezm doit être correctement configuré. Si un startup.ezm est dans le EZUSER \ Macros \ alors il sera utilisé. Sinon, il utilisera le startup.ezm dans le EZSYS \ Macros \ répertoire. Vous pouvez ouvrir ce fichier avec le bloc note de Windows 7 ou 8. Ouvrez le fichier startup et vérifiez si les lignes ci-dessous sont présentes dans celui-ci.

print « Arduino Mode CMD 38400 Baud »
cfgio 3 serial2_rx 38400 n81
cfgio 4 serial2_tx 38400 n81
cmd serial2
‘setup usb bridge to program arduino
CFGIO 2 serial1_tx 57600 n81
CFGIO 6 serial1_rx 57600 n81
CFGIO 7 USB_DTR
bridge USBserial1
‘extra options
cfgio 9 touch_int low quiet

Si vous deviez changer quelque chose, appuyez sur le bouton de réinitialisation à l’arrière de l’écran pour redémarrer le arLCD.
Remarque: Le arLCD utilise le GPU pour programmer l’Arduino via le port USB

EN COURS DE REALISATION

Les librairies Arduino

***

Mise à jour le 07/04/2015

Les bibliothèques sont un ensemble de codes qui vous permettent d’utiliser des fonctions élaborées de votre carte Arduino. Ces programmes spécialisés se trouvent dans le répertoire librairie du dossier Arduino .
Les fonctions sont disponible après son importation depuis l’IDE .

D’où une notion de « Classe »
On appelle « Classe » un regroupement de fonctions

Continuer la lecture →