RedOhm

Vue éclatée du capot pour la Zortrax M200

Vue éclatée du capot pour l’imprimante Zortrax M200 RedOhm fig 01

Vue éclatée du capot pour l’imprimante Zortrax M200 RedOhm fig 02

Vue éclatée du capot pour l’imprimante Zortrax M200 RedOhm fig 03

–

Différentes vue du capotage de l’imprimante Zortrax M200
en 3D

–

Impression avec du filament PLA standard

Caractéristique des pièces du capot Zortrax M200
en fonction du tableau de positionnement ci-dessous
pour du PLA standard

Pièces	Taille X en mm	Taille Y en mm	Taille Z en mm	Poids en g	Temps estimé
001	199	183	140	383g	31h
002	199	183	140	359g	31h
003	193	179	140	418g	36h30
004	55	84	110	125g	11h
005	143	140	140	137g	13h20
006	185	179	158	462g	46h
007	195	195	172	725g	71h
008	195	179	172	775g	73h
009	185	179	156	476g	72h
		Poids total ⇒		3854g

Estimation du budget avec un prix du PLA à 39 € les 2kg
3,854g*19,5€ = 75,15€

Positionnement conseillé des différentes pièces
pour du PLA standard

Les pièces ont été positionnées pour avoir une qualité visuelle après montage la plus propre possible. Comme beaucoup de PLA , quand vous enlevez les supports ,il reste des petites parties blanches disgracieuses. Si vous voulez éviter de passer beaucoup de temps en post impression pour le nettoyage , il faut choisir ce type de positionnement.

cliquez sur la pièce pour agrandir la vue

Position pour la pièce 001 Zortrax – RedOhm

Position pour la pièce 002 Zortrax – RedOhm

Position pour la pièce 003 Zortrax – RedOhm

Position pour la pièce 004 Zortrax – RedOhm

Position pour la pièce 005 Zortrax – RedOhm

Position pour la pièce 006 Zortrax – RedOhm

Position pour la pièce 007 Zortrax – RedOhm

Position pour la pièce 008 Zortrax – RedOhm

Position pour la pièce 009 Zortrax – RedOhm

Impression avec du filament PLA Arianeplast

Caractéristique des pièces du capot Zortrax M200
en fonction du tableau de positionnement ci-dessous
pour du PLA Arianplast

Attention : Attention seuls les types de filament suivant sont à utiliser dans ce cas bien précis, le PLA rouge , noir et gris métallisé 3D

Pièces	Taille X en mm	Taille Y en mm	Taille Z en mm	Poids en g	Temps estimé	Gain matière
001	199	183	140	383g	31h	0g
002	199	183	140	359g	31h	0g
003	193	179	140	418g	36h30	0g
004	55	84	110	110g	8h30	15g
005	143	140	140	118g	8h54	19g
006	185	179	158	251g	24h	211g
007	195	195	172	297g	30h	428g
008	195	179	172	369g	34h	406g
009	185	179	256	266g	26h	204g
		Poids total ⇒		2571g

Estimation du budget avec un prix du PLA type ArianePlast métallisée à 39 € les 2kg
3,854g*19,5€ = 50.13€

Positionnement conseillé des différentes pièces
pour du PLA type Arianeplast

Ce filament ( filament gris, rouge , noir métallisé exclusivement ) possède la propriété de ne laisser que très peu de traces lors du nettoyage des supports nécessaires à la fabrication de celle-ci. Cela nous permet d’avoir un aspect des plus réussis. C’est pour cette raison que les pièces sont positionnées pour avoir le moins de supports possibles, d’où une consommation de filament plus réduite et un temps d’impression moins long.

Position pour la pièce 001 ArianePlast Zortrax M200 – RedOhm

Position pour la pièce 002 ArianePlast Zortrax M200 – RedOhm

Position pour la pièce 003 ArianePlast Zortrax M200 – RedOhm

Position pour la pièce 004 ArianePlast Zortrax M200 – RedOhm

Position pour la pièce 005 ArianePlast Zortrax M200 – RedOhm

Position pour la pièce 006 ArianePlast Zortrax M200 – RedOhm

Position pour la pièce 007 ArianePlast Zortrax M200 – RedOhm

Position pour la pièce 008 ArianePlast Zortrax M200 – RedOhm

Position pour la pièce 009 ArianePlast Zortrax M200 – RedOhm

_

Impression des accessoires pour le capot de la Zortrax M200

Pièces	Taille X en mm	Taille Y en mm	Taille Z en mm	Poids en g	Temps estimé	Matière
020	98	14	119	93g	7h10mm	PLA
021	24	32	10	4g	32mm	ABS ou Hips
022	140	40	30	42g	4h28mm	ABS ou Hips

Les fichiers STL pour l’impression du capot pour l’imprimante Zortrax M200

Pieces dessous capot Zortrax M200

Cliquez sur la pièce pour agrandir la vue
Capot Zortrax piece 001	Capot Zortrax piece 002	Capot Zortrax piece 003
Capot Zortrax piece 004	Capot Zortrax piece 005

Fichier à télécharger pour imprimer ->

Pieces dessous capot Zortrax M200

1 fichier·s 239.69 KB

Pieces dessous capot Zortrax M200

Pieces dessus capot Zortrax M200

Capot Zortrax piece 006

Capot Zortrax piece 007

Capot Zortrax piece 008

Capot Zortrax piece 009

Fichier à télécharger pour imprimer ->

Pieces dessus capot Zortrax M200

1 fichier·s 517.46 KB

Pieces dessus capot Zortrax M200

Pieces capot Zortrax M200 accessoires

Pièce 020 – Capot câble Zortrax M200 – RedOhm

Pièce 021- Charniere Zortrax M200 – RedOhm

Pièce 022 -Poignet Zortrax M200 – RedOhm

Fichier à télécharger pour imprimer ->

Accessoire pour capot Zortrax M200

1 fichier·s 143.35 KB

Accessoire pour capot Zortrax M200

plaque de cote plexi droit
plaque de cote plexi gauche
plaque dessus
plaque devant bas
plaque devant haut

Dossier pour le plexiglas

Information technique et approvisionnement

Le polyméthacrylate de méthyle ou PMMA, plus connu sous le nom de plexiglas, a été inventé par les chimistes Barker et Skinner en 1924.
Il s’agit d’une matière Plastique appartenant à la famille des thermoplastiques, qui a pour propriétés d’être transparente et très résistante.
Ce matériau appartient à la famille des thermoplastiques, c’est-à-dire des matières plastiques qui se déforment et peuvent être façonnées sous l’action de la chaleur.

Source : Gralon.net
Exemple d’approvisionnement : Evonik industries

–

Plan de découpe pour le plexiglas

Plaque de cote plexi droit – RedOhm

Fichier ci-dessus de l’ensemble des plexi

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.

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.

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

}

En cours et à suivre .

Matériel Pololu

.

Rappel : Documentations sur le matériel utile dans nos réalisations.

Mise à jour de 26/11/2019

Sommaire :

Contrôleur de servomoteurs.
- Contrôleur de servomoteurs 6 canaux : micro Maestro 6
  1. Présentation de la carte micro Maestro 6
  2. Méthodes de contrôle
  3. Brochage du module micro Maestro 6
  4. Informations complémentaires
  5. Caractéristique
- Contrôleur de servomoteurs 12 canaux : Mini Maestro 12 ( en cours )
Commande de moteur en courant continu
- Commande de moteur CC MC33926 2,5A . Référence fabricant: 1212
Capteur de courant à effet hall
- ACS714 capteur de courant -30A to +30A

Présentation de l’article.

Nous avons remarqué que pour certains constructeurs, lorsque le materiel devient obsolète , il est difficile de se procurer: drivers, schéma, exemple de programme ou même sous quel système d’exploitation ce materiel fonctionnait, alors que nous en possédons encore dans nos tiroirs . C’est pour cela que nous avons décidé de stocker le maximum d’information sur notre site . Evidemment cela ne concerne que le materiel que nous utilisons .
Vous trouverez donc dans cette page aussi bien du materiel récent mais aussi du matériel d’ancienne génération .

Un ensemble de programme vous sera proposé pour chaque élément que nous utilisons sur nos robots .

Contrôleur de servomoteurs 6 canaux
micro Maestro 6

1 ) Présentation de la carte .

Micro Maestro 6 canaux Pololu vue de la carte

Les 6 canaux Micro Maestro élèvent les performances des contrôleurs de servo de série, avec des fonctionnalités telles que l’interface USB natif, le TTL et le contrôle de scripts embarqués.

Très performant, il permet un contrôle fin pour la vitesse et l’accélération grâce à sa résolution élevée (0.25µs).

2) 3 méthodes de contrôle : USB, série TTL (5 V) et script interne

USB pour une connexion directe à un ordinateur, via un logiciel disponible en libre téléchargement (sous environnement Windows ou Linux).
Série TTL pour une utilisation avec les systèmes embarqués.
Scripts embarqués que vous pourrez programmer (depuis votre ordinateur), puis faire « rejouer » de façon autonome par le module (sans qu’il soit connecté à l’ordinateur). Pour ce faire, le module dispose d’une mémoire interne de 8 Kb laquelle permet la mémorisation d’un script d’environ 3000 positions de servomoteurs .

3 ) Brochage du module micro Maestro 6

Micro Maestro 6 canaux Pololu repérage des pins de la carte

4 ) Informations complémentaires

Résolution de largeur d’impulsions de sortie de 0,25 µs ce qui équivaut à environ 0,025° pour un servomoteur classique.
Fréquence des impulsions configurable de 33 à 100 Hz
Large gamme d’impulsions de 64 à 3280 µs en utilisant l’ensemble des six servos avec un taux d’impulsions de 50 Hz
Commande individuelle de vitesse et d’accélération pour chaque canal
Les canaux peuvent aussi être utilisés comme sorties numériques ou entrées analogiques à usage général
Un langage de script simple vous permet de programmer le contrôleur pour effectuer des actions complexes, même après avoir enlevé les connexions USB et série.
L’application de contrôle et de configuration gratuite pour Windows vous permet facilement de configurer et tester votre contrôleur , créer, exécuter et enregistrer des séquences de mouvements de servo pour des animations électroniques et des robots marcheurs et écrire faire défiler et exécuter des scripts stockés dans le contrôleur de servomoteur
Le port COM virtuel permet de créer facilement des applications personnalisées pour envoyer des commandes de série via USB au contrôleur.
Caractéristiques de la série TTL
- Prise en charge de 300 à 250 000 kbps en mode de bauds fixes.
- Prise en charge de 300 à 115 200 kbps en mode de détection automatique de bauds
- Prise en charge simultanée du protocole Pololu, qui donne accès à des fonctionnalités avancées, et du protocole plus simple Scott Edwards MiniSSC II (il n’est pas nécessaire de configurer le dispositif pour un mode de protocole particulier).
- Peut être monté en série avec d’autres contrôleurs de moteur et de servo Pololu en utilisant une seule ligne de transmission de série

Caracteristique :

Alimentation: 5 à 16V ( attention a l’alimentation des servomoteurs )
Consommation : 40 à 50 mA max
Dimensions: 2,15 cm x 3,04 cm
Poids : 4,8 g
Référence fabricant: Contrôleur Micro Maestro 6
Prix moyen entre :15 à 17€

Information à telecharger:
Guide utilisateur Maestro -> [En] Maestro User’s Guide

Contrôleur de servomoteurs 12 canaux
Mini Maestro 12

en cours

Commande de moteur CC MC33926 2,5A .
Référence fabricant: 1212

–

Cette commande basée sur le circuit MC33926 permet de contrôler un moteur CC jusqu’à 2,5 A à partir d’une sortie PWM d’un microcontrôleur (Arduino, Seeeduino, etc).

Une tension de feedback permet d’avoir un retour sur la consommation du moteur. Ce module de petites dimensions est protégé contre les inversions de polarité, les surintensités et les échauffements excessifs.

Caractéristiques techniques

Alimentation:
Partie logique: 2,5 à 5,5 Vcc
Partie moteur: 5 à 28 Vcc
Sortie moteur : 2,5 A (5 A en pointe)
Feedback » retour information » consommation moteur: environ 525 mV/A
Dimensions: 31 x 26 x 12 mm
Référence fabricant: 1212
Prix moyen entre :15 à 18€
Support pour ce module : RedOhm impression 3D

–

Raccordement du module :

Pololu 1212 raccordement du module

Capteur de courant à effet hall
Definition

Le capteur de courant à effet Hall est un type de capteur de courant exploitant l’effet Hall pour produire une tension qui est l’image exacte (avec un facteur de proportionnalité connu) du courant à mesurer ou à visualiser.

L’effet Hall « classique » a été découvert en 1879 par Edwin Herbert Hall qui l’a énoncé comme suit : « un courant électrique traversant un matériau baignant dans un champ magnétique, engendre une tension perpendiculaire à ce dernier ». Sous certaines conditions, cette tension croît par paliers

Information technique supplémentaire

Capteur de courant à effet hall
ACS714 -30A to +30A

1 ) Présentation de la carte .

Capteur de courant 30A ACS714 Pololu

Ce capteur de courant basé sur un circuit à effet Hall ACS711EX permet de mesurer un courant de -30 A à +30 A. Une sortie analogique est proportionnelle au courant mesuré (2,5 V pour 0 A sous 5 Vcc). Un connecteur 5 broches est inclus (non soudé).

Montage de la carte :

Capteur de courant 30A ACS714 Pololu

Caractéristiques techniques

Alimentation: 3,3 à 5,0 Vcc
Consommation: 4 mA
Plage de mesure: -30 A à +30 A en AC ou DC
Plage d’utilisation: 30 Volts maxi
Sensibilité: 68 mV/A à 5 Vcc (45 mV/A à 3,3 Vcc)
Précision: ±4 %
Shunt: 0,6 mΩ
Bande passante: 100 kHz
T° de service: -40 à +125 °C
Dimensions: 21 x 18 x 3 mm
Référence fabricant: 2453

Mini Spider S12-PC patte courte 12 servomoteurs

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

Mini Spider S12 patte courte Version 02022017 – RedOhm

Sommaire :

Version 1.00 ou Version 02-02-2017. Vue éclatée de mini Spider S12-PC pour le choix des pièce , ensemble des fichiers à télécharger .
Version 09-02-2017 .Vue éclatée de mini Spider S12-PC pour le choix des pièce ensemble des fichiers à télécharger . ( Cette version est conseillée pour les néophytes de l’impression 3D ) .
Fichier pour le porte batterie et capot
Repérage des numéros des servomoteurs .
Divers programmes .
- Programme de calibrage des moteurs ( Positionnement a 90° du servomoteur ).
- Programme d’initialisation de mini-spider et un petit bonjour
- Programme d’enchaînement de divers sous programme ( Initialisation spider , petit bonjour , position d’attaque de Spider ,rotation de Spider)
Explication de l’alimentation des servomoteurs.
Présentation de Mr le régulateur 7806 en boitier TO220.
Retour au menu nos robots

Vue éclatée de mini Spider S12-PC et l’ensemble des fichiers à télécharger . Version 1.00

Vue éclatée de mini Spider S12 Version 1.00 – RedOhm

Vue de la patte et de son servomoteur – RedOhm –

Ensemble des fichiers à télécharger pour imprimer Spider version 1.00

–

Matériel utile :

12 Servomoteur: type ES08MA miniature avec pignonnerie métallique

Alimentation: 4,8 à 6 Vcc
Couple: 1,6 kg.cm à 4,8 Vcc
Vitesse: 0,12 s/60° à 4,8 Vcc
Dimensions: 24 x 12 x 29 mm

Informations techniques utiles :
Sur les servomoteurs en général , Carte Arduino Mega , La programmation en particulier de la carte Arduino Mega , l’impression 3D en général .

Fournisseur:
Servomoteurs : Gotronic
Arduino Mega 2560 : Selectronic

Montant total du montage ( en version simple ):

1 Ensemble de PLA ou HIPS ou ABS => 25 €
12 servomoteurs à 6.90 € => 82.80 €
1 carte arduino Mega => 29.95€
Soit un montant de = 137.75 € prix moyen

–

.

Vue éclatée de mini Spider S12-PC pour le choix des pièce et l’ensemble des fichiers à télécharger Version 09-02-2017

Spider version 09-02-2017 RedOhm – 001

Spider version 09-02-2017 RedOhm – 002

Spider version 09-02-2017 RedOhm – 003

–

Ensemble des fichiers à télécharger pour imprimer Spider Version 2.00

–

Matériel utile :

12 Servomoteur: type ES08MA miniature avec pignonnerie métallique

Alimentation: 4,8 à 6 Vcc
Couple: 1,6 kg.cm à 4,8 Vcc
Vitesse: 0,12 s/60° à 4,8 Vcc
Dimensions: 24 x 12 x 29 mm

Informations techniques utiles :
Sur les servomoteurs en général , Carte Arduino Mega , La programmation en particulier de la carte Arduino Mega , l’impression 3D en général .

Fournisseur:
Servomoteurs : Gotronic
Arduino Mega 2560 : Selectronic

Montant total du montage ( en version simple ):

1 Ensemble de PLA ou HIPS ou ABS => 25 €
12 servomoteurs à 6.90 € => 82.80 €
1 carte arduino Mega => 29.95€
Soit un montant de = 137.75 € prix moyen

Porte batterie et capot

.

Ensemble des fichiers à télécharger pour imprimer le capot et le porte batterie

–

Repérage des numéros des servomoteurs

Robot Spider repérage RedOhm

–

Programme de calibrage des moteurs ( Positionnement a 90° du servomoteur )

Voici un petit programme pour Arduino permettant de positionner un servomoteur à 90°. Ce positionnement se produit quand on appuie sur le bouton poussoir , tant que celui-ci est sollicité le servomoteur conserve sa position, quand le bouton est relâché le servo est à nouveau libre.

/*
 * RedOhm
 * 
 * 
 * Positionne un servomoteur à son centre 
 *              donc à 90°
 *              
 * Le 06/12/2016
 * H.Mazelin              
 */
 
 
// Cette librairie permet à une carte Arduino de contrôler des servomoteurs
#include <Servo.h>
 
// Crée un objet de type "Servo", nommé -> monservo
Servo monservo;
 
// le bouton est connecté à la broche 2 de la carte Arduino
const int bouton=2;
// Variable qui enregistre l'état du bouton
int etatdubouton;
 
/* 
 * 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() {
 
 
//le bouton est une entrée
  pinMode(bouton,INPUT);
//on initialise l'état du bouton comme "relaché"
  etatdubouton=LOW;
  
}
 
/*
 *Le programme principal s’exécute par une boucle infinie appelée Loop () 
 * 
 */
 
 
void loop() {
 
// lecture de l'etat du bouton
etatdubouton=digitalRead(bouton);
 
//test si le bouton a un niveau logique HAUT
if (etatdubouton == HIGH)
{
// associe le servomoteur a la broche 3  
   monservo.attach(3);
// Positionne mon servomteur a 90
   monservo.write(90);
// 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);
}
 
else 
{
 
// Dissocie la variable monservo de sa broche   
 monservo.detach();
 
}
 
 
  
 
}

* RedOhm

* Positionne un servomoteur à son centre

* donc à 90°

* Le 06/12/2016

* H.Mazelin

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

#include <Servo.h>

// Crée un objet de type "Servo", nommé -> monservo

Servo monservo;

// le bouton est connecté à la broche 2 de la carte Arduino

const int bouton=2;

// Variable qui enregistre l'état du bouton

int etatdubouton;

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

//le bouton est une entrée

pinMode(bouton,INPUT);

//on initialise l'état du bouton comme "relaché"

etatdubouton=LOW;

}

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

void loop() {

// lecture de l'etat du bouton

etatdubouton=digitalRead(bouton);

//test si le bouton a un niveau logique HAUT

if (etatdubouton == HIGH)

{

// associe le servomoteur a la broche 3

monservo.attach(3);

// Positionne mon servomteur a 90

monservo.write(90);

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

}

else

{

// Dissocie la variable monservo de sa broche

monservo.detach();

}

–

Programme d’initialisation de mini-spider et un petit bonjour

/*
 * 
 * 
 * RedOhm
 * 
 * Initialisation de mini spider
 * 
 * but : les pattes en bas et droite
 * enfin un petit bonjour pour nous confirmer
 * que le robot est en attente
 * 
 * 
 * Le 28/01/2017
 * H-Mazelin
 */

 



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


//Crée un objet de type "Servo", nommé -> servo_d1
 Servo servo_d1; 
//Crée un objet de type "Servo", nommé -> servo_d2
 Servo servo_d2;
//Crée un objet de type "Servo", nommé -> servo_d3
 Servo servo_d3; 
//Crée un objet de type "Servo", nommé -> servo_d4
 Servo servo_d4;
//Crée un objet de type "Servo", nommé -> servo_d5
 Servo servo_d5;
//Crée un objet de type "Servo", nommé -> servo_d6
 Servo servo_d6;
//Crée un objet de type "Servo", nommé -> servo_d7
 Servo servo_d7;
//Crée un objet de type "Servo", nommé -> servo_d8
 Servo servo_d8; 
//Crée un objet de type "Servo", nommé -> servo_d9
 Servo servo_d9;
//Crée un objet de type "Servo", nommé -> servo_d10
 Servo servo_d10; 
//Crée un objet de type "Servo", nommé -> servo_d11
 Servo servo_d11;
//Crée un objet de type "Servo", nommé -> servo_d12
 Servo servo_d12;

// variable du type int pour les deplacement des servomoteurs
// a droite 
 int initd=5;
// variable du type int pour les deplacement des servomoteurs
// a gauche 
 int initg=5;
// variable du type int pour les boucle for 
 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() {

// associe le servomoteur a la broche 2 
 servo_d1.attach(2,700,2000);
// associe le servomoteur a la broche 3 
 servo_d2.attach(3,700,2000);
// associe le servomoteur a la broche 4 
 servo_d3.attach(4,700,2000);
// associe le servomoteur a la broche 5 
 servo_d4.attach(5,700,2000); 
// associe le servomoteur a la broche 6 
 servo_d5.attach(6,700,2000); 
// associe le servomoteur a la broche 7 
 servo_d6.attach(7,700,2000); 
 
//associe le servomoteur a la broche 8 
 servo_d7.attach(8,700,2000);
//associe le servomoteur a la broche 9 
 servo_d8.attach(9,700,2000);
//associe le servomoteur a la broche 10 
 servo_d9.attach(10,700,2000);
//associe le servomoteur a la broche 11 
 servo_d10.attach(11,700,2000); 
//associe le servomoteur a la broche 12 
 servo_d11.attach(12,700,2000); 
//associe le servomoteur a la broche 13 
 servo_d12.attach(13,700,2000); 

// Appel de la fonction -> initialisation 
initialisation(); 
// pause pour le positionnement des servomoteurs 
delay(500);


// lancement d'un petit bonjour 
 servo_d1.write (175);
 for (x=0;x<2;x++){
 servo_d2.write (30);
 delay(500);
 servo_d2.write (150); 
 delay(500); 
 }
 
 servo_d2.write (90);
 delay(200);
 servo_d1.write (5);
 delay(500);
 servo_d1.write (175);
 for (x=0;x<2;x++){
 servo_d2.write (30);
 delay(500);
 servo_d2.write (150); 
 delay(500); 
 
 } 
 servo_d2.write (90);
 servo_d1.write (5);
}

// fin du bonjour 



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

 


 
}


// Initialisation spider

void initialisation()
 {
 
 // position des pattes en bas 
 initd=5;
 initg=175;
 
 servo_d1.write (initd);
 servo_d9.write (initd);
 servo_d11.write (initd); 
 
 servo_d5.write (initg);
 servo_d3.write (initg); 
 servo_d7.write (initg);
 
 
 // position des pattes au centre 
 servo_d2.write (90);
 servo_d4.write (90);
 servo_d6.write (90);
 servo_d8.write (90); 
 servo_d10.write (90); 
 servo_d12.write (90); 
 

 }

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

* RedOhm

* Initialisation de mini spider

* but : les pattes en bas et droite

* enfin un petit bonjour pour nous confirmer

* que le robot est en attente

* Le 28/01/2017

* H-Mazelin

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

#include <Servo.h>

//Crée un objet de type "Servo", nommé -> servo_d1

Servo servo_d1;

//Crée un objet de type "Servo", nommé -> servo_d2

Servo servo_d2;

//Crée un objet de type "Servo", nommé -> servo_d3

Servo servo_d3;

//Crée un objet de type "Servo", nommé -> servo_d4

Servo servo_d4;

//Crée un objet de type "Servo", nommé -> servo_d5

Servo servo_d5;

//Crée un objet de type "Servo", nommé -> servo_d6

Servo servo_d6;

//Crée un objet de type "Servo", nommé -> servo_d7

Servo servo_d7;

//Crée un objet de type "Servo", nommé -> servo_d8

Servo servo_d8;

//Crée un objet de type "Servo", nommé -> servo_d9

Servo servo_d9;

//Crée un objet de type "Servo", nommé -> servo_d10

Servo servo_d10;

//Crée un objet de type "Servo", nommé -> servo_d11

Servo servo_d11;

//Crée un objet de type "Servo", nommé -> servo_d12

Servo servo_d12;

// variable du type int pour les deplacement des servomoteurs

// a droite

int initd=5;

// variable du type int pour les deplacement des servomoteurs

// a gauche

int initg=5;

// variable du type int pour les boucle for

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

// associe le servomoteur a la broche 2

servo_d1.attach(2,700,2000);

// associe le servomoteur a la broche 3

servo_d2.attach(3,700,2000);

// associe le servomoteur a la broche 4

servo_d3.attach(4,700,2000);

// associe le servomoteur a la broche 5

servo_d4.attach(5,700,2000);

// associe le servomoteur a la broche 6

servo_d5.attach(6,700,2000);

// associe le servomoteur a la broche 7

servo_d6.attach(7,700,2000);

//associe le servomoteur a la broche 8

servo_d7.attach(8,700,2000);

//associe le servomoteur a la broche 9

servo_d8.attach(9,700,2000);

//associe le servomoteur a la broche 10

servo_d9.attach(10,700,2000);

//associe le servomoteur a la broche 11

servo_d10.attach(11,700,2000);

//associe le servomoteur a la broche 12

servo_d11.attach(12,700,2000);

//associe le servomoteur a la broche 13

servo_d12.attach(13,700,2000);

// Appel de la fonction -> initialisation

initialisation();

// pause pour le positionnement des servomoteurs

delay(500);

// lancement d'un petit bonjour

servo_d1.write (175);

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

servo_d2.write (30);

delay(500);

servo_d2.write (150);

delay(500);

}

servo_d2.write (90);

delay(200);

servo_d1.write (5);

delay(500);

servo_d1.write (175);

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

servo_d2.write (30);

delay(500);

servo_d2.write (150);

delay(500);

}

servo_d2.write (90);

servo_d1.write (5);

}

// fin du bonjour

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

void loop() {

}

// Initialisation spider

void initialisation()

{

// position des pattes en bas

initd=5;

initg=175;

servo_d1.write (initd);

servo_d9.write (initd);

servo_d11.write (initd);

servo_d5.write (initg);

servo_d3.write (initg);

servo_d7.write (initg);

// position des pattes au centre

servo_d2.write (90);

servo_d4.write (90);

servo_d6.write (90);

servo_d8.write (90);

servo_d10.write (90);

servo_d12.write (90);

}

Programme enchaînement de divers sous programme 002

Initialisation spider
Petit bonjour
Position d’attaque de Spider
Rotation de Spider

/*
 * 
 * 
 * RedOhm
 * 
 * Programme enchaînement de divers sous programme 
 * 
 * Initialisation spider
 * Petit bonjour 
 * Position d'attaque de Spider 
 * Rotation de Spider 
 * 
 * Le 18/02/2017
 * H-Mazelin
 * 
 */

 



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


//Crée un objet de type "Servo", nommé -> servo_d1
  Servo servo_d1; 
//Crée un objet de type "Servo", nommé -> servo_d2
  Servo servo_d2;
//Crée un objet de type "Servo", nommé -> servo_d3
  Servo servo_d3;  
//Crée un objet de type "Servo", nommé -> servo_d4
  Servo servo_d4;
//Crée un objet de type "Servo", nommé -> servo_d5
  Servo servo_d5;
//Crée un objet de type "Servo", nommé -> servo_d6
  Servo servo_d6;
//Crée un objet de type "Servo", nommé -> servo_d7
   Servo servo_d7;
//Crée un objet de type "Servo", nommé -> servo_d8
   Servo servo_d8;      
//Crée un objet de type "Servo", nommé -> servo_d9
   Servo servo_d9;
//Crée un objet de type "Servo", nommé -> servo_d10
   Servo servo_d10;   
//Crée un objet de type "Servo", nommé -> servo_d11
   Servo servo_d11;
//Crée un objet de type "Servo", nommé -> servo_d12
   Servo servo_d12;

// variable du type int pour les deplacement des servomoteurs
// a droite 
 int initd=5;
// variable du type int pour les deplacement des servomoteurs
// a gauche 
  int initg=5;
// variable du type int pour les boucle for   
  int x;
// variable du type int pour le deplacement arriere
int arriere =90;


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

// associe le servomoteur a la broche 2  
  servo_d1.attach(2,700,2000);
// associe le servomoteur a la broche 3  
  servo_d2.attach(3,700,2000);
// associe le servomoteur a la broche 4  
  servo_d3.attach(4,700,2000);
// associe le servomoteur a la broche 5  
  servo_d4.attach(5,700,2000);  
// associe le servomoteur a la broche 6  
  servo_d5.attach(6,700,2000);  
// associe le servomoteur a la broche 7  
  servo_d6.attach(7,700,2000);  
    
//associe le servomoteur a la broche 8  
  servo_d7.attach(8,700,2000);
//associe le servomoteur a la broche 9  
  servo_d8.attach(9,700,2000);
//associe le servomoteur a la broche 10  
  servo_d9.attach(10,700,2000);
//associe le servomoteur a la broche 11  
  servo_d10.attach(11,700,2000);  
//associe le servomoteur a la broche 12 
  servo_d11.attach(12,700,2000);  
//associe le servomoteur a la broche 13 
  servo_d12.attach(13,700,2000);   



// Appel de la fonction -> initialisation 
initialisation(); 
// pause pour le positionnement des servomoteurs 
delay(1500);


   
}
 


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

// appel du sous programme un petit bonjour 
  petit_bonjour();
// temporisation 
  delay(500);
// appel du sous programme attaque 
  attaque_spider();
 // Appel de la fonction -> initialisation 
initialisation(); 
// pause pour le positionnement des servomoteurs 
delay(500);
  
  
// temporisation 
  delay(2000); 



// realisation de 5 pas de rotation 
for (x=0;x<5;x++){
// appel du sous programme rotation
  rotation_spider(); 
  delay(300);
}  

   

  
}


/* 
 * =============================================
 *      
 *         ensemble de sous programme 
 *      
 * =============================================     
 */

// Initialisation spider

void initialisation()
 {
  
  // position des pattes en bas 
  initd=5;
  initg=175;
    
  servo_d1.write (initd);
   servo_d9.write (initd);
    servo_d11.write (initd); 
 
  servo_d5.write (initg);
    servo_d3.write (initg);  
      servo_d7.write (initg);
  
  
  // position des pattes au centre 
  servo_d2.write (90);
     servo_d4.write (90);
       servo_d6.write (90);
        servo_d8.write (90);   
         servo_d10.write (90);    
          servo_d12.write (90);    
  

 }



//========== sous programme petit bonjour ==========

void petit_bonjour()

{

 
   servo_d1.write (175);
    for (x=0;x<2;x++){
     servo_d2.write (30);
      delay(500);
     servo_d2.write (150); 
      delay(500); 
 }
   
   servo_d2.write (90);
   delay(200);
   servo_d1.write (5);
   delay(500);
   servo_d1.write (175);
    for (x=0;x<2;x++){
     servo_d2.write (30);
      delay(500);
     servo_d2.write (150); 
      delay(500);    
 
    } 
    servo_d2.write (90);
    servo_d1.write (5);



}

//==================fin du bonjour ======================


//========= position d'attaque de Spider ================

void attaque_spider()

{ 

  initd=55;
  initg=125;
    
  servo_d1.write (initd);
   servo_d9.write (initd);
    servo_d11.write (initd); 
 
  servo_d5.write (initg);
    servo_d3.write (initg);  
      servo_d7.write (initg);
  
  
  // position des pattes au centre 
  servo_d2.write (90);
     servo_d4.write (90);
       servo_d6.write (90);
        servo_d8.write (90);   
         servo_d10.write (90);    
          servo_d12.write (90);  

  delay(1000);
  servo_d8.write (40);   
  servo_d10.write (140); 
  delay(1000);
  initd=175;
  servo_d1.write (initd);
  servo_d11.write (initd); 
  delay(1000); 

  for (x=0;x<5;x++){
     initd=135;
  servo_d1.write (initd);
  servo_d11.write (initd); 
  delay(300);
    initd=175;
  servo_d1.write (initd);
  servo_d11.write (initd); 
  delay(300);
 } 

 }

 //====== position d'attaque de Spider =======



void rotation_spider()
{
 

 //===== rotation de spider ==================

//patte 1
 servo_d1.write (25);
  delay (200);
 servo_d2.write (50);
  delay (200);
 servo_d1.write (5);
  delay (200); 
//patte 2  
 servo_d11.write (25);
  delay (200);
 servo_d12.write (50);
  delay (200);
 servo_d11.write (5);
  delay (200); 
//patte3
servo_d9.write (25);
  delay (200);
 servo_d10.write (50);
  delay (200);
 servo_d9.write (5);
  delay (200); 
//patte4
servo_d3.write (150);
  delay (200);
 servo_d4.write (50);
  delay (200);
 servo_d3.write (175);
  delay (200); 
//patte 5
servo_d5.write (150);
  delay (200);
 servo_d6.write (50);
  delay (200);
 servo_d5.write (175);
  delay (200); 
 //patte6
 servo_d7.write (150);
  delay (200);
 servo_d8.write (50);
  delay (200);
 servo_d7.write (175);
  delay (200);  

// position des pattes en arriere 
 arriere=130;
// position des pattes au centre 
  servo_d2.write (arriere);
     servo_d4.write (arriere);
       servo_d6.write (arriere);
        servo_d8.write (arriere);   
         servo_d10.write (arriere);    
          servo_d12.write (arriere);  

 delay(500);

}

 //=====Fin de rotation de spider =====================

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

* RedOhm

* Programme enchaînement de divers sous programme

* Initialisation spider

* Petit bonjour

* Position d'attaque de Spider

* Rotation de Spider

* Le 18/02/2017

* H-Mazelin

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

#include <Servo.h>

//Crée un objet de type "Servo", nommé -> servo_d1

Servo servo_d1;

//Crée un objet de type "Servo", nommé -> servo_d2

Servo servo_d2;

//Crée un objet de type "Servo", nommé -> servo_d3

Servo servo_d3;

//Crée un objet de type "Servo", nommé -> servo_d4

Servo servo_d4;

//Crée un objet de type "Servo", nommé -> servo_d5

Servo servo_d5;

//Crée un objet de type "Servo", nommé -> servo_d6

Servo servo_d6;

//Crée un objet de type "Servo", nommé -> servo_d7

Servo servo_d7;

//Crée un objet de type "Servo", nommé -> servo_d8

Servo servo_d8;

//Crée un objet de type "Servo", nommé -> servo_d9

Servo servo_d9;

//Crée un objet de type "Servo", nommé -> servo_d10

Servo servo_d10;

//Crée un objet de type "Servo", nommé -> servo_d11

Servo servo_d11;

//Crée un objet de type "Servo", nommé -> servo_d12

Servo servo_d12;

// variable du type int pour les deplacement des servomoteurs

// a droite

int initd=5;

// variable du type int pour les deplacement des servomoteurs

// a gauche

int initg=5;

// variable du type int pour les boucle for

int x;

// variable du type int pour le deplacement arriere

int arriere =90;

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

// associe le servomoteur a la broche 2

servo_d1.attach(2,700,2000);

// associe le servomoteur a la broche 3

servo_d2.attach(3,700,2000);

// associe le servomoteur a la broche 4

servo_d3.attach(4,700,2000);

// associe le servomoteur a la broche 5

servo_d4.attach(5,700,2000);

// associe le servomoteur a la broche 6

servo_d5.attach(6,700,2000);

// associe le servomoteur a la broche 7

servo_d6.attach(7,700,2000);

//associe le servomoteur a la broche 8

servo_d7.attach(8,700,2000);

//associe le servomoteur a la broche 9

servo_d8.attach(9,700,2000);

//associe le servomoteur a la broche 10

servo_d9.attach(10,700,2000);

//associe le servomoteur a la broche 11

servo_d10.attach(11,700,2000);

//associe le servomoteur a la broche 12

servo_d11.attach(12,700,2000);

//associe le servomoteur a la broche 13

servo_d12.attach(13,700,2000);

// Appel de la fonction -> initialisation

initialisation();

// pause pour le positionnement des servomoteurs

delay(1500);

}

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

void loop() {

// appel du sous programme un petit bonjour

petit_bonjour();

// temporisation

delay(500);

// appel du sous programme attaque

attaque_spider();

// Appel de la fonction -> initialisation

initialisation();

// pause pour le positionnement des servomoteurs

delay(500);

// temporisation

delay(2000);

// realisation de 5 pas de rotation

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

// appel du sous programme rotation

rotation_spider();

delay(300);

}

* =============================================

* ensemble de sous programme

* =============================================

// Initialisation spider

void initialisation()

{

// position des pattes en bas

initd=5;

initg=175;

servo_d1.write (initd);

servo_d9.write (initd);

servo_d11.write (initd);

servo_d5.write (initg);

servo_d3.write (initg);

servo_d7.write (initg);

// position des pattes au centre

servo_d2.write (90);

servo_d4.write (90);

servo_d6.write (90);

servo_d8.write (90);

servo_d10.write (90);

servo_d12.write (90);

}

//========== sous programme petit bonjour ==========

void petit_bonjour()

{

servo_d1.write (175);

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

servo_d2.write (30);

delay(500);

servo_d2.write (150);

delay(500);

}

servo_d2.write (90);

delay(200);

servo_d1.write (5);

delay(500);

servo_d1.write (175);

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

servo_d2.write (30);

delay(500);

servo_d2.write (150);

delay(500);

}

servo_d2.write (90);

servo_d1.write (5);

}

//==================fin du bonjour ======================

//========= position d'attaque de Spider ================

void attaque_spider()

{

initd=55;

initg=125;

servo_d1.write (initd);

servo_d9.write (initd);

servo_d11.write (initd);

servo_d5.write (initg);

servo_d3.write (initg);

servo_d7.write (initg);

// position des pattes au centre

servo_d2.write (90);

servo_d4.write (90);

servo_d6.write (90);

servo_d8.write (90);

servo_d10.write (90);

servo_d12.write (90);

delay(1000);

servo_d8.write (40);

servo_d10.write (140);

delay(1000);

initd=175;

servo_d1.write (initd);

servo_d11.write (initd);

delay(1000);

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

initd=135;

servo_d1.write (initd);

servo_d11.write (initd);

delay(300);

initd=175;

servo_d1.write (initd);

servo_d11.write (initd);

delay(300);

}

//====== position d'attaque de Spider =======

void rotation_spider()

{

//===== rotation de spider ==================

//patte 1

servo_d1.write (25);

delay (200);

servo_d2.write (50);

delay (200);

servo_d1.write (5);

delay (200);

//patte 2

servo_d11.write (25);

delay (200);

servo_d12.write (50);

delay (200);

servo_d11.write (5);

delay (200);

//patte3

servo_d9.write (25);

delay (200);

servo_d10.write (50);

delay (200);

servo_d9.write (5);

delay (200);

//patte4

servo_d3.write (150);

delay (200);

servo_d4.write (50);

delay (200);

servo_d3.write (175);

delay (200);

//patte 5

servo_d5.write (150);

delay (200);

servo_d6.write (50);

delay (200);

servo_d5.write (175);

delay (200);

//patte6

servo_d7.write (150);

delay (200);

servo_d8.write (50);

delay (200);

servo_d7.write (175);

delay (200);

// position des pattes en arriere

arriere=130;

// position des pattes au centre

servo_d2.write (arriere);

servo_d4.write (arriere);

servo_d6.write (arriere);

servo_d8.write (arriere);

servo_d10.write (arriere);

servo_d12.write (arriere);

delay(500);

}

//=====Fin de rotation de spider =====================

–

Présentation de Mr le régulateur 7806 en boitier TO220

La série de régulateurs à trois broches LM78XX est disponible dans de nombreuses valeurs de tensions de sortie fixes et est très utile dans nombre d’applications. Bien que conçus pour fournir des tensions de sortie fixes, ces circuits peuvent également délivrer des tensions et courants réglables à l’aide de quelques composants extérieurs

La série LM78XX est disponible en boîtier aluminium TO-220 et peut délivrer jusqu’à 1 A si on utilise un refroidisseur approprié. Ce boîtier possède une limitation en courant interne pour ne pas dépasser les limites de sécurité en courant de pointe. Une plage de sécurité est prévue pour le transistor de sortie permettant de limiter la puissance interne dissipée. Si celle-ci devient trop importante pour le refroidisseur utilisé, le circuit de disjonction thermique est activé pour éviter une surchauffe du circuit intégré.

_

ROBOT MAYA – Module Ez-Robot pour le pilotage de Maya avec Arduino

***

Archive de l’article : ROBOT MAYA – Module Ez-Robot pour le pilotage de Maya avec Arduino derniere remise à jour le 11/02/2017 . Chez RedOhm , nous avons pris l’habitude de consever les anciennes notices de logiciel ou de matériel .Voici donc une version que nous utilisions pour la période 2016 à septembre 2017. Cette version est la version logiciel 2016–06–11–00.

Continuer la lecture →

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.

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

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

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

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

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

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

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

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

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 )

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 )

–

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

É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

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

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

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

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

Support écran pièce 054

–

Fichier à télécharger pour imprimer ->

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

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

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)

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

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

Avant bras type Terminator Version 2.00

Mise à jour le 10/07/2019 : Retrouvez sur cette page l’ensemble des articles concernant le projet type Terminator ( album photos , plan mécanique , fichier à télécharger pour l’impression 3D etc. ).

Continuer la lecture →

Actionneur – Fil à mémoire de forme

***

Mise à jour le 19/06/2018

Définition alliage à mémoire de forme

Un alliage à mémoire de forme (AMF) est un alliage possédant plusieurs propriétés inédites parmi les matériaux métalliques : la capacité de garder en mémoire une forme initiale et d’y retourner même après une déformation, la possibilité d’alterner entre deux formes préalablement mémorisées lorsque sa température varie autour d’une température critique, et un comportement superélastique permettant des allongements sans déformation permanente supérieurs à ceux des autres métaux. Parmi les principaux alliages à mémoire de forme, on retrouve toute une variété d’alliages de nickel et de titane comme constituants principaux, en proportions presque égales. Bien que « nitinol » ne soit en fait que le nom de l’un de ces « alliages quasi-équiatomiques nickel-titane », cette appellation est devenue couramment utilisée dans la littérature pour désigner l’ensemble de ces alliages, qui ont des propriétés fort semblables. Afin d’alléger le texte, il en sera fait ici le même usage. Dans une moindre mesure, le laiton et certains alliages cuivre-aluminium possèdent également des propriétés de mémoire de forme.

Présentation du fil Flexinol

A température ambiante, un fil FLEXINOL peut être étiré facilement sans grand effort. Cependant, le fait de le porter à une température supérieure à sa température de transition modifie sa structure ce qui a pour effet de le faire revenir de lui-même à sa taille initiale en fournissant une force considérable.

Propriétés physiques :

   – Taux de rétreint en longueur : 3 à 5 % (indépendant du diamètre du fil)
   – Nombre de manœuvres : >1million de cycle (si utilisés conformément aux instructions).
   – Temps de rétreint très court : aussi vite qu’il chauffe !
   – Temps de relaxation (retour à la longueur initiale) : dépend de la T° ambiante.
   – Assistance possible par un moyen externe (ressort , etc.).

Le fil FLEXINOL est disponible en deux T° de transition : 70 °C et 90 °C.

Plus la T° est élevée, plus il faut de puissance pour le chauffer mais plus le temps de relaxation sera court.

Nombre de cycles possibles par minute :

– fil “70 °C” : 9 à 40.
– fil “90 °C” : 13 à 65.

Référence	Température en degrés	Force en gr	Temps de réaction en seconde	Courant de contraction / s	Résistance en Ohms/m	Diamètre en mm
5765	90	36	0.3	85mA	500	0.05
5722	70	321	2	415mA	55	0.15

Utilisation du produit

Dans les montages ou nous utilisons le fil Flexinol, un contrôle du courant est essentiel pour obtenir des résultats satisfaisants. S’il y a trop de courant, le fil ne parviendra pas à se contracter à l’inverse un excès de courant et le fil surchauffera, et dans ce cas il peut perdre ses propriétés de mémoire de forme. On s’aperçoit que les variations de courant auront une incidence sur le temps de chauffage et de refroidissement. Il est important avant de faire quoique ce soit, au niveau du montage, de bien intégrer les paramètres électriques du fil utilisé, voir le tableau ci-dessous.

Flexinol tableau de paramètres

***

Quelques vidéos

Anecdote :

le saviez-vous ,flexinol a été utilisé pour faire fonctionner un capteur de poussière installé sur le Rover Sojourner qui a atterri sur Mars dans le cadre de la mission mars Pathfinder le 4 juillet 1997.

Référence à :

Référence technique : robotics.hobbizine.com/
Information sur les alliage à mémoire de forme : Wikipédia
Information produit :
Nos fournisseurs :

Etude du robot Maya pas à pas

***

RedOhm Maya le 26/11/2016

Mise à jour le 29/01/2016

Sommaire :

Expression des yeux de Maya
10-10-2016 Assemblage des yeux et de la bouche de Maya ( Diaporama )
22-10-2016 avancement de la tète de Maya . ( Diaporama )
22-10-2016 Une petite vidéo pour découvrir l’ensemble des pièces qui composent la tête (Vidéo)
26-10-2016 Impression 3d des premières pièces du robot Maya ( Diaporama )
27/10/2016 Montage de la partie inférieure du visage ( Diaporama )
29/10/2016 Modifications du robot Maya avec la pose du cou ( Diaporama )
02/11/2016 Impression des pièces .Version 2.00
17/11/2016 Vidéo de l’ensemble tête , thorax, épaule ( Vidéo )
20/11/2016 Premiers essais du robot Maya 5 ( Vidéo )
26/11/2016 Etude du montage des épaule sur le thorax ( Diaporama et vidéo )
03/12/2016 Montage du thorax , du cou , de la tête et essai de l’ensemble ( vidéo )
10/12/2016 Mise au point du système de vision pour la partie mécanique ( vidéo )
18/01/2017 Modification de l’encéphale ( photos )
29/01/2017 Etude du bras ( Photos )

Retour au menu principal

Expression des yeux de Maya

La question est la suivante comment donner une expression à 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

Le programme de la construction de l’œil est disponible .
Le programme des différents regards . En cours

Construction de l’oeil de Maya

10-10-2016 Assemblage des yeux et de la bouche de Maya

Vignettes

22-10-2016 avancement de la tète de Maya .

Positionnement d’une visière amovible
Les cartes de pilotages pour le système visuel sont en place ( Arduino Mega ) .
- Descriptif technique de la carte :

La carte Arduino Mega 2560 est basée sur un ATMega2560 cadencé à 16 MHz. Elle dispose de 54 E/S dont 14 PWM, 16 analogiques et 4 UARTs.

Du pointeur laser sur la partie gauche de Maya
Du micro avec la carte de reconnaissance vocale du type : EasyVR 3.0
- Descriptif technique de la carte :

Ce module peut reconnaître 32 mots ou expressions de commande que l’utilisateur enregistre au préalable, dans n’importe quelle langue. Ces commandes enregistrées sont de type mono-locuteur (le module ne réagit qu’à l’ordre de la personne qui a enregistré la commande).

Le shield EasyVR dispose également de 26 commandes pré-enregistrées pour chaque langage supporté. Ces expressions sont reconnues quelle que soit la personne qui les prononce. Ces expressions sont: robot, action, bouge, tourne, cours, regarde, attaque, arrête, salut, à gauche, à droite, vers le haut, vers le bas, en avant, en arrière, zéro, un, deux, trois, quatre, cinq, six, sept, huit, neuf, dix)

Le module peut être utilisé avec des cartes équipées d’une interface UART alimentée en 3,3 – 5 Vcc. Le logiciel est téléchargeable gratuitement et le module est livré avec un micro séparé.

Diaporama de la journée du 23/10/2016

Vignettes

22-10-2016 Une petite vidéo pour découvrir l’ensemble des pièces qui composent la tête

***

26/10/2016 – Impression 3d des premières pièces du robot Maya

Vignettes

***

27/10/2016 Montage de la partie inférieure du visage

Les essais de montage sur le robot Maya continuent .Nous avons essayé le montage de l’écran qui fait office de bouche et le montage du capteur ultrasonique.

Descriptif technique de la carte écran qui fait office de bouche

Ecran couleur LCD TFT 1,77″ Arduino spécialement prévu pour être raccordé sur la carte Arduino Esplora via 2 rangées de connecteurs. Cet afficheur peut également fonctionner avec les cartes UNO, Leonardo, Due, etc.

Le module est équipé d’un port micro-SD, ce qui permet notamment de stocker et afficher des images bitmap et il communique avec la carte Arduino via le port SPI. La librairie contenue dans la version Arduino 1.5.8 beta est nécessaire au bon fonctionnement de cet afficheur.

Alimentation: 5 Vcc
Ecran: 1,77″
Couleurs: 262000
Résolution: 160 x 128 pixels
Port: SPI
Support carte: micro-SD
Température de service: -20 à +70°C
Dimensions: 60 x 42 x 15 mm
Référence fabricant: A000096
Utilisation pratique de l’afficheur : RedOhm le regarde attentif

Prix moyen entre : 22 à 30€
Fournisseur : generationrobots

Descriptif technique de la mesure de distance ( moyenne 4 m max )

Ce télémètre compatible Grove permet de mesurer la distance sans contact à l’aide de transducteurs à ultrasons.Il se raccorde sur une entrée analogique du Grove Base Shield ou du Mega Shield via un câble 4 conducteurs .

Interface: compatible Grove
Alimentation: 5 Vcc
Consommation: 15 mA
Fréquence: 40 kHz
Sortie digitale:
– état HAUT: ligne noire détectée
– état BAS: couleur blanche détectée
Led: rouge si détection d’une ligne noire
Portée de détection: 3 cm à 4 m
Résolution: 1 cm
Dimensions: 43 x 25 x 15 mm
Référence Seeedstudio: 101020010 (remplace SEN10737P)

Prix moyen entre : 13 à 16€
Fournisseur : gotronic.fr

Vignettes

***

29/10/2016 Modifications du robot Maya avec la pose du cou

Vignettes

***

02/11/2016 Impression des pièces Version 2.00

Nous avons sorti l’ensemble des pièces principales du système de vision ainsi que la partie de la mâchoire inférieure et le carter. L’ensemble de ces pièces ont déjà subi quelques modifications. Nous sommes déjà à la version 2.00

***

Visualisation des pièces ci-dessus

Vignettes

***

17/11/2016 Vidéo de l’ensemble tête , thorax, épaule

Présentation de l’ensemble tête , thorax , épaule de notre robot Maya . Cette vidéo à pour but de vous donner un aperçu du rendu de l’ensemble ainsi qu’une vision des mouvements de la tête .

20/11/2016 Premiers essais du robot Maya

Utilisation du materiel ci-dessous pour les essais

La carte EZ-B V4 permet de contrôler et commander un robot ou autre application de votre choix pilotée par PC via une liaison Wifi. Il suffit d’utiliser une plateforme de base ou de construire vous-même un robot de base et d’ajouter la carte EZ-B.

L’utilisation du logiciel EZ-Builder sur votre ordinateur vous permet de contrôler les sorties de la carte de commande EZ-B. Ajoutez des capteurs, caméras, leds, servomoteurs, afficheurs digitaux, contrôleurs de moteurs, etc pour réaliser le projet.

Le logiciel graphique EZ-Builder est prévu pour ceux qui ne souhaitent pas programmer. Il suffit de connecter les capteurs, servomoteurs, leds, afficheurs LCD et bouton à la carte EZ-B et d’utiliser le logiciel graphique pour commander le robot à partir de votre PC.

Caractéristiques:

Alimentation à prévoir: 9 Vcc (6 piles AA non incluses)
8 entrées analogiques
24 E/S digitales (dont PWM, ports série et commandes servos)
3 ports I2C
Processeurs: Cortex M3 ARM 120 MHz et Microchip PIC32 80 MHZ
Fréquence de fonctionnement: 120 MHz + 80 MHz
wifi: Hoc, infrastructure, WEP, WPA et WPA2
Fusible réarmable
Dimensions avec socle: 70 x 67 x 56 mm

Premiers essais du robot Maya 20/11/2016

***

Documentation materiel :

Pour plus d’information sur le papillon Galactique :

26/11/2016 Etude du montage des épaule sur le thorax

Vignettes

***

Utilisation de servomoteur MASTODON 9944 pour les articulations des épaules

Le servomoteur digital Mastodon 9944 est idéal pour les gros modèles de modèle réduit . Son boîtier en aluminium parfaitement étanche, usiné dans la masse, ses pignons en métal et son axe de sortie à roulement à billes vous offrent de belles performances.

Caractéristiques :

Boîtier en aluminium usiné dans la masse.
Parfaitement étanche
Train de pignons métalliques parfaitement dimensionné
Axe de sortie supporté par 2 gros roulements à billes
Moteur électrique de bonne dimension
Disque servo en aluminium Ø46mm (épaisseur 3mm!)
Alimentation 7,4V séparée (accu LiPo 2S)

Décoration de la carcasse du robot Maya

Nous avons aussi ajouté des symboles Maya sur la carcasse du robot comme décoration, par exemple sur le support porte coup le papillon galactique .

RedOhm le robot Maya : sur la base du porte cou le symbole du papillon galactique

Quelle est la définition du papillon galactique dans la culture Maya ?

Ce symbole est appelé Hunab Ku ou Papillon Galactique dans la mythologie Maya ; il est dit qu’il représente toute la Conscience ayant jamais existé dans cette galaxie. Il englobe la totalité de nos ancêtres sur le plan physique, les humains, les animaux, les reptiles, les poissons, les crustacés et également les plantes en tant que conscience qui organise toute matière à l’état brut à partir d’un disque tournoyant dans les étoiles, les planètes et les systèmes solaires. Ceci possède une grande signification. Si grande que les Mayas d’origine ne possédaient aucun symbole pour cela. Dans leur civilisation il n’y avait pas de nom pour « Dieu ». La connaissance du concept était suffisante.

Ce symbole est appelé Hunab Ku ou Papillon Galactique dans la mythologie Maya . RedOhm

Un récapitulatif en vidéo du travail accompli le 26/11/2016

***

03/12/2016 Montage du thorax , du cou , de la tête et essai de l’ensemble

Maya construction du thorax , du cou ,de la tête RedOhm

10/12/2016 Mise au point du système de vision pour la partie mécanique

18/01/2017 Modification de l’encéphale

Nous avons modifié la partie de l’encéphale mais il faut savoir que les versions 1.00 ou 2 .00 sont compatibles avec le reste des ensembles du robot Maya .Ces modifications ont pour but d’améliorer la pose des cartes ainsi que le câblage de celle-ci. Les personnes qui ont déjà démarré la version 1.00 ne doivent pas s’inquiéter, l’ensemble de la version 1.00 est opérationnelle.

Ci-dessous une photo en coupe pour vous montrer le support carte Arduino , alors que dans la version 1.00 les cartes étaient visées sur les côtés de la boite crânienne

Encéphale avec support carte pour Arduino – RedOhm

Modification et renforcement de la partie fixation de la face avant

Robot Maya cache face avant renfort de la partie fixation RedOhm

L’ouverture d’accès de l’encéphale agrandit de Maya pour la pose et le câblage des cartes Arduino

L’ouverture d’accès de l’encéphale agrandit de Maya – RedOhm

Nouveau capot suite aux modifications de l’ouverture. 2 versions de ce capot seront disponibles. Une pour les imprimantes 200*200*200 et une version pour les imprimantes avec un espace supérieur à celui précité.

Nouveau capot suite aux modification de l’ouverture – RedOhm

Pièce d’assemblage modifiée pour gagner de la place en vue du câblage des cartes électroniques

Pièce d’assemblage modifiée robot Maya – RedOhm

Modification seulement pour le rendu de la pièce

Modification seulement pour le rendu de la pièce – RedOhm

Aperçu de l’ensemble des modifications du robot Maya

Aperçu de l’ensemble des modifications – RedOhm