Archives par étiquette : REDOHM

ROBOT MAYA – Version 2.00 Dossier pour la construction de la tête du robot

–

Mise à jour 16/06/2019 . 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 )

Continuer la lecture →

Zortrax M200 – Capot

***

Mise à jour le 08/01/2018.Grâce a ce capot pour l’imprimante Zortrax M200 , il est beaucoup plus facile d’imprimer des matières comme l’ABS qui ont tendance à subir le choc thermique entre la température environnante et la chaleur du plateau , de plus il saura maintenir la température intérieure de votre imprimante 3D. Il protégera vos impressions des aléas extérieurs comme par exemple les courants d’air, poussières ect..

Capot pour Zortrax M200 – RedOhm

Sommaire :

Présentation
Vue éclatée du capot pour la Zortrax M200
Différentes vue du capotage de l’imprimante Zortrax M200 en 3D
Différentes vue pour le montage du capot
Impression avec du filament PLA standard
- Caractéristique des pièces du capot Zortrax M200 pour du PLA standard
- Positionnement conseillé des différentes pièces pour du PLA standard
Impression avec du filament PLA Arianeplast
- Caractéristique des pièces du capot Zortrax M200 pour du PLA Arianplast
- Positionnement conseillé des différentes pièces pour du PLA type Arianeplast
Impression des accessoires pour le capot de la Zortrax M200
Les fichiers STL pour l’impression du capot pour l’imprimante Zortrax M200
- Pièces dessous capot Zortrax M200
- Pièces dessus capot
- Pièces capot Zortrax M200 accessoires
Dossier pour le plexiglas
- Information technique et approvisionnement
- Plan de découpe pour le plexiglas

Présentation du capot pour Zortrax M200

Grâce a ce capot , il est beaucoup plus facile d’imprimer des matières comme l’ABS qui ont tendance à subir le choc thermique entre la température environnante et la chaleur du plateau , de plus il saura maintenir la température intérieure de votre imprimante 3D. Il protégera vos impressions des aléas extérieurs comme par exemple les courants d’air, poussières ect..

Sécurité :
Dans un contexte public comme les fablab par exemple, ce capot permet une utilisation sécurisée et sans risque et de plus atténuera les éventuelles nuisances sonores .
Le capot est muni filtre contre les micro-particules.

A savoir sur les risques des micro-particule

Les chercheurs ont testé deux matériaux d’impression 3D différentes, l’ABS (acrylonitrile butadiene styrene) et le PLA (polylactic acid), pour voir combien de particules fines sont émises à chaque réalisation. Ils ont constaté que l’ABS émet 10 fois plus de particules que le PLA. L’étude met en garde contre les imprimantes d’entrée de gamme qui impriment à la fois en ABS et PLA. Elle prend l’exemple de la xxx xxxxx qui coûte 800 euros et de ses instructions liées à la sécurité. « Le PLA est un matériau sûr et non toxique, il n’y a pas de risques connus sur la santé lorsqu’il est utilisé dans les imprimantes 3D », peut-on lire sur la notice et d’ajouter « lors de l’impression avec l’ABS, il y a une odeur de plastique brûlé. C’est tout à fait normal, mais il peut aussi causer des maux de têtes, une irritation des voies respiratoires et des yeux pour les personnes sensibles ». Brent Stephens indique que plusieurs études ont montré que les fumées d’ABS étaient toxiques sur les souris et les rats.

Articles qui traite sur le sujet :
⇒ le monde informatique
⇒ Prévention du risque chimique Cnrs
⇒ Sciences et avenir : L’impression 3D est elle dangereuse pour la santé

–

Retour au sommaire

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

–

Retour au sommaire

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

–

Retour au sommaire

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€

Retour au sommaire

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

Retour au sommaire

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

_

Retour au sommaire

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

Retour au sommaire

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

Retour au sommaire

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

Retour au sommaire

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

Retour au sommaire

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

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

Retour au sommaire

Robot Maya : Programme oeil penaud droit

***

Maya oeil penaud droit RedOhm

/*
 * 
 * 
 * Creation de l'oeil penaud droit
 * 
 * 
 * 
 * 
 * code projet : 0000-Oeil_penaud_droit
 * 
 * Herve Mazelin - RedOhm
 * 21/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" par defaut 
#include <SPI.h>
// je charge la librairie TFT
// Cette bibliothèque permet à une carte Arduino de communiquer à
// l'écran LCD TFT 
#include <TFT.h> 

// Affectation des pins pour la communication Arduino-> afficheur  
#define cs   10
#define dc   9
#define rst  8
 
TFT screen = TFT(cs, dc, rst);


// variable du type int pour les boucle de creation de l'oeil
// Declare la variable X 
// Rappel sur la fonction d'une variable :On peut définir une variable comme
// une boite ou l’on stock des balles .Une variable est une boite ou 
// l’on stock un nombre ,et comme il existe une multitude de nombres:
// Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette
// variable .
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'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);
 

  // Dessin de l'oeil penaud ------------------------------

  // je dessine un triangle 

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

}

void loop() {
  // vide pour le besoin de la demonstration

}

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

* Creation de l'oeil penaud droit

* code projet : 0000-Oeil_penaud_droit

* Herve Mazelin - RedOhm

* 21/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" par defaut

#include <SPI.h>

// je charge la librairie TFT

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

// l'écran LCD TFT

#include <TFT.h>

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

#define cs 10

#define dc 9

#define rst 8

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

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

// Declare la variable X

// Rappel sur la fonction d'une variable :On peut définir une variable comme

// une boite ou l’on stock des balles .Une variable est une boite ou

// l’on stock un nombre ,et comme il existe une multitude de nombres:

// Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette

// variable .

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

// Dessin de l'oeil penaud ------------------------------

// je dessine un triangle

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

}

void loop() {

// vide pour le besoin de la demonstration

}

***

Impression 3D Support bobine du type Verbatim pour Zortrax M300

***

Information pour l’impression :

– Temps de réalisation : 4h38 mm
– Matière : 58 grammes
– Type de Matière : Z-HIPS ( autre voir tableau )
– Remplissage : High dans le menu Z- suite ( correspond à ± 60 % )
– Définition : Normal ( dans menu Z-suite )
– Température : 240 à 250 °C
– Note pour ABS : Un lit chauffé à 130°C

Robot Maya : Support yeux pièce 011 Version 3.00

***

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

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

–

Retour au sommaire

.

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

Retour au sommaire

Porte batterie et capot

.

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

–

Retour au sommaire

Repérage des numéros des servomoteurs

Robot Spider repérage RedOhm

–

Retour au sommaire

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

}

–

Retour au sommaire

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

}

Retour au sommaire

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é.

_

Retour au sommaire

ROBOT MAYA – Le regard penaud

Mise à jour le 26/02/2017

Sommaire :

Définition de penaud
Rappel de la fiche technique
Schéma de raccordement de l’afficheur et de la carte Arduino 2560
Programme : La création du regard penaud de Maya de l’œil droit .

Définition de penaud :

Qui est embarrassé, confus, généralement à la suite d’une déconvenue, d’une maladresse ou pour avoir été pris en défaut

Maya oeil penaud droit RedOhm

Retour au sommaire

Description technique :

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
Site officiel Arduino: www.arduino.org

Retour au sommaire

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

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

***

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

Retour au sommaire

Programme : La création du regard penaud de Maya de l’œil droit .

/*
 * 
 * 
 * Creation de l'oeil penaud droit
 * 
 * 
 * 
 * 
 * code projet : 0000-Oeil_penaud_droit
 * 
 * Herve Mazelin - RedOhm
 * 21/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" par defaut 
#include <SPI.h>
// je charge la librairie TFT
// Cette bibliothèque permet à une carte Arduino de communiquer à
// l'écran LCD TFT 
#include <TFT.h> 

// Affectation des pins pour la communication Arduino-> afficheur  
#define cs   10
#define dc   9
#define rst  8
 
TFT screen = TFT(cs, dc, rst);


// variable du type int pour les boucle de creation de l'oeil
// Declare la variable X 
// Rappel sur la fonction d'une variable :On peut définir une variable comme
// une boite ou l’on stock des balles .Une variable est une boite ou 
// l’on stock un nombre ,et comme il existe une multitude de nombres:
// Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette
// variable .
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'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);
 

  // Dessin de l'oeil 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);        
  }
  

  


  




}

void loop() {
  // vide pour le besoin de la demonstration

}

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

* Creation de l'oeil penaud droit

* code projet : 0000-Oeil_penaud_droit

* Herve Mazelin - RedOhm

* 21/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" par defaut

#include <SPI.h>

// je charge la librairie TFT

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

// l'écran LCD TFT

#include <TFT.h>

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

#define cs 10

#define dc 9

#define rst 8

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

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

// Declare la variable X

// Rappel sur la fonction d'une variable :On peut définir une variable comme

// une boite ou l’on stock des balles .Une variable est une boite ou

// l’on stock un nombre ,et comme il existe une multitude de nombres:

// Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette

// variable .

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

// Dessin de l'oeil 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);

}

void loop() {

// vide pour le besoin de la demonstration

}

Retour au sommaire

***

ROBOT MAYA – Je veux tout savoir

Mise à jour le 08/04/2019 : L’ équipe RedOhm a pour objectif de créer un robot semi humanoïde complet . Le robot Maya sera reproductible par tous et une grande partie sera en impression 3D.Retrouvez l’ensemble des articles concernant le projet Maya sur notre site https://www.redohm.fr ou suivez-nous sur notre chaîne YouTube. Continuer la lecture →

Support pour avant bras projet Inmoov

***

Mise à jour le 10/10/2016

redohm-support-bras-inmoov-0050_01

Sommaire :

Présentation
Fichier pour l’impression 3D
Tableau récapitulatif pour l’impression 3D
Liste de l’ensemble des pièces
Montage de l’ensemble des pièces

Retour au sommaire

***

1-Présentation

Vous avez sur cette page les principaux paramètres pour réaliser le support pour l’avant bras du projet Inmoov entre autre, 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 (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

Retour au sommaire

***

2-Fichier pour l’impression 3D

A) Support pied haut

Patte pour support bras Inmoov

Remplissage de : 50%
Temps d’impression : 8h54mm
Matière : PLA noir conseiller 156.69g (0.3450lb)

Paramètre imprimante 3D
Résolution : 0.2mm
Température : 210 degrés
Raft : oui
Support : oui

Télécharger le fichier » Support pied haut » ->

Projet Inmoov - Support pied haut

1 fichier·s 17.76 KB

Support pied haut

Retour au sommaire

B) Support pied bas

Remplissage de : 50%
Temps d’impression : 7h12mm
Matière : PLA noir conseiller 122.59g (0.27lb)

Paramètre imprimante 3D
Résolution : 0.2mm
Température : 210 degrés
Raft : oui
Support : oui

Télécharger le fichier » Support pied bas » ⇓

Projet Inmoov - Support pied bas

1 fichier·s 19.42 KB

Support pied bas

Retour au sommaire

C) Logo ( RedOhm )

Remplissage de : 30%
Temps d’impression : 1h25mm
Matière : PLA noir conseiller 22,64g (0.05lb)

Paramètre imprimante 3D
Résolution : 0.2mm
Température : 210 degrés
Raft : oui
Support : oui

Télécharger le fichier » Logo » ⇓

Projet Inmoov -Logo RedOhm

1 fichier·s 11.16 KB

Logo RedOhm

Retour au sommaire

***

3- Tableau récapitulatif pour l’impression 3D

Référence de la pièce	Temps d’impression	Poids en Gramme	Poids en lb
Support pied haut	8h54mm	156.69g	0.3450lb
Support pied bas	7h12mm	122.59g	0.27lb
Logo	1h25mm	22,64g	0.05lb
Total ->	15h31mm	301.92g	0.665Ib

Retour au sommaire

***

4- Liste de l’ensemble des pièces

Quantités	Désignation
1	Support pied haut
1	Support pied bas
1	Logo
2	Tube en aluminium diamètre 8 longueur 40 cm
2	Tige filetée diamètre 6
4	Écrou borgne

Retour au sommaire

***

5- Montage de l’ensemble des pièces

06102016 – Vue de l’ensemble des pièces

06102016 – Montage des 2 entretoises sur le pied bas – RedOhm

06102016 – Assemblage avec le pied haut – RedOhm

06102016 – Montage des tiges filetées – RedOhm

06102016 – Montage des ecrous borgne de 6mm – RedOhm

Le bras Inmoov dans son support – RedOhm

Retour au sommaire

Support 3 axes

Mise à jour le 20/09/2019 : C’est un support trois axes qui pourrait utiliser pour différentes réalisations. L’ensemble de ce projet a été réalisé pour que certaines pièces comme les cages des servomoteurs soient réutilisé dans d’autres applications.

Sommaire :

Présentation du projet .
Tutoriel de montage en photo .
1. Montage du servomoteur dans la base .
2. Montage du Palonnier type roue sur la cage .
3. Assemblage de la cage sur le servomoteur de la base .
4. Montage du servo porte bras .
5. Assemblage du bras .
6. Assemblage de la partie haute.
Ensemble des fichiers pour l’impression 3D.
1. Base du support 3 axes.
2. Cage support pour servomoteur partie bas .
3. Bras du support 3 axes
4. Cage pour servomoteur partie haute
5. Support supérieure
Programme pour tester les limites mini et maxi du support 3 axes
Schéma de branchement de l’ensembles des actionneurs et potentiomètre .
1. Montage avec une carte Arduino Mega 2560.
  1. Liste du matériel câblage classique .
  2. Liste du matériel avec utilisation du matériel Grove
  3. Schéma électrique de principe
  4. Exemple de programme sur Arduino Mega
2. Montage avec une carte Arduino Uno ( en cours )
  1. Exemple de programme sur Arduino Uno
  2. Liste du matériel avec utilisation du matériel Grove
  3. Schéma électrique de principe .
  4. Exemple de programme sur Arduino Uno
Retour au menu nos robots

Présentation du projet .

.

Vue

C’est un support trois axes qui pourrait utiliser pour différentes réalisations. L’ensemble de ce projet a été réalisé pour que certaines pièces comme les cages des servomoteurs soient réutilisé dans d’autres applications.

Retour au sommaire

Tutoriel de montage en photo .

1: Montage du servomoteur HS-422 dans sa base .

Nous pouvons aussi utiliser le servomoteur Hitec HS-645 MG en sachant que les 2 servo ne possèdent pas le même couple . Nous avons un couple de 4.7kg.cm pour le HS-422 et de 9.6kg.cm pour le HS-645 MG .

Montage du servomoteur HS-422 dans sa base

Montage du servomoteur HS-422 dans sa base (fig 2)

Montage du servomoteur HS-422 dans sa base (fig 3)

Retour au sommaire

2:Montage du Palonnier type roue sur la cage support du servomoteur ( en général ce type de palonnier est vendu avec son servo ) .

RedOhm : Montage du palonnier

Retour au sommaire

3:Assemblage de la cage sur le servomoteur de la base .

Redohm : On passe un petit tournevis dans l’orifice de la cage porte servo prévu pour ce type de montage

Redohm : Vue en gros plan

Retour au sommaire

4:Montage du servo porte bras .

Redohm : Montage du servo porte bras

Retour au sommaire

5:Assemblage du bras et montage du Palonnier type roue dans le bras ( en général ce type de palonnier est vendu avec son servo ) .

Redohm : Vue du bras fig.10

Redohm : Vue du bras fig.11

RedOhm : Montage du palonnier fig.20

RedOhm : Montage du palonnier fig.21

Redohm: Montage de l’ensemble fig.22

Redohm:Vue d’ensemble fig.23

Retour au sommaire

6:Assemblage de la partie haute .

Redohm:Support haut fig.60

Redohm: Support servomoteur superieur fig.61

Redohm : Vue d’ensemble fig.62

Redohm : Vue d’ensemble avec servomoteur et support fig.63

Redohm : Vue d’ensemble avec servomoteur et support fig.64

Retour au sommaire

Ensemble des fichiers pour l’impression 3D.

Piece 001 : Base du support 3 axes

Piece 001 : Base pour support 3 axes

Temps d’impression pour un remplissage de 30% ⇒ 7h21mm
Matière : PLA 120.01g
Résolution : 0.2mm

Télechargement de : Piece 001-Base du support 3 axes

Retour au sommaire

Piece 002 : Cage support servomoteur partie bras

Temps d’impression pour un remplissage de 30% ⇒ 1h17mm.
Matière : PLA 16.62g (0.037lb)
Résolution : 0.2mm

Télechargement de : Pièce 002-Cage servomoteur partie bras

Retour au sommaire

Piece 003 : Bras du support 3 axes

Bras pour support 3 axes

Temps d’impression pour un remplissage de 30% ⇒ 2h57mm
Matière : PLA 46.54g (0.103lb)
Résolution : 0.2mm

Télechargement de : Pieces 003-Bras pour support 3 axes

Retour au sommaire

Piece 004 : Cage pour servomoteur partie haute

Piece 004 – Cage pour servomoteur partie haute

Temps d’impression pour un remplissage de 30% ⇒ 1h06mm
Matière : PLA 14.43g (0.023lb)
Résolution : 0.2mm

Télechargement de : Piece 004-Cage servomoteur partie haute

Retour au sommaire

Piece 005 : Support supérieure

Piece 005- Support supérieure fig 005.1

Temps d’impression pour un remplissage de 30% ⇒ 00h21mm
Matière : PLA 6.64g (0.015lb)
Résolution : 0.2mm

Télechargement de : Piece 005-Support supérieure

Retour au sommaire

Programme pour tester les limites mini et maxi du support 3 axes

//
//
//

/*
 * RedOhm
 * 
 * 
 * Essai et reglage des servomoteurs a l'aide 
 * d'un potentiometre en vue de determiner les 
 * limites min et max 
 *              
 * Le 27/08/2016
 * H.Mazelin              
 */





// Cette librairie permet à une carte Arduino de contrôler des servomoteurs
#include &lt;Servo.h&gt;

 
// Crée un objet de type "Servo", nommé -&gt; monservo
Servo monservo;
// broche sur lequel est branche le potentiometre
int brochepotar_de_position=2;
// variable contenant la valeur de la potentiometre 
int valeur_potar_position;



/*
 *  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() {
  Serial.begin(9600);
// associe le servomoteur a la broche 3   
  monservo.attach(3); 
 
}


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

void loop() {
 // lecture de la valeur du potentiomètre (valeur entre 0 et 1023)  
  valeur_potar_position=analogRead( brochepotar_de_position); 
// mise a l'échelle (valeur entre 5 et 180)
// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position=map(valeur_potar_position,0,1023,5,180);
// définit la position d'asservissement du servomoteur 
// en fonction de la valeur à l'échelle  
  monservo.write(valeur_potar_position);
  Serial.println(valeur_potar_position);
// 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);
}

* RedOhm

* Essai et reglage des servomoteurs a l'aide

* d'un potentiometre en vue de determiner les

* limites min et max

* Le 27/08/2016

* H.Mazelin

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

#include <Servo.h>

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

Servo monservo;

// broche sur lequel est branche le potentiometre

int brochepotar_de_position=2;

// variable contenant la valeur de la potentiometre

int valeur_potar_position;

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

Serial.begin(9600);

// associe le servomoteur a la broche 3

monservo.attach(3);

}

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

void loop() {

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

valeur_potar_position=analogRead( brochepotar_de_position);

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

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

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

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

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

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

monservo.write(valeur_potar_position);

Serial.println(valeur_potar_position);

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

}

Retour au sommaire

Schéma de branchement de l’ensembles des actionneurs et potentiomètre .

1:Montage avec une carte Arduino Mega 2560

a) Liste du materiel pour câblage classique.

3 potentiomètre de 10kΩ
3 servomoteurs Hitec référence HS-645MG ou Hitec HS422
1 carte Arduino Mega 2560
1 alimentation variable régler a 6 Volt ou une alimentation fixe 6V
1 Alimentation pour la carte micro ( alimentation de 7 à 12 V sur connecteur alim = vin tension positive en entrée ne pas oublier la masse à brancher sur la pin Gnd ).Si on utilise plus de 12V, le régulateur de tension de la carte pourrait chauffer et en cascade détruire la carte )

b) Liste du matériel avec utilisation du matériel Grove :

1 Module Grove Mega Shield V1.2 référence -> 103020027 .Le module Grove Base Shield est une carte d’interface permettant de raccorder facilement, rapidement et sans soudure les capteurs et les actionneurs Grove de Seeedstudio sur une carte compatible Arduino.
3 Potentiomètre à glissière Grove 101020036 ou potentiomètre rotatif Grove 101020048
3 servomoteurs Hitec référence HS-645MG ou Hitec HS422
1 carte Arduino Mega 2560
1 alimentation variable régler a 6 Volt ou une alimentation fixe 6V
1 Alimentation pour la carte micro ( alimentation de 7 à 12 V sur connecteur alim = vin tension positive en entrée ne pas oublier la masse à brancher sur la pin Gnd ) .Si on utilise plus de 12V, le régulateur de tension de la carte pourrait chauffer et en cascade détruire la carte )

c) Schéma électrique de principe.

: Redohm : Schéma avec un Arduino Mega cliquez sur le dessin pour l’agrandir

d) Exemple de programme sur Arduino Mega

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




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

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

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

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

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

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



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



void loop() {

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


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


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


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


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


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

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

*RedOhm

*Programme pour piloter separement chaque moteur du support

*trois axes

*le 27/08/2016

* H-Mazelin

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

#include <Servo.h>

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

Servo servobase;

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

Servo servobras;

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

Servo servotete;

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

int brochepotar_de_position_servobase=0;

// variable contenant la valeur du potentiometre pour le servobase

int valeur_potar_position_du_servobase;

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

int brochepotar_de_position_servobras=2;

// variable contenant la valeur du potentiometre pour le servobras

int valeur_potar_position_du_servobras;

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

int brochepotar_de_position_servotete=4;

// variable contenant la valeur du potentiometre pour le servotete

int valeur_potar_position_du_servotete;

* Un programme Arduino doit impérativement contenir cette fonction

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

* Elle sert à configurer globalement les entrées sorties

void setup() {

// initialisation de la connexion série

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

Serial.begin(9600);

// associe le servomoteur servobase a la broche 3

servobase.attach(3);

// associe le servomoteur servobras a la broche 4

servobras.attach(4);

// associe le servomoteur servotete a la broche 5

servotete.attach(5);

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

Serial.println("* *");

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

Serial.println("* operationnel *");

Serial.println("* *");

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

Serial.println(" ");

//pause presentation

delay (5000);

}

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

void loop() {

* traitement pour la position de la base

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

valeur_potar_position_du_servobase=analogRead( brochepotar_de_position_servobase);

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

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

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

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

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

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

servobase.write(valeur_potar_position_du_servobase);

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

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

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

Serial.println(valeur_potar_position_du_servobase);

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

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

* traitement pour la position du bras

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

valeur_potar_position_du_servobras=analogRead(brochepotar_de_position_servobras);

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

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

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

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

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

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

servobras.write(valeur_potar_position_du_servobras);

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

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

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

Serial.println(valeur_potar_position_du_servobras);

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

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

* traitement pour la position de la tete

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

valeur_potar_position_du_servotete=analogRead(brochepotar_de_position_servotete);

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

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

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

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

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

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

servotete.write( valeur_potar_position_du_servotete);

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

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

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

Serial.println( valeur_potar_position_du_servotete);

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

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

}

Retour au sommaire

2:Montage avec une carte Arduino Uno

Liste du materiel :

3 potentiomètre de 10kΩ
3 servomoteurs Hitec référence HS-645MG ou Hitec HS422
1 carte Arduino Uno
1 alimentation variable régler a 6 Volt ou une alimentation fixe 6V
1 Alimentation pour la carte micro ( alimentation de 7 à 12 V sur connecteur alim = vin tension positive en entrée ne pas oublier la masse à brancher sur la pin Gnd ).Si on utilise plus de 12V, le régulateur de tension de la carte pourrait chauffer et en cascade détruire la carte )

Liste du matériel avec utilisation du matériel Grove :

1 Module Grove Base Shield 103030000 . Le module Grove Base Shield est une carte d’interface permettant de raccorder facilement, rapidement et sans soudure les capteurs et les actionneurs Grove de Seeedstudio sur une carte compatible Arduino.
3 Potentiomètre à glissière Grove 101020036 ou potentiomètre rotatif Grove 101020048 .
3 servomoteurs Hitec référence HS-645MG ou Hitec HS422 .
1 Carte arduino Uno
1 alimentation variable régler a 6 Volt ou une alimentation fixe 6V .
1 Alimentation pour la carte micro ( alimentation de 7 à 12 V sur connecteur alim = vin tension positive en entrée ne pas oublier la masse à brancher sur la pin Gnd ).Si on utilise plus de 12V, le régulateur de tension de la carte pourrait chauffer et en cascade détruire la carte )