Nestor : Programmation des yeux

Mise à jour le 26/01/2019 :

Sommaire :

Programmation de l’œil droit ( étape 1 )
Dilatation de la pupilles ( étape 2 )

Programmation de l’œil droit ( étape 1 )

Œil droit

//
//
//========================================================
//*       Programmation de l'oeil droit de Nestor        *
//*                                                      *
//*Etape 1                                               *
//*                                                      *
//*Le 26/01/2019                                         *
//*Par Hervé Mazelin                                     *
//*                                                      *
//========================================================  



// je charge la librairie SPI
// Cette librairie vous permet de communiquer avec des périphériques SPI
// La carte Arduino en tant que "maitre" par defaut 
#include <SPI.h>
// je charge la librairie TFT
// Cette bibliothèque permet à une carte Arduino de communiquer à
// l'écran LCD TFT 
#include <TFT.h> 
 
// Affectation des pins pour la communication Arduino-> afficheur  
#define cs   10
#define dc   9
#define rst  8
 
TFT screen = TFT(cs, dc, rst);

/* 
 * Un programme Arduino doit impérativement contenir cette fonction .
 * Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur
 * Elle sert à configurer globalement les entrées sorties  
 *  
 */
 
void setup()

{

 // initialisation de l'écran 
  screen.begin(); 
  
 // Efface l'ecran et met le fond en noir 
  screen.background(0,0,0);

 //defini la couleur pour tracer l'objet a dessiner 
 screen.stroke(255,255,255);
 
 // ******************** 1 anneau ****************************
 //
 // Anneau 1 exterieure bleu 
 // définition de la couleur de remplissage exemple bleu -> 128,255,255
 screen.fill(128,255,255);
 // Dessine un cercle sur l'écran.
 // Le cercle est tracé par rapport à son centre, 
 // ce qui signifie que le diamètre total sera toujours un nombre impair.
 screen.circle(88,64, 58);

 
 //****************** Dessin le rectangle *******************
 //
 //stroke = il définit la couleur des lignes et des bordures 
 //autour des formes.
 screen.stroke(0,0,0);
 //définition de la couleur de remplissage exemple noir -> 0,0,0
 screen.fill(0,0,0);
 screen.rect(73,109,30,20);

 // ******************** 2 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 46);

 // ******************** 3 anneau ****************************
 //dessine le cercle bleu foncé  
 screen.fill(19,56,236);
 screen.circle(88,64, 43);

 // ******************** 4 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 28);

 // ******************** 5 anneau ****************************
 //dessine le cercle bleu foncé  
 screen.fill(19,56,236);
 screen.circle(88,64, 25 );

 // ******************** 6 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 18);


}

/*
 *Le programme principal s’exécute par une boucle infinie appelée Loop () 
 * 
 */
 
void loop() {
  // vide pour le besoin de la demonstration
 
}

100

101

102

103

104

105

106

107

//========================================================

//* Programmation de l'oeil droit de Nestor *

//* *

//*Etape 1 *

//* *

//*Le 26/01/2019 *

//*Par Hervé Mazelin *

//* *

//========================================================

// je charge la librairie SPI

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

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

#include <SPI.h>

// je charge la librairie TFT

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

// l'écran LCD TFT

#include <TFT.h>

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

#define cs 10

#define dc 9

#define rst 8

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

* Un programme Arduino doit impérativement contenir cette fonction .

* Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur

* Elle sert à configurer globalement les entrées sorties

void setup()

{

// initialisation de l'écran

screen.begin();

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

screen.background(0,0,0);

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

screen.stroke(255,255,255);

// ******************** 1 anneau ****************************

// Anneau 1 exterieure bleu

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

screen.fill(128,255,255);

// Dessine un cercle sur l'écran.

// Le cercle est tracé par rapport à son centre,

// ce qui signifie que le diamètre total sera toujours un nombre impair.

screen.circle(88,64, 58);

//****************** Dessin le rectangle *******************

//stroke = il définit la couleur des lignes et des bordures

//autour des formes.

screen.stroke(0,0,0);

//définition de la couleur de remplissage exemple noir -> 0,0,0

screen.fill(0,0,0);

screen.rect(73,109,30,20);

// ******************** 2 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 46);

// ******************** 3 anneau ****************************

//dessine le cercle bleu foncé

screen.fill(19,56,236);

screen.circle(88,64, 43);

// ******************** 4 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 28);

// ******************** 5 anneau ****************************

//dessine le cercle bleu foncé

screen.fill(19,56,236);

screen.circle(88,64, 25 );

// ******************** 6 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 18);

}

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

void loop() {

// vide pour le besoin de la demonstration

}

Retour au sommaire

Programmation de l’œil droit ( étape 2 )

Dilatation de la pupille

//
//
//========================================================
//*       Programmation de l'oeil droit de Nestor        *
//*                                                      *
//*             dilatation des pupilles                  *
//*Etape 2                                               *
//*                                                      *
//*Le 26/01/2019                                         *
//*Par Hervé Mazelin                                     *
//*                                                      *
//========================================================  



// je charge la librairie SPI
// Cette librairie vous permet de communiquer avec des périphériques SPI
// La carte Arduino en tant que "maitre" par defaut 
#include &lt;SPI.h>
// je charge la librairie TFT
// Cette bibliothèque permet à une carte Arduino de communiquer à
// l'écran LCD TFT 
#include &lt;TFT.h> 
 
// Affectation des pins pour la communication Arduino-> afficheur  
#define cs   10
#define dc   9
#define rst  8
 
TFT screen = TFT(cs, dc, rst);

// déclaration de l'entrée analogique 
// ou se trouve le module potentiometre Grove 
int potar_pin2 = 2; 
 int potar_pin3= 3;

// variable du type int pour stocker la valeur du cercle 
int cercle1 ;
int passage ;
int new1;

/* 
 * Un programme Arduino doit impérativement contenir cette fonction .
 * Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur
 * Elle sert à configurer globalement les entrées sorties  
 *  
 */
 
void setup()

{

 //ouvre le port série et fixe le debit de communication à 9600 bauds
   Serial.begin(9600);

 // initialisation de l'écran 
  screen.begin(); 
  
 // Efface l'ecran et met le fond en noir 
  screen.background(0,0,0);

 //defini la couleur pour tracer l'objet a dessiner 
 screen.stroke(255,255,255);
 
 // ******************** 1 anneau ****************************
 //
 // Anneau 1 exterieure bleu 
 // définition de la couleur de remplissage exemple bleu -> 128,255,255
 screen.fill(128,255,255);
 // Dessine un cercle sur l'écran.
 // Le cercle est tracé par rapport à son centre, 
 // ce qui signifie que le diamètre total sera toujours un nombre impair.
 screen.circle(88,64, 58);

 
 //****************** Dessin le rectangle *******************
 //
 //stroke = il définit la couleur des lignes et des bordures 
 //autour des formes.
 screen.stroke(0,0,0);
 //définition de la couleur de remplissage exemple noir -> 0,0,0
 screen.fill(0,0,0);
 screen.rect(73,109,30,20);

 // ******************** 2 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 46);

 // ******************** 3 anneau ****************************
 //dessine le cercle bleu foncé  
 screen.fill(19,56,236);
 screen.circle(88,64, 43);

 // ******************** 4 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 28);

 // ******************** 5 anneau ****************************
 //dessine le cercle bleu foncé  
 screen.fill(19,56,236);
 screen.circle(88,64, 25 );

 // ******************** 6 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 18);


}

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


 
// lis la valeur de la tension analogique présente sur la broche 2
// et introduit le resultat dans la variable "variable"
cercle1 = analogRead(potar_pin2);
// la valeur du potentiometre est comprise entre 0 et 1023
// Etalonnage de la valeur du potentiometre en valeur de temps 
// valeur de temps comprise de 100 a 1200 milliseconde
// pour cela on utilise la fonction Map
// map (variable ,valeur basse de depart,valeur haute de depart ,new valeur basse, new valeur haute )
// valeur basse de depart = 1
// valeur haute de depart = 1023
// new valeur basse = 100
// new valeur haute = 1200
cercle1 =map( cercle1 ,0,800,10,0);



delay (10);

// Verification si on recoit l'ordre d'agrandir la pupille
if ( passage &lt; cercle1)
{
  Serial.println("Verification si on recoit l'ordre d'agrandir la pupille");
  Serial.print(passage);
  Serial.print(" &lt; ");
   Serial.println(cercle1); 
   
 // ******************** 6 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 18+cercle1);
 
 Serial.print("Nouvelle valeur de la pupille => ");
   new1=18+cercle1;
   Serial.println(new1);
}
 


// Verification de reduction de la pupille 
else if (passage > cercle1)
{
 Serial.println("Verification de reduction de la pupille");
 Serial.print(passage);
  Serial.print(" > ");
   Serial.println(cercle1);
    
 
 // ******************** 4 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 28);
 
 // ******************** 5 anneau ****************************
 //dessine le cercle bleu foncé  
 screen.fill(19,56,236);
 screen.circle(88,64, 25 );
 
 // ******************** 6 anneau ****************************
 //dessine le cercle noir  
 screen.fill(0,0,0);
 screen.circle(88,64, 18+cercle1);
  Serial.print("Nouvelle valeur de la pupille => ");
   new1=18+cercle1;
   Serial.println(new1);
}

else if (passage == cercle1 )
{

   
}

passage = cercle1;
 
}




// --------------- Ensemble de sous programme ------------------
// 







void clignote_les_yeux ()
  
{

  delay (1000);
 //dessine le cercle noir  
 screen.fill(255,0,0);
 screen.circle(88,64, 18);

 delay(1000);                
 //dessine le cercle noir  
 screen.fill(233,209,223);
 screen.circle(88,64, 18);

  
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

//========================================================

//* Programmation de l'oeil droit de Nestor *

//* *

//* dilatation des pupilles *

//*Etape 2 *

//* *

//*Le 26/01/2019 *

//*Par Hervé Mazelin *

//* *

//========================================================

// je charge la librairie SPI

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

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

#include <SPI.h>

// je charge la librairie TFT

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

// l'écran LCD TFT

#include <TFT.h>

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

#define cs 10

#define dc 9

#define rst 8

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

// déclaration de l'entrée analogique

// ou se trouve le module potentiometre Grove

int potar_pin2 = 2;

int potar_pin3= 3;

// variable du type int pour stocker la valeur du cercle

int cercle1 ;

int passage ;

int new1;

* Un programme Arduino doit impérativement contenir cette fonction .

* Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur

* Elle sert à configurer globalement les entrées sorties

void setup()

{

//ouvre le port série et fixe le debit de communication à 9600 bauds

Serial.begin(9600);

// initialisation de l'écran

screen.begin();

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

screen.background(0,0,0);

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

screen.stroke(255,255,255);

// ******************** 1 anneau ****************************

// Anneau 1 exterieure bleu

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

screen.fill(128,255,255);

// Dessine un cercle sur l'écran.

// Le cercle est tracé par rapport à son centre,

// ce qui signifie que le diamètre total sera toujours un nombre impair.

screen.circle(88,64, 58);

//****************** Dessin le rectangle *******************

//stroke = il définit la couleur des lignes et des bordures

//autour des formes.

screen.stroke(0,0,0);

//définition de la couleur de remplissage exemple noir -> 0,0,0

screen.fill(0,0,0);

screen.rect(73,109,30,20);

// ******************** 2 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 46);

// ******************** 3 anneau ****************************

//dessine le cercle bleu foncé

screen.fill(19,56,236);

screen.circle(88,64, 43);

// ******************** 4 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 28);

// ******************** 5 anneau ****************************

//dessine le cercle bleu foncé

screen.fill(19,56,236);

screen.circle(88,64, 25 );

// ******************** 6 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 18);

}

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

void loop() {

// lis la valeur de la tension analogique présente sur la broche 2

// et introduit le resultat dans la variable "variable"

cercle1 = analogRead(potar_pin2);

// la valeur du potentiometre est comprise entre 0 et 1023

// Etalonnage de la valeur du potentiometre en valeur de temps

// valeur de temps comprise de 100 a 1200 milliseconde

// pour cela on utilise la fonction Map

// map (variable ,valeur basse de depart,valeur haute de depart ,new valeur basse, new valeur haute )

// valeur basse de depart = 1

// valeur haute de depart = 1023

// new valeur basse = 100

// new valeur haute = 1200

cercle1 =map( cercle1 ,0,800,10,0);

delay (10);

// Verification si on recoit l'ordre d'agrandir la pupille

if ( passage < cercle1)

{

Serial.println("Verification si on recoit l'ordre d'agrandir la pupille");

Serial.print(passage);

Serial.print(" < ");

Serial.println(cercle1);

// ******************** 6 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 18+cercle1);

Serial.print("Nouvelle valeur de la pupille => ");

new1=18+cercle1;

Serial.println(new1);

}

// Verification de reduction de la pupille

else if (passage > cercle1)

{

Serial.println("Verification de reduction de la pupille");

Serial.print(passage);

Serial.print(" > ");

Serial.println(cercle1);

// ******************** 4 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 28);

// ******************** 5 anneau ****************************

//dessine le cercle bleu foncé

screen.fill(19,56,236);

screen.circle(88,64, 25 );

// ******************** 6 anneau ****************************

//dessine le cercle noir

screen.fill(0,0,0);

screen.circle(88,64, 18+cercle1);

Serial.print("Nouvelle valeur de la pupille => ");

new1=18+cercle1;

Serial.println(new1);

}

else if (passage == cercle1 )

{

}

passage = cercle1;

}

// --------------- Ensemble de sous programme ------------------

void clignote_les_yeux ()

{

delay (1000);

//dessine le cercle noir

screen.fill(255,0,0);

screen.circle(88,64, 18);

delay(1000);

//dessine le cercle noir

screen.fill(233,209,223);

screen.circle(88,64, 18);

}

Retour au sommaire