RedOhm

–

04/02/2017 Etude et réalisation du support carte
pour la version 1.00 de Maya

Maya support carte Arduino Version 1.00 ( position de carte dans la boite crânienne ) – RedOhm -003

Maya soutien carte arduino Version 1.00 – RedOhm -002

Maya soutien carte arduino Version 1.00 – RedOhm -001

10/02/2017 Suite de l’étude des bras et avant bras avant essais

Nous voilà à une étape très importante, la fabrication des bras, l’étude étant terminée, nous allons commencer l’impression pour tester la résistance et la mobilité de l’ensemble. La motorisation du haut du bras est assurée par un servomoteur Mastodon 9944 de la marque Topmodel . Ce matériel est disponible chez le distributeur France robotique, Il développe une poussée de 99 kg.cm et affiche une excellente performance. Sur ce matériel, pour avoir le couple maximal, il faudra construire une alimentation de 7.4 V de façon à optimiser le couple de sortie. La partie de l’avant-bras est motorisée par un servo de marque Hitec HS805BB, il développe un couple de 24 kg.cm. Un seul bémol à ce choix et le coût des servomoteurs Mastodon, il sera donc prévu une motorisation avec des servomoteurs moins chers mais évidemment avec des performances plus modestes.

_

Les informations sur les servomoteurs sur -> Les servomoteurs

12/02/2017 L’étude se poursuit sur le réalisation du bras

L’étude se poursuit sur notre robot Maya. Après l’étude du bras et de l’avant-bras terminé, voici maintenant la rotation poignée. La rotation poignée sera motorisée avec un servomoteur de type Hitec 645 MG. Voici un bref rappel des différents servo qui composent le bras, nous avons donc un Mastodont 9944 pour le haut du bras, pour le coude nous avons un servomoteur Hitec HS805BB.

Il sera prévu des motorisations différentes et surtout moins onéreuses, mais je pense avec des performances plus modestes.

Robot Maya état au 12/02/2017 – RedOhm

–

18/02/2017 L’étude de la partie mécanique du coude

Voici des vues plus détaillées sur la partie mécanique qui compose le coude. Nous pouvons observer sur la figure 1, une pièce pour Le maintien axial de la rotation de l’avant-bras, cette pièce devra être réalisée avec un tour .Les contraintes mécaniques sont trop importantes pour réaliser cette pièce en impression 3D. Vous trouverez sur notre site les plans mécaniques pour pouvoir les réaliser. Ou vous avez la possibilité de commander cette pièce auprès d’un artisan, nous allons vous communiquer le lien. Nous avons déjà fait chiffrer cette pièce qui est de l’ordre de 8 euros. Vous remarquerez que la rotation du coude est supportée par un roulement de type SMF126 ZZ ( prix moyen 8.83€ ) , et enfin l’ensemble est bloqué par une flasque.

Vue du maintien axial de rotation de l’avant bras – RedOhm

Robot Maya vue en coupe du bras , coude et de l’avant bras RedOhm

–

20/02/2017 Etat de l’avancement de la rotation du poignet
en photo

–

24/02/2017 Rotation du thorax et motorisation de celui-ci

Nous voici maintenant arrivé à la rotation du buste, nous pouvons remarquer sur les photos que nous avons repris le système de buté à bille déjà utilisée pour la rotation du cou. Le servomoteur 99 44 qui effectue cette rotation a été choisi pour ses qualités mécaniques. Nous pouvons remarquer au-dessus du système de rotation que l’on peut apercevoir une sorte de petit œil, nous avons à faire là ,à un Pico projecteur qui occupe une partie de la cage thoracique, évidemment cet accessoire est purement optionnel (c’est certainement un petit coup de nostalgie de R2-D2) .

thorax de rotation Maya RedOhm – 001

thorax de rotation Maya RedOhm – 002

Maya rotation thorax visu sur le pico projecteur RedOhm – 003

Maya rotation thorax visu sur le pico projecteur RedOhm – 004

Information sur le fonctionnement des servomoteurs : Servomoteur

–

25/02/2017 Schéma de principe du circuit de contrôle

Maya schéma de principe du circuit de contrôle RedOhm

Voici d’une façon schématique comment va s’articuler le système de communication entre les diverses cartes utilisées. Un grand nombre de protocoles de communication sera utilisés dans ce système.

Exemple :

I2C : Communication entre les 3 cartes Arduino des yeux et de la bouche

SPI : Communication des afficheurs avec les carte Arduino 2560

WIFI ; Entre le mini pc et les cartes EZ-Robot

Filaire binaire : Entre les cartes EZ-Robot les cartes Arduino 2560

Rc : La radiocommande pour reprendre la main en cas anomalie

Vous remarquerez que sur ce dessin nous ne voyons pas apparaître tous les capteurs, vous aurez d’autres schémas correspondants à différents systèmes de détection que Maya utilisera. Nous développons actuellement un autre système pour remplacer le mini PC ceci afin de baisser le coût de construction , pour le moment nous avons jeté notre dévolu sur la carte LattePanda.

La carte de développement LattePanda est un ordinateur monocarte compatible Arduino. Elle fonctionne sous Windows 10 Home Edition 32 bits (avec la licence incluse) installé sur une mémoire flash de 32 GB intégrée. Le LattePanda fonctionne sur une base d’Intel ATOM X5-Z8300 comportant 2 GB de mémoire RAM.

Le LattePanda peut se connecter à un moniteur (via port HDMI ou MIPI-DSI) et propose une connectivité complète: WiFi, Bluetooth 4.0, 2 ports USB 2.0, port USB 3.0, port microSD (carte microSD non livrée), port audio Jack 3.5, connecteur RJ45 et 6 connecteurs pour capteurs compatibles Gravity. Le LattePanda peut effectuer les tâches simples d’un PC de bureau (feuilles de calcul, traitement de texte, décodage flux vidéos 1080p, internet, jeux peu gourmands en ressources…).

Nous avons déjà installé le logiciel EZ-Robot , et tester cette application sur la carte LattePanda pour le moment les résultats sont plutôt encourageants.

Notre fournisseur : Gotronic
Prix moyen de la carte : 155 €

–

18/03/2017 Impression du haut du bras

Voici quelques photos du haut du bras de Maya. L’impression a duré 66 heures, pour 731 g de produit de chez ArianePlas . On peut déjà apercevoir un des deux servomoteurs montés dans la partie haute du bras.

Maya le 18-03-2017 par RedOhm

–

19/03/2017 Modification de la rotation du buste

Voici quelques photos qui vous donnent l’état des modifications pour la rotation du buste. Lors de la première étude, nous avions travaillé sur la rotation du buste par l’intermédiaire d’une buté à billes. Après présentation de l’étude à nos lecteurs, nous avons eu une remarque judicieuse (merci à notre lecteur) sur les efforts radial et axial de la rotation du buste (surtout avec le balancement des bras). Après quelques vérifications, nous avons donc inséré dans le buste un roulement à rouleaux coniques, ceci afin d’avoir une meilleure stabilité de l’ensemble et d’absorber les différents efforts.

–

08/04/2017 Essai du bras de Maya.

–

Nous allons déjà faire le point sur les actionneurs nécessaires à la construction du bras.

Nous avons pour la rotation et l’élévation du haut du bras .2 servomoteurs Mastodon 9944 de chez Topmodel (Couple: 99 kg.cm).

Pour la partie du coude, nous utilisons un servomoteur Hitec HS805BB. Ce servomoteur à roulement à billes se caractérise par un couple très élevé (Couple: 24 kg.cm).

Pour la partie rotation du poignet, nous avons un servomoteur Hitec HS645MG .Ce servomoteur à double roulements à billes se caractérise par un excellent centrage et un couple très élevé pour sa taille (Couple: 9,6 kg.cm).

Nous avons choisi pour piloter cet ensemble un module Ez robot. Le module EZ-Robot contient les composants nécessaires pour réaliser rapidement cette manipulation pilotée par PC via une liaison sans fil Wifi .L’utilisation du logiciel EZ-Builder sur votre ordinateur vous permet de contrôler les sorties de la carte de commande EZ-B V4.

Passons à la tension d’alimentation, pour faire ces essais , nous aurons besoin de 7.4V pour la partie puissance des servomoteurs Mastodon 9944. Une tension de 6 V pour le servomoteur du coude et de la rotation du poignet. Pour l’alimentation du module de contrôle , nous aurons besoin d’une tension de 12 V.

Vous remarquerez que nous avons choisi d’utiliser les tensions maximales sur les servomoteurs pourquoi ? Simplement pour avoir le couple maximum donné par le constructeur.

Informations utiles sur les servomoteurs sur -> Les servomoteurs

–

22/04/2017
Fonctionnement manuel des différents mouvements de la tête

–

Voici une présentation du fonctionnement manuel des différents mouvements de la tête. Nous avons déjà la rotation des yeux comme un être humain, nous bougeons d’abord nos yeux avant de bouger la tête, et enfin seulement quand nos yeux sont en buté ou je dirais plutôt au maximum de leurs déplacements, la tête tourne pour continuer à observer. Il en sera de même pour notre robot. De même, vous pourrez voir dans cette vidéo le système d’élévation de la tête. L’ensemble du déplacement des yeux, de la rotation de la tête et de l’élévation de la tête et piloté par la caméra qui se trouve au centre de la boîte crânienne de Maya. Évidemment, cette caméra passe par un ordinateur qui après traitement, renvoie ces informations de déplacement sur les servomoteurs qui pilotent ses ensembles. Vous pourrez remarquer aussi que les yeux de Maya sont opérationnels, ils sont surtout là pour vous donner l’état d’esprit de notre robot (et voilà, je considère qu’il est vivant cela ne vous rappelle rien) sur la vidéo, le robot possède des yeux qui reflètent qu’il est attentif, vous pourrez observer plus tard qu’il possède une multitude de formes d’œil, qui démarre de la colère, attentif, penaud, choqué etc.

29/04/2017
Maya un robot avec de la voix

Nous avons intégré dans la boîte crânienne de Maya une enceinte Bluetooth qui permettra de restituer la parole de notre robot, mais bien évidemment, vous aurez aussi la possibilité de mettre des haut-parleurs filaires. Comme nous l’avions annoncé dès le départ, notre robot est sous le signe de la culture Maya , donc nous avons réalisé la grille du haut-parleur avec une reproduction stylisée du calendrier maya. Vous remarquerez aussi que nous avons dû percer avec un trépan la boîte crânienne de notre robot là encore, de nouveaux fichiers seront disponibles, pour éviter cette manipulation. En revanche, ceux qui ont déjà sorti la boîte crânienne, la grille du haut-parleur s’adapte parfaitement. Le trépan utilisé pour percer la boîte crânienne de Maya est de diamètre 54. C’est un trépan que l’on trouve facilement dans n’importe quel magasin de bricolage.

Calendrier Maya

Nous avons réalisé la grille du haut-parleur avec une reproduction stylisée du calendrier maya – RedOhm

Le trépan utilisé pour percer la boîte crânienne de Maya est de diamètre 54. – RedOhm

L’ensemble sur Maya -RedOhm

06/05/2017
Maya groupe de propulsion châssis M001

Pour le déplacement de Maya nous avons réfléchi sur trois types de châssis différents, nous allons commencer par le châssis qui est prévu plutôt pour rouler en plein air. L’ensemble est relativement facile à construire « Eh oui il va falloir faire un peu de mécanique », le montage est composé d’un moto réducteurs compact Doga 319 *12V/95rpm (mais rien ne vous empêche de récupérer 2 moteurs d’essuie-glace de même type), de 2 paliers à semelle avec graisseur UCP 202, une tôle en aluminium de 6 mm d’épaisseur, et enfin de construire l’axe principal est l’élargissement de roue qui sera adaptée au type de roue que vous pourrez récupérer. Vous aurez toutes les informations techniques, les dessins, les branchements électriques avec le variateur sur notre site.

Maya groupe moto-propulseur vue sur le moto-réducteur RedOhm

Maya groupe moto-propulseur vue sur le moto-réducteur RedOhm – 001

Maya groupe moto-propulseur vue sur le moto-réducteur RedOhm – 002

Maya groupe moto-propulseur vue sur le moto-réducteur RedOhm – 003

Information technique :

Groupe moto-réducteur : Doga 319 la page ou le site Mdp
Palier à semelle avec graisseur UCP 202 : 1001roulements la page ou 1001roulements le site

11/06/2017
Coffret tuning pour variateur de propulsion

Le châssis du robot Maya fonctionne avec un variateur de type SaberTooth 2x60A. Ce variateur mérite un coffret de protection digne de Maya .Voici donc la version définitive du coffret.

Coffret tuning pour variateur de propulsion – RedOhm

Description :
Protection du variateur de propulsion SaberTooth 2x60A
Ouverture du coffret par vérin électrique avec détecteur de gestes de chez Grove ,
Du tuning avec éclairage des gaines moteurs en fibre optique dépolie, et signalisation de l’état variateur sur LED RGB en face avant et enfin refroidissement avec ventilateur diamètre 80 bleu

–

Diaporama ci-dessous du coffret variateur

Type de matériel utilisé :

Actionneur linéaire L12-100-6R: L’actionneur maintient sa position en cas de coupure d’alimentation, à moins que la force appliquée n’excède la force de maintien.

Caractéristiques de l’actionneur linéaire :
Alimentation: 6 Vcc	Précision: 0,3 mm	Courant de blocage: 450 mA
Contrôle: signal RC servo	Réduction: 100:1	Niveau sonore: 55 dB à 45 cm
Course maxi: 100 mm	Force: 23 N à 6 mm/s	Indice de protection: IP54
Vitesse à vide: 12 mm/s	Force de maintien: 80 N	T° de travail: -10°C à +50°C
Précision: 0,3 mm	Cycle de charge: 20%	Section: 15 x 18 mm
Longueur: 160 mm au repos	Connectique: fiche JR	Poids: 56 g

–

Led 8 mm RGB Grove 104030006 :Ce module led RGB 8 mm est compatible Grove et permet d’obtenir une couleur au choix à partir d’une sortie d’une microcontrôleur

Led 8 mm RGB Grove 104030006 – RedOhm

Caractéristiques de la Led 8 mm RGB Grove
Interface: compatible Grove	Alimentation: 5 Vcc	Couleur: RGB
Dimensions: 20 x 20 x 25 mm

06/08/2017
Présentation du châssis extérieur pour Maya

La structure du châssis de Maya est enfin terminée. Nous avons donc passé aux essais de roulage qui sont avérés plus que satisfaisant. Puisque le cahier des charges nous imposait une charge utile de 50kg, une vitesse de 5 à 6 km/h, un freinage très rapide avec récupération d’énergie. Sur cette vidéo, vous verrez donc le déplacement du châssis mais aussi les conseils techniques pour la création des pièces en aluminium.

La deuxième phase vient d’être lancée. C’est la partie câblage de l’ensemble du châssis. Voici le cahier des charges.

Le groupe moto propulseur doit être refroidi aussitôt que la vitesse des groupes excède 50°.
Le châssis possède 1 coupe batterie à l’arrière.
De chaque côté du châssis, il y a un arrêt d’urgence qui coupe l’ensemble du robot sur la partie puissance. L’intégrité de son système de contrôle reste toujours alimentée malgré un arrêt d’urgence.
Le coffret qui détient le variateur possède son propre système de refroidissement. Il est contrôlé par la carte Arduino qui se trouve à l’intérieur de celui-ci.
Un interrupteur de by passe vous permettra de passer en radio commande pour pouvoir déplacer le robot à des fins de maintenance ou de positionnement.

Les plans mécaniques seront bientôt disponibles, de même que l’ensemble des schémas électriques qui régissent le châssis.

Vue du fonctionnement de la main de Maya

–

Pour le fonctionnement des doigts, nous allons utiliser le servomoteur Batan S1123 . Pourquoi ce servomoteur ? Est bien simplement car il n’est pas comme les autres. Il dispose d’un fil de retour d’information (feed-back), cette information nous permet de connaître la position du servomoteur précisément. La valeur lue est une valeur analogique, qui peut être lu facilement soit sur une carte Arduino soit sur la carte Ez-Robot. Cette information nous sera utile pour le cas suivant, sommes-nous bien arrivés à la valeur fixée, si l’information de retour ne correspond pas à la valeur fixée on n’en déduira que le moteur est bloqué et dans ce là, le servomoteur chauffe, et au pire des cas, il peut se détruire.

–

Fiche technique du servomoteur Batan S1123
Poids	13.82g
Dimensions	11.57,32.71,31.76mm
Couple	13.kg.cm
Type de pignon	Plastique
Roulement à billes	2BB
Nombre de dents	22

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 →

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 .

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

_

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

29/01/2017 Etude du bras Phase n-1

Voici une première étude de la partie du bras de Maya. Comme vous avez pu l’observer sur le dessin les servomoteurs sont en entraînement direct. Le bras est rattaché à l’épaule par un servomoteur en entraînement direct (les seules démultiplications sont à l’intérieur du servomoteur).Celui-ci assurera la rotation de l’épaule, un second servomoteur monté dans la cage de l’épaule assurera l’élévation du bras. Le type de servomoteur choisi nous permettra de porter des charges relativement conséquentes (les tests nous confirmeront le poids des charges déplacées)

Etude des bras de Maya – RedOhm -001

Etude des bras de Maya – RedOhm -002

Etude des bras de Maya – RedOhm -003

Etude des bras de Maya – RedOhm -004

Etude des bras de Maya – RedOhm -005

Etude des bras de Maya – RedOhm -006

–

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 →

ROBOT MAYA – La création de l’œil

***

Mise à jour le 20/11/2016

Sommaire :

Le matériel utile pour cette réalisation
- L’écran LCD 1,77 »
  - Présentation de l’écran LCD 1,77 » Arduino
  - La fiche technique de l’écran LCD 1,77 » Arduino
  - Utilisation de la bibliothèque
    - Begin : Initialisation de l’écran
    - background : Efface l’écran
    - stroke : Défini la couleur des formes
    - noStroke : Arrêt de la définition de la couleur des formes
    - fill : Remplissage de l’objet
    - noFill : Arrêt Remplissage de l’objet
    - text() : Positionne un texte
    - setTextSize : Définit la taille du texte
    - point : Dessine un point .
    - line : Dessine une ligne .
La création de l’œil de Maya
Création de la fonction pour dessiner l’œil

***

Le matériel utile pour cette réalisation

Présentation de l’écran LCD 1,77 » Arduino

Pour la création de l’œil , on va utiliser un écran couleur LCD TFT 1,77″ Arduino .Le module est équipé d’un port micro-SD, ce qui permet notamment de stocker et afficher des images bitmap et de communiquer 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.

Fiche technique :

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 de la bibliothèque :

Si vous utilisez l’interface SPI matériel avec la carte Arduino Uno ou Mega Arduino, il vous suffit de déclarer le CS, DC, RESET et MOSI (broche 11) et SCLK (broche 13) qui sont déjà définies.Voir l’exemple ci-dessous .

//
//
#define CS   10
#define DC   9
#define RESET  8 

TFT myScreen = TFT(CS, DC, RESET);

#define CS 10

#define DC 9

#define RESET 8

TFT myScreen = TFT(CS, DC, RESET);

***

Mot clef : begin

Cette instruction doit être appelée pour initialiser l’écran lcd TFT 1,77″ Arduino . Exemple ci-dessous

//
//
#include <SPI.h>
#include <TFT.h>            

#define cs   10
#define dc   9
#define rst  8

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

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

  // Efface l'écran LCD avec la couleur indiquée. 
  screen.background(255,255,255);
}

void loop() {

}

#include <SPI.h>

#include <TFT.h>

#define cs 10

#define dc 9

#define rst 8

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

void setup() {

// initialisation de l'écran

screen.begin();

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

screen.background(255,255,255);

}

void loop() {

}

***

Mot clef : background

Permet d’effacer à tout moment l’écran LCD avec la couleur indiquer .Peut être utilisée dans loop () pour effacer l’écran.Voir exemple ci-dessous .

//
//
#include <SPI.h>
#include <TFT.h>           

#define cs   10
#define dc   9
#define rst  8

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

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 blanc
  screen.background(255,255,255);
}

void loop() {

}

#include <SPI.h>

#include <TFT.h>

#define cs 10

#define dc 9

#define rst 8

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

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 blanc

screen.background(255,255,255);

}

void loop() {

}

***

Mot clef : stroke

Cette instruction est appelée avant de dessiner un objet sur l’écran, il définit la couleur des lignes et des bordures autour des formes.

L’instruction stroke () attend des valeurs de 8 bits pour chacun des canaux rouge, vert et bleu, mais l’écran n’affiche pas l’ensemble de ces couleurs . Les valeurs rouges sont réduites aux couleurs de 5 bits (32 étapes distinctes) et les couleurs bleues sont réduites à 6 bits (64 étapes distinctes) .

//
// 
// défini la couleur du dessin en blanc
  screen.stroke(255,255,255);

// défini la couleur du dessin en blanc

screen.stroke(255,255,255);

***

Mot clef : noStroke

Après avoir appelé la fonction noStroke, arrêt de la définition de la couleur des lignes et des bordures autour des formes.

***

Mot clef : fill

Cette instruction est appelée avant de dessiner un objet sur l’écran, il définit la couleur du remplissage des formes et des textes.

L’instruction fill () attend des valeurs de 8 bits pour chacun des canaux rouge, vert et bleu, mais l’écran n’affiche pas l’ensemble de ces couleurs . Les valeurs rouges sont réduites aux couleurs de 5 bits (32 étapes distinctes) et les couleurs bleues sont réduites à 6 bits (64 étapes distinctes).

//
//  
// Définition de la couleur du remplissage la en blanc
  screen.fill(255,255,255);

// dessine un rectangle blanc dans le centre de l'écran
screen.rect(screen.width()/2+10,screen.height()/2+10,screen.width()/2-10,screen.height()/2-10);

}

// Définition de la couleur du remplissage la en blanc

screen.fill(255,255,255);

// dessine un rectangle blanc dans le centre de l'écran

screen.rect(screen.width()/2+10,screen.height()/2+10,screen.width()/2-10,screen.height()/2-10);

}

***

Mot clef : noFill

Après avoir appelé la fonction noFill, toutes les formes dessinées sur l’écran ne seront pas remplies.

***

Mot clef : text()

L’instruction écrire un texte à l’écran aux coordonnées données.Exemple ci-dessous.

La syntaxe est la suivante : screen.text(text, xPos, yPos);

text: le texte que vous voulez écrire sur l’écran
xPos: int, l’emplacement sur l’axe-x que vous voulez commencer à dessiner le texte à l’écran
yPos: int, l’emplacement sur l’axe-y que vous voulez commencer à dessiner le texte à l’écran.

//
//
// définir la couleur du texte en blanc
  screen.stroke(255,255,255);

// écrire un texte à l'écran dans le coin supérieur gauche
  screen.text(" REDOHM ", 0, 0);

// définir la couleur du texte en blanc

screen.stroke(255,255,255);

// écrire un texte à l'écran dans le coin supérieur gauche

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

***

Mot clef : setTextSize

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.Exemple ci-dessous.

La syntaxe est la suivante : screen.setTextSize(size);

//
//
//

#include <SPI.h>
#include <TFT.h> 

#define cs   10
#define dc   9
#define rst  8

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

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

  // défini la couleur du dessin en blanc
  screen.stroke(255,255,255);

  // Taille du texte par défaut
  screen.setTextSize(1);
  // écrire le texte "bonjour" à l'écran dans le coin supérieur gauche
  screen.text("bonjour !", 0, 0);
  // augmenter la taille du texte
  screen.setTextSize(5);
  // écrire le texte "YODA" a l'écran 
  screen.text(" YODA ", 0, 10);
}

void loop() {

}

#include <SPI.h>

#include <TFT.h>

#define cs 10

#define dc 9

#define rst 8

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

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

// défini la couleur du dessin en blanc

screen.stroke(255,255,255);

// Taille du texte par défaut

screen.setTextSize(1);

// écrire le texte "bonjour" à l'écran dans le coin supérieur gauche

screen.text("bonjour !", 0, 0);

// augmenter la taille du texte

screen.setTextSize(5);

// écrire le texte "YODA" a l'écran

screen.text(" YODA ", 0, 10);

}

void loop() {

}

Affichage de texte et définition de la taille des caracteres

***

Mot clef : point

Dessine un point aux coordonnées données. Le premier paramètre est la valeur horizontale pour le point, la deuxième valeur est la valeur verticale pour le point.Exemple ci-dessous.

La syntaxe est la suivante : screen.point(xPos, yPos);

// 
//
// Commande 
//    screen.point(xPos, yPos);
//
// Modifier par RedOhm

#include <SPI.h>
#include <TFT.h>

#define cs   10
#define dc   9
#define rst  8

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

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

  // défini la couleur du dessin en blanc
  screen.stroke(255,255,255);

  // dessiner un pixel dans le centre de l'écran
  screen.point(screen.width()/2, screen.height()/2);
}

void loop() {

}

// Commande

// screen.point(xPos, yPos);

// Modifier par RedOhm

#include <SPI.h>

#include <TFT.h>

#define cs 10

#define dc 9

#define rst 8

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

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

// défini la couleur du dessin en blanc

screen.stroke(255,255,255);

// dessiner un pixel dans le centre de l'écran

screen.point(screen.width()/2, screen.height()/2);

}

void loop() {

}

***

Mot clef : line

Dessine une ligne entre deux points.Exemple ci-dessous.

La syntaxe est la suivante : screen.line(xStart, yStart, xEnd, yEnd);

Paramètres

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

/*
 *   
 */


#include <SPI.h>
#include <TFT.h>

#define cs   10
#define dc   9
#define rst  8

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

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

  // défini la couleur du dessin en blanc
  screen.stroke(255,255,255);

  // dessine une diagonale ( ligne )
  screen.line(0, 0, 160, 124);
}

void loop() {

}

#include <SPI.h>

#include <TFT.h>

#define cs 10

#define dc 9

#define rst 8

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

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

// défini la couleur du dessin en blanc

screen.stroke(255,255,255);

// dessine une diagonale ( ligne )

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

}

void loop() {

}