Archives de catégorie : Robotique

–

Mise à jour : 18/08/2019 : L’équipe RedOhm vous présente le Cobot Oryon.Le robot collaboratif ou cobot est un robot permettant de ne pas avoir de cage de sécurité autour de lui. Donc de pouvoir s’approcher du robot en toute sécurité.

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

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

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 →

Robot Nestor – Version 1.00 Dossier pour la construction du robot

–

Mise à jour 16/06/2019 . Retrouvez sur cette page l’ensemble des articles concernant le robot Nestor (album photos des pièces , plan mécanique , fichier à télécharger pour l’impression 3D )

Continuer la lecture →

ROBOT MAYA – Version 2.00 Dossier pour la construction du robot pour le bras et la main gauche

–

Mise à jour 28/10/2018 . Retrouvez sur cette page l’ensemble des articles concernant le robot Maya pour l’impression du bras et de la main gauche ( album photos des pièces , plan mécanique , fichier à télécharger pour l’impression 3D

en cours de realisation

Continuer la lecture →

Robot Maya : Programmation de Maya en utilisant les bloc Ez-Robot

–

Mise à jour le 12/09/2018 –

Continuer la lecture →

Robot Golbotth8

–.

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

Continuer la lecture →

Robot Nestor : Tutoriel de montage du visage de Nestor

–

Mise à jour le 04/08/2018 : Le but de ce tutoriel est de clarifier le montage des différents éléments dans le visage du robot Nestor. Vous retrouvez sur cette page ou sur la vidéo les références des matériels ainsi que les liens éventuels pour vous les procurer.

Continuer la lecture →