Archives par étiquette : maya

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

Retour au sommaire

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

Vignettes

Retour au sommaire

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

Retour au sommaire

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

***

Retour au sommaire

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

Vignettes

***

Retour au sommaire

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

***

Retour au sommaire

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

Vignettes

***

Retour au sommaire

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

***

Retour au sommaire

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 .

Retour au sommaire

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 :

Retour au sommaire

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.

Pour plus d’information sur le papillon Galactique :

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

***

Retour au sommaire

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

Retour au sommaire

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

Retour au sommaire

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

Retour au sommaire

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

–

Retour au sommaire

ROBOT MAYA – Le regard penaud

Mise à jour le 26/02/2017

Sommaire :

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

Définition de penaud :

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

Maya oeil penaud droit RedOhm

Retour au sommaire

Description technique :

Alimentation: 5 Vcc
Ecran: 1,77″
Couleurs: 262000
Résolution: 160 x 128 pixels
Port: SPI
Support carte: micro-SD
Température de service: -20 à +70°C
Dimensions: 60 x 42 x 15 mm
Référence fabricant: A000096
Site officiel Arduino: www.arduino.org

Retour au sommaire

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

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

***

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

Retour au sommaire

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

/*
 * 
 * 
 * Creation de l'oeil penaud droit
 * 
 * 
 * 
 * 
 * code projet : 0000-Oeil_penaud_droit
 * 
 * Herve Mazelin - RedOhm
 * 21/01/2017
 */





// je charge la librairie SPI
// Cette librairie vous permet de communiquer avec des périphériques SPI
// La carte Arduino en tant que "maitre" par defaut 
#include <SPI.h>
// je charge la librairie TFT
// Cette bibliothèque permet à une carte Arduino de communiquer à
// l'écran LCD TFT 
#include <TFT.h> 

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


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



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


void setup() {

 
 // initialisation de l'écran 
  screen.begin(); 
  
 // Efface l'ecran et met le fond en noir 
  screen.background(0,0,0);
 
  //defini la couleur pour tracer l'objet a dessiner 
  screen.stroke(255,255,255);
 
  // 1 anneau exterieure bleu 
  // définition de la couleur de remplissage exemple bleu -> 128,255,255
  screen.fill(128,255,255);
  // je dessine un annneau exterieur dans le centre de l'écran
  // je prend la largeur de l'ecran que je divise par 2 
  // je prend la hauteur de l'ecran que je divise par 2
  screen.circle(screen.width()/2, screen.height()/2, 60);
 
 //dessine le trait horizontal et vertical
 //defini la couleur pour tracer l'objet a dessiner en noir
   screen.stroke(0,0,0);
  // Trace trois lignes horizontale qui traverse l'ecran
  for (x=0;x<3;x++)
  {
   screen.line(1,63+x,159,63+x); 
  } 
  // Trace une ligne verticale qui traverse l'ecran d'une epaisseur de 
  // 3 pixels
  for (x=0;x<3;x++)
  {
   screen.line (79+x,1,79+x,127); 
  } 
 
 
 
  
  // 2 cercle  
  // définit la couleur de remplissage exemple gris 127.127.127
  screen.fill(0,0,0);
  
  // je dessine un cercle dans le centre de l'écran
  screen.circle(screen.width()/2, screen.height()/2, 45);
  
 
   // 3 cercle  
  // définit la couleur de remplissage exemple gris 127.127.127
  screen.fill(136,136,136);
  // je dessine un cercle dans le centre de l'écran
  screen.circle(80, 64, 35);
 
  // 4 cercle  
  // définit la couleur de remplissage exemple noir 0.0.0
  screen.fill(0,0,0);
  // je dessine un cercle dans le centre de l'écran
  screen.circle(screen.width()/2, screen.height()/2, 25);
 

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

  // je dessine un triangle 

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


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

  


  




}

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

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

* Creation de l'oeil penaud droit

* code projet : 0000-Oeil_penaud_droit

* Herve Mazelin - RedOhm

* 21/01/2017

// je charge la librairie SPI

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

// La carte Arduino en tant que "maitre" par defaut

#include <SPI.h>

// je charge la librairie TFT

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

// l'écran LCD TFT

#include <TFT.h>

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

#define cs 10

#define dc 9

#define rst 8

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

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

// Declare la variable X

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

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

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

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

// variable .

int x;

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

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

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

void setup() {

// initialisation de l'écran

screen.begin();

// Efface l'ecran et met le fond en noir

screen.background(0,0,0);

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

screen.stroke(255,255,255);

// 1 anneau exterieure bleu

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

screen.fill(128,255,255);

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

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

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

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

//dessine le trait horizontal et vertical

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

screen.stroke(0,0,0);

// Trace trois lignes horizontale qui traverse l'ecran

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

{

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

}

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

// 3 pixels

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

{

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

}

// 2 cercle

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

screen.fill(0,0,0);

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

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

// 3 cercle

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

screen.fill(136,136,136);

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

screen.circle(80, 64, 35);

// 4 cercle

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

screen.fill(0,0,0);

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

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

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

// je dessine un triangle

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

// for (initialisation ; condition ; increment)

// entre crochet { instructions executees dans la boucle }

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

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

screen.fill(255,255,255);

// dessine une ligne entre deux points les parametres :

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

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

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

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

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

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

}

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

// ou la ligne commence

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

// for (initialisation ; condition ; increment)

// entre crochet { instructions executees dans la boucle }

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

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

screen.fill(255,255,255);

// dessine une ligne entre deux points les parametres :

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

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

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

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

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

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

}

void loop() {

// vide pour le besoin de la demonstration

}

Retour au sommaire

***

ROBOT MAYA – Je veux tout savoir

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

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

Retour au sommaire

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

Retour au sommaire

***

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

}

Retour au sommaire

***

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

}

Retour au sommaire

***

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

Retour au sommaire

***

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.

Retour au sommaire

***

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

}

Retour au sommaire

***

Mot clef : noFill

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

Retour au sommaire

***

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

Retour au sommaire

***

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

Retour au sommaire

***

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

}

Retour au sommaire

***

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

}

Retour au sommaire

***

La création de l’œil de Maya .

La première étape consiste à dessiner le plus grand cercle

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

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

Maya – étape 1

La deuxième étape consiste à dessiner le trait horizontal et le trait vertical

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

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

}

Maya – étape 2

La troisième étape consiste à dessiner un cercle noir qui donnera une épaisseur au cercle extérieur

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

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

Maya – étape 3

La quatrième étape consiste à dessiner un cercle gris

  //
  //
  // 3 cercle  
  // définit la couleur de remplissage exemple gris 127.127.127
  screen.fill(127,127,127);
  // je dessine un cercle dans le centre de l'écran
  screen.circle(80, 64, 35);

// 3 cercle

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

screen.fill(127,127,127);

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

screen.circle(80, 64, 35);

Maya – étape 4

La cinquième étape consiste à donner une épaisseur au cercle gris

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

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

Maya – étape 5

L’ensemble du programme de la création de l’œil se compose de la façon suivante

 //
 //
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(127,127,127);
  // 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);



}

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

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

}

***

Création de la fonction pour dessiner l’oeil

Dans cette partie, on modifie le programme principal pour le transformer en fonction indépendante , qui s’appellera -> creation_de_oeil.

la syntaxe sera la suivante : void creation_de_oeil()

//
//
//


void creation_de_oeil()

{

// dans cette partie nous retrouverons le programme pour 
// la création de l'oeil 

}

void creation_de_oeil()

{

// dans cette partie nous retrouverons le programme pour

// la création de l'oeil

}

Transfert du programme principal dans la fonction

/*
 * Programme de l'oeil droit 
 *  
 * code projet : REDOHM_MAYA_0001
 * 
 * Herve Mazelin
 */


// je charge la librairie SPI
// Cette librairie vous permet de communiquer avec des périphériques SPI
// La carte Arduino en tant que "maitre"
#include <SPI.h>
// je charge la librairie TFT
// Cette bibliothèque permet à une carte Arduino de communiquer 
// l'écran LCD TFT 
#include <TFT.h>            

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

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




// Declare la variable X 
// Rappel sur la fonction d'une variable :On peut définir une variable comme
// une boite ou l’on stock des balles .Une variable est une boite ou 
// l’on stock un nombre ,et comme il existe une multitude de nombres:
// Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette
// variable .
int x;

int controle14; 

// fils en borne 14
int fil_14=14;

// variable pour enregistrer l'etat de l'entrée 14
int entree_14 ;

// 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();
  // forcage de la variable a l'etat bas 
  controle14=LOW;

 //Initialise la broche numérique 14 comme entrée avec la résistance
 //interne pull-up activé
 pinMode (fil_14,INPUT_PULLUP); 
  
}


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

 // Lit l"état de la broche 14 en entrée numérique, et renvoie la valeur
 // dans la variable entree_14
 entree_14=digitalRead(fil_14);
   
  if ((entree_14==LOW)&&(controle14==LOW))
  
  {
     // appel de la fonction -> creation_de_oeil
     creation_de_oeil();
     controle14=HIGH;
     
  }  

   // Ecran noir : efface l'ecran 
  else if (entree_14==HIGH)
  {
    screen.background(0,0,0); 
    controle14=LOW;
    
  }  
   
   
 
}



/*
 *  la creation de la fonction -> creation_de_oeil
 *  
 *  a savoir : la creation d'un 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);


}

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

* Programme de l'oeil droit

* code projet : REDOHM_MAYA_0001

* Herve Mazelin

// je charge la librairie SPI

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

// La carte Arduino en tant que "maitre"

#include <SPI.h>

// je charge la librairie TFT

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

// l'écran LCD TFT

#include <TFT.h>

#define cs 10

#define dc 9

#define rst 8

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

// Declare la variable X

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

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

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

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

// variable .

int x;

int controle14;

// fils en borne 14

int fil_14=14;

// variable pour enregistrer l'etat de l'entrée 14

int entree_14 ;

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

// forcage de la variable a l'etat bas

controle14=LOW;

//Initialise la broche numérique 14 comme entrée avec la résistance

//interne pull-up activé

pinMode (fil_14,INPUT_PULLUP);

}

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

void loop() {

// Lit l"état de la broche 14 en entrée numérique, et renvoie la valeur

// dans la variable entree_14

entree_14=digitalRead(fil_14);

if ((entree_14==LOW)&&(controle14==LOW))

{

// appel de la fonction -> creation_de_oeil

creation_de_oeil();

controle14=HIGH;

}

// Ecran noir : efface l'ecran

else if (entree_14==HIGH)

{

screen.background(0,0,0);

controle14=LOW;

}

* la creation de la fonction -> creation_de_oeil

* a savoir : la creation d'un 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);

}

Vue d’ensemble