Archives par étiquette : arduino

***

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

Programme pour piloter séparement chaque moteur du support trois axes

Version 1.00
Mise à jour le 27/08/2016

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




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

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

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

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

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

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



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



void loop() {

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


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


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


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


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


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

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

*RedOhm

*Programme pour piloter separement chaque moteur du support

*trois axes

*le 27/08/2016

* H-Mazelin

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

#include <Servo.h>

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

Servo servobase;

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

Servo servobras;

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

Servo servotete;

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

int brochepotar_de_position_servobase=0;

// variable contenant la valeur du potentiometre pour le servobase

int valeur_potar_position_du_servobase;

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

int brochepotar_de_position_servobras=2;

// variable contenant la valeur du potentiometre pour le servobras

int valeur_potar_position_du_servobras;

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

int brochepotar_de_position_servotete=4;

// variable contenant la valeur du potentiometre pour le servotete

int valeur_potar_position_du_servotete;

* Un programme Arduino doit impérativement contenir cette fonction

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

* Elle sert à configurer globalement les entrées sorties

void setup() {

// initialisation de la connexion série

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

Serial.begin(9600);

// associe le servomoteur servobase a la broche 3

servobase.attach(3);

// associe le servomoteur servobras a la broche 4

servobras.attach(4);

// associe le servomoteur servotete a la broche 5

servotete.attach(5);

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

Serial.println("* *");

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

Serial.println("* operationnel *");

Serial.println("* *");

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

Serial.println(" ");

//pause presentation

delay (5000);

}

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

void loop() {

* traitement pour la position de la base

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

valeur_potar_position_du_servobase=analogRead( brochepotar_de_position_servobase);

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

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

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

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

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

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

servobase.write(valeur_potar_position_du_servobase);

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

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

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

Serial.println(valeur_potar_position_du_servobase);

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

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

* traitement pour la position du bras

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

valeur_potar_position_du_servobras=analogRead(brochepotar_de_position_servobras);

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

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

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

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

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

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

servobras.write(valeur_potar_position_du_servobras);

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

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

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

Serial.println(valeur_potar_position_du_servobras);

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

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

* traitement pour la position de la tete

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

valeur_potar_position_du_servotete=analogRead(brochepotar_de_position_servotete);

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

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

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

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

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

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

servotete.write( valeur_potar_position_du_servotete);

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

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

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

Serial.println( valeur_potar_position_du_servotete);

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

// de 20 millisecondes

// permettant au servomteur d'atteindre sa position

delay(20);

}

Led 8 mm RGB Grove 104030006 / 104020048 – Version 2.00

–

Mise à jour le 15/02/2020 – Rubrique traitant du module led RGB 8 mm Grove , en particulier sur Arduino méga et nano . Nous traitons des 2 versions 104030006 / 104020048

Continuer la lecture →

Arduino : programmer avec Visual Studio

***

Mise à jour le 28/03/2016

Quels avantages à utiliser Visual Studio ?
Comment installer tout ça ?
Installation du plugin Visual Studio pour Arduino
Ouverture d’un projet Arduino
Paramétrage de votre carte Arduino
La vue Solution Explorer
Et après ?

Vous avez l’habitude d’utiliser l’environnement de développement Arduino ? Vous trouvez celui-ci un peu limité en termes de fonctionnalités ? Nous vous proposons de faire un petit tour avec Visual Studio.

Quels avantages à utiliser Visual Studio ?

Tout d’abord, vous aurez l’auto complétion, ce petit outil qui vous suggère les mots au fur et à mesure que l’on tape. Certains estiment que c’est surfait, d’autres y trouvent un gain de productivité (quelques lettres et un appui sur la touche Tab pour valider le mot proposé, hop, c’est fait, et il n’y a pas de faute de frappe ni de casse).
Vérification live de votre code. Si vous avez fait une faute de frappe, oublié un « ; » ou autre chose, vous le verrez de suite, ce sera souligné en rouge. Plus besoin d’attendre le moment de la compilation pour se rendre compte qu’il y a des erreurs partout.
Le mode debug : Visual Studio permet d’effectuer du pas à pas très facilement dans le programme.
La gestion des fichiers du projet. C’est le premier gros défaut de l’IDE (environnement de développement) Arduino : Si vous voulez ajouter des fichiers, tout concentrer sous forme de projet, vous ne pouvez pas tout voir en mode arborescence (à moins de jongler entre l’explorateur windows et l’IDE Arduino). Visual Studio vous propose une vue « Solution Explorer » dans laquelle vous pouvez voir tous vos fichiers.

Retour au menu :

Comment installer tout ça ?

Tout d’abord, vous devez installer l’IDE Arduino si ce n’est pas déjà fait (sinon, profitez-en pour vérifier si votre version est bien à jour) en suivant ce lien
Ensuite, il vous faudra télécharger Visual Studio Community Edition en suivant ce lien

Une fois le téléchargement de Visual Studio terminé, lancez-le, il vous proposera de choisir vos options.

Installation Visual Studio Community Edition

A ce moment ci, si vous pensez qu’un jour vous testerez le développement d’application windows (windows, windows phone, windows IoT…), je vous conseille d’anticiper, de choisir l’option « Personnalisé ».

Dans l’écran qui suit, cochez « Outils de développement d’applications Windows Universelles »

options Visual Studio Community Edition

Validez l’installation (cela prend un petit moment).

Lors du premier lancement de Visual Studio, il vous demandera de vous identifier pour valider la licence communautaire. Utilisez un compte Microsoft Standard (si vous avez une adresse hotmail, msn, live ou outlook.com vous pouvez vous en servir, cela n’engage strictement rien).

Retour au menu :

Installation du plugin Visual Studio pour Arduino

La possibilité de programmer de l’Arduino au travers de Visual Studio réside dans l’utilisation d’un plugin à installer. Pour se faire, lancez Visual Studio, allez dans le menu Outils puis sur Extensions et mises à jour,

Dans la fenêtre qui suit, partie de gauche, cliquez sur « En ligne » puis « Galerie Visual Studio ». Puis en haut à droite dans la zone de recherche, tapez Arduino.

Installation plugin Arduino

Lorsque vous voyez apparaître « Arduino IDE for Visual Studio », sélectionnez le puis cliquez sur « Installer ». A la fin de l’installation, il vous demandera de redémarrer Visual Studio pour terminer l’opération.

Ce plugin vous demandera de configurer les chemins vers l’environnement Arduino (l’original). Il faut alors lui indiquer où se trouve l’installation de celui ci qui, par défaut se situe à l’endroit indiqué dans la capture ci dessous.

paramétrage Visual Micro

Retour au menu :

Ouverture d’un projet Arduino

Vous pouvez maintenant vérifier que cela fonctionne en ouvrant un projet Arduino (fichier *.ino). Lorsque vous l’ouvrirez, le plugin vous demandera confirmation si vous voulez bien ouvrir ce fichier, il suffit de répondre oui.

Retour au menu :

Si celui ci vous parle ensuite de fin de lignes non cohérentes, vous pouvez y répondre Oui (Visual Studio et l’IDE Arduino n’utilisent pas forcément les mêmes sauts de lignes pour passer à la ligne, d’où ce message permettant de normaliser tout ça).

Paramétrage de votre carte Arduino

La partie supérieure de visual studio présente tout le paramétrage de la carte sur laquelle on travaille

paramétrage Arduino

De gauche à droite :

Choix de la version de l’environnement Arduino (actuellement 1.6.8)
Choix de la carte Arduino utilisée (pour ma part une Mega 2560)
Choix du port Com sur lequel est branchée la carte (COM3)
L’icone juste à droite du port COM permet d’afficher le moniteur Série (permettant de lire et écrire des valeurs vers l’Arduino)
La liste « Add library » permet d’importer des librairies externes
La liste « Add code » permet d’ajouter des fichiers à votre projet (en l’occurence, créer le fichier .ino servant de base à votre programme, ajouter des fichiers cpp et h pour étendre celui-ci…)
Enfin, vous avez deux boutons en bout de ligne. Le premier sert à compiler le projet (pour vérifier qu’il n’y ait pas de faute) et le second sert à compiler et envoyer le programme dans la carte connectée.

Retour au menu :

La vue Solution Explorer

L’explorateur de solutions permet de voir l’ensemble de vos fichiers appartenant à votre projet. Cela permet de tout centraliser, et de tout voir en un seul coup d’œil. Au delà des fichiers, il permet également de se rendre directement dans le code d’une fonction spécifique.

Explorateur de solution

Comme vous pouvez le constater dans la capture ci dessus, juste en dessous du nom du fichier ino, on peut voir les deux fonctions « loop » et « setup ». Vous pouvez facilement imaginer que dans un gros fichiers avec beaucoup de fonctions, cela puisse être plutôt utile.

Et après ?

Vous pouvez continuer à explorer les possibilités de ce plugin au travers du menu « Visual Micro » de Visual Studio. Il propose quelques options supplémentaires.

Vous pouvez aussi faire un tout sur leur site et voir ce que propose de plus la version Pro en suivant ce lien

Capteur de Distance Laser LIDAR-Lite 2 (PulsedLight)

Mise à jour le 04/10/2019 : Le nouveau LIDAR-Lite possède les mêmes spécifications que le capteur d’origine : Capacité de portée jusqu’à 40 mètres avec une résolution de 1 cm.

Continuer la lecture →

Carte Arduino M0 Pro

***

Mise a jour le 26/02/2016

La carte Arduino M0 Pro est basée sur un Atmel ARM Cortex SAMD21 cadencé à 48 MHz sous 32 bits. La version pro est équipée d’un second microcontrôleur EDBG (AT32UC3A4256) et d’un second port USB permettant le débogage et la programmation du SAMD21 via le logiciel Arduino. Cette carte permet d’obtenir de meilleures performances, une meilleure flexibilité que la UNO et permet l’initiation au développement sur une architecture 32 bits.

La carte Arduino M0 Pro dispose deux ports USB:
– un premier port micro-USB (Native) permet d’utiliser le M0 comme un périphérique USB (comme une souris ou un clavier connecté à un PC, hôte USB, port série via programmation) et autorise la programmation (non recommandé).
– un second port micro-USB (Programming) recommandé pour la programmation et le débogage donnant accès au microcontrôleur principal SAMD21 via le microcontrôleur EDBG. Permet de reprogrammer le microcontrôleur principal en cas de plantage.

Des connecteurs situés sur les bords extérieurs du circuit imprimé permettent d’enficher une série de modules complémentaires. L’Arduino M0 pro se programme avec le logiciel Arduino 1.7.8 ou supérieur disponible sur le site Arduino.

Les broches d’alimentation sont les suivants:

VIN . La tension d’entrée de la carte Arduino avec une source d’alimentation externe (par opposition au 5 volts de la connexion USB ou une autre source d’alimentation régulée). La plage de tension d’entrée autorisée pour cette broche est 6-20 V.
5V . L’alimentation régulée utilisée pour alimenter le microcontrôleur et d’ autres composants de la carte. Peut être fournit soit de VIN via le régulateur de la carte , ou être fourni par la prise USB ou d’une autre alimentation 5V régulée.
3V3 . Une alimentation de 3,3 volts est généré par le régulateur sur la carte. Consommation maximale = 1 A (selon la source d’alimentation).

Les entrées sorties :

Chacune des 14 E / S numériques sur le M0 Pro peuvent être utilisé comme une entrée ou une sortie, en utilisant pinMode (), digitalWrite (), et digitalRead (). Ils fonctionnent en 3,3 volts. Pour les broches d’E / S et une résistance de pull-up interne (déconnecté par défaut) de 20-60 kOhms. En outre, certaines broches ont des fonctions spécialisées:

Serial : 0 (RX) et 1 (TX). Permet de recevoir (RX) et transmettre (TX) .
TWI : SDA et SCL. Pour la com TWI en utilisant la bibliothèque Wire.
PWM : Pin 2 à 13 Sortie PWM 8 bits avec la fonction analogWrite (). La résolution du PWM peut être modifiée avec le analogWrite Resolution () fonction.

Note1 Les broches 4 et 10 ne peut pas être utilisé en même temps que PWM.
Note2 Les broches 5 et 12 ne peut pas être utilisé en même temps que PWM.

Entrées analogiques : A0-A5. Le M0 Pro dispose de 6 entrées analogiques, étiquetés A0 à A5. Pins A0-A5 ils apparaissent dans les mêmes endroits que sur le Uno; Chaque entrée analogique fournit 12 bits de résolution.

La programmation de la carte :

L’Arduino M0 Pro peut être programmé avec le logiciel Arduino ( téléchargement ).
Pour Linux OS suivez le guide Arduino IDE sur OS basé sur Linux .

Remarques:
– contrairement aux autres cartes Arduino, les entrées/sorties fonctionnent sous 3,3 Vcc, l’utilisation de 5 Vcc en entrée ou en sortie n’est pas possible. Une tension supérieure endommagera la carte.
– l’intensité maximale de sortie par E/S est de 7 mA.

Caractéristiques:
Alimentation:
– via port USB ou
– 6 à 15 Vcc sur connecteur alim
Microcontrôleur: ATSAMD21G18 ARM Cortex M0 32 bits
Microcontrôleur EDBG (Atmel’s Embedded Debugger): AT32UC3A4256
Mémoire flash: 256 kb (4 kB sont utilisés pour le bootloader)
Mémoire SRAM: 32 kB
Mémoire EEPROM: aucune disponible par défaut, possibilité d’émulation dans la SRAM
Tension de sortie: 3,3 Vcc
14 broches d’E/S dont 12 PWM et série
6 entrées analogiques 12 bits ADC
1 sortie analogique 10 bit DAC
1 broche d’interruption (D2)
Intensité par E/S: 7 mA
Cadencement: 48 MHz
Bus série, I2C et SPI
2 x Fiche micro-USB:
– 1 x usb programmation
– 1 x usb classique
Fiche d’alimentation: 5,5 x 2,1 mm
Dimensions: 69 x 53 x 10 mm
Référence Arduino: A000111
Version d’origine fabriquée en Italie.
Site officiel Arduino: www.arduino.org

Carte microcontrôleur ChipKIT WI-FIRE

.

Mise à jour le 25/12/2018 : Le module chipKIT WI-FIRE est une plate-forme de prototypage microcontrôlée « open-source » compatible avec le brochage et les applications développées pour les Arduino™.

Continuer la lecture →

Piloter un arduino à distance depuis un PC

Mise à jour le 31/05/2017 : Dans cet article, nous allons voir comment envoyer des ordres depuis un pc vers un arduino au travers de la communication RF de deux xbee.

Schéma de principe pour le module Xbee

Dans ce schéma, on peut distinguer deux parties :
L’émetteur : il est constitué d’un PC, d’un arduino et d’un shield xbee.
Le récepteur : il est constitué d’un arduino et d’un shield xbee voir description . Il est également relié à une les et un bouton poussoir par le biais d’un shield Grove méga (mais vous pouvez adapter avec votre matériel sans problème).

Dans notre article, nous allons voir comment allumer une LED à distance mais aussi comment recevoir une information provenant du récepteur au travers d’un bouton poussoir.

Partie récepteur

Il faut donc préparer l’arduino pour qu’une led et un bouton poussoir y soient connectés. Il faut également solidariser le tout avec un shield xbee. Dans notre exemple nous avons placé la LED sur le pin D12 et le bouton sur le pin D2. Nous avons également branché le module xbee sur le port série hardware n°1 (par le biais d’un câblage et non en enfichant le shield sur l’arduino, cela permet de libérer le port COM de base qui sert également à la programmation de l’arduino et évite ainsi de devoir bouger les jumpers sans arrêt).

Au niveau programmation, nous allons coder une partie qui va permettre d’effectuer deux actions :

1) On va lire les données provenant du shield xbee pour voir si nous avons reçu un ordre et transmettre cet ordre à la LED (allumer ou éteindre)
2) On va envoyer l’état du bouton, si celui ci a changé, au PC.

//On place le bouton sur le pin D2
const int buttonPin = 2;
//Onb place la LED sur le pin D12
const int ledPin =  12;
//Variable permettant de connaitre le dernier état du bouton
int lastState = LOW;

void setup() {
  //On initialise le port COM xbee
  Serial1.begin(9600);
  //On initialise la LED
  pinMode(ledPin, OUTPUT);
  //On initialise le bouton
  pinMode(buttonPin, INPUT);     
}

void loop() {
  
  // RECEPTION D'UN ORDRE
  String lastOrdre = "";
  while(Serial1.available()) {
    //On récupère le caractère
    char lastchar = Serial1.read();
    //Si celui ci est un # on s'arrete là, l'ordre est complet
    if(lastchar == '#') { break; }
    //Sinon on concatene avec le reste de l'ordre
    lastOrdre += lastchar;
  }
  
  //Si la taille de l'ordre est > à 0
  if(lastOrdre.length() > 0) {
    //Si l'ordre est ALLUMER
    if(lastOrdre == "ALLUMER") {
      //On passe la led à l'état haut (on l'allume)
      digitalWrite(ledPin, HIGH); 
    }
    //Si l'ordre est d'éteindre
    if(lastOrdre == "ETEINDRE") {
      //On passe la led à l'état bas, on l'éteint
      digitalWrite(ledPin, LOW); 
    }
  }
  
  delay(50);
  
  //EMISSION D'UN ORDRE
  
  //On récupère l'état actuel du bouton
  int currentState = digitalRead(buttonPin);
  //Si l'etat actuel du bouton est différent de celui qu'on avait enregistré la derniere fois, 
  //on sait qu'on doit déclencher un nouvel ordre (on a changé d'état)
  if(currentState != lastState) {
    //Tout d'abord, on enregistre le nouvel état
    lastState = currentState;
    //Si l'état est haut
    if(lastState == HIGH) {
      //On demande l'allumage au PC
      Serial1.write("ALLUMER#");
    }
    //Si l'état est bas
    if(lastState == LOW) {
      //On demande l'extinction au PC
      Serial1.write("ETEINDRE#");
    }
  }
}

//On place le bouton sur le pin D2

const int buttonPin = 2;

//Onb place la LED sur le pin D12

const int ledPin = 12;

//Variable permettant de connaitre le dernier état du bouton

int lastState = LOW;

void setup() {

//On initialise le port COM xbee

Serial1.begin(9600);

//On initialise la LED

pinMode(ledPin, OUTPUT);

//On initialise le bouton

pinMode(buttonPin, INPUT);

}

void loop() {

// RECEPTION D'UN ORDRE

String lastOrdre = "";

while(Serial1.available()) {

//On récupère le caractère

char lastchar = Serial1.read();

//Si celui ci est un # on s'arrete là, l'ordre est complet

if(lastchar == '#') { break; }

//Sinon on concatene avec le reste de l'ordre

lastOrdre += lastchar;

}

//Si la taille de l'ordre est > à 0

if(lastOrdre.length() > 0) {

//Si l'ordre est ALLUMER

if(lastOrdre == "ALLUMER") {

//On passe la led à l'état haut (on l'allume)

digitalWrite(ledPin, HIGH);

}

//Si l'ordre est d'éteindre

if(lastOrdre == "ETEINDRE") {

//On passe la led à l'état bas, on l'éteint

digitalWrite(ledPin, LOW);

}

delay(50);

//EMISSION D'UN ORDRE

//On récupère l'état actuel du bouton

int currentState = digitalRead(buttonPin);

//Si l'etat actuel du bouton est différent de celui qu'on avait enregistré la derniere fois,

//on sait qu'on doit déclencher un nouvel ordre (on a changé d'état)

if(currentState != lastState) {

//Tout d'abord, on enregistre le nouvel état

lastState = currentState;

//Si l'état est haut

if(lastState == HIGH) {

//On demande l'allumage au PC

Serial1.write("ALLUMER#");

}

//Si l'état est bas

if(lastState == LOW) {

//On demande l'extinction au PC

Serial1.write("ETEINDRE#");

}

Partie émetteur – Arduino

La partie émetteur est la plus basique au niveau branchements : Nous avons juste branché un shield xbee par le biais de câbles (comme pour le récepteur) sur le port Série hardware n°1 et nous avons relié l’arduino au port USB.

Le programme de la partie émetteur est très simple, c’est une sorte de routeur. Il va recevoir les ordres du pc qu’il transmet au récepteur et il reçoit des ordres du récepteur qu’il transmet au pc. On utilise donc deux canaux série : le canal série Arduino/PC et le canal série Arduino/xbee.

void setup() {
  //On initialise le port Serie Arduino / PC
  Serial.begin(9600);
  //On initialise le port Serie Arduino / Xbee
  Serial1.begin(9600);
}

void loop() {
  // RECEPTION D'UN ORDRE PROVENANT DE L'ARDUINO
  String lastOrdre = "";
  while(Serial1.available()) {
    //On récupère chaque caractere provenant du module xbee
    char lastchar = Serial1.read();
    //On concatene le caractère au reste de l'ordre
    lastOrdre += lastchar;
    //Si le caractère reçu est un #, on s'arrete là, fin de l'ordre.
    if(lastchar == '#') { break; }
  }
  
  //Si la taille de l'ordre est supérieur à 0 
  if(lastOrdre.length() > 0) {
    //On le renvoie directement vers le PC
    Serial.println(lastOrdre);
  }
  
  delay(50);
  
  // RECEPTION D'UN ORDRE PROVENANT DU PC
  lastOrdre = "";
  while(Serial.available()) {
    //On récupère chaque caractère provenant du PC
    char lastchar = Serial.read();
    //On concatene le caractère au reste de l'ordre
    lastOrdre += lastchar;
    //Si le dernier caractère était un #, on s'arrete là
    if(lastchar == '#') { break; }
  }
  
  if(lastOrdre.length() > 0) {
    //On transmet l'ordre à l'autre arduino via le shield Xbee
    Serial1.print(lastOrdre);
  }
  
}

void setup() {

//On initialise le port Serie Arduino / PC

Serial.begin(9600);

//On initialise le port Serie Arduino / Xbee

Serial1.begin(9600);

}

void loop() {

// RECEPTION D'UN ORDRE PROVENANT DE L'ARDUINO

String lastOrdre = "";

while(Serial1.available()) {

//On récupère chaque caractere provenant du module xbee

char lastchar = Serial1.read();

//On concatene le caractère au reste de l'ordre

lastOrdre += lastchar;

//Si le caractère reçu est un #, on s'arrete là, fin de l'ordre.

if(lastchar == '#') { break; }

}

//Si la taille de l'ordre est supérieur à 0

if(lastOrdre.length() > 0) {

//On le renvoie directement vers le PC

Serial.println(lastOrdre);

}

delay(50);

// RECEPTION D'UN ORDRE PROVENANT DU PC

lastOrdre = "";

while(Serial.available()) {

//On récupère chaque caractère provenant du PC

char lastchar = Serial.read();

//On concatene le caractère au reste de l'ordre

lastOrdre += lastchar;

//Si le dernier caractère était un #, on s'arrete là

if(lastchar == '#') { break; }

}

if(lastOrdre.length() > 0) {

//On transmet l'ordre à l'autre arduino via le shield Xbee

Serial1.print(lastOrdre);

}

Partie émetteur – PC

La partie émetteur PC est assez similaire à la partie récepteur : il va lire les ordres reçus (état du bouton poussoir) et envoyer des ordres (allumer ou éteindre la led).

Dans notre exemple, nous utilisons un bouton nommé « LED » pour allumer ou éteindre la LED. Si on reste appuyé sur le bouton, la LED reste allumée. Si on relâche, elle s’éteint.
En revanche, tant qu’on reste appuyé sur le bouton poussoir, la case à cocher reste cochée, si on relâche le bouton poussoir, la case à cocher se décoche.

Public Class Form1

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        'Au chargement du programme, on ouvre le port COM 3
        SerialPort1.PortName = "COM3"
        SerialPort1.Open()
    End Sub

    Private Sub Form1_FormClosing(sender As Object, e As FormClosingEventArgs) Handles MyBase.FormClosing
        'A la fermeture de fenetre, on ferme le port COM et on détruit le composant SerialPort1
        SerialPort1.Close()
        SerialPort1.Dispose()
    End Sub

    'Evenement reçu lorsqu'on presse le clic souris sur le bouton "LED"
    Private Sub btnLed_MouseDown(sender As Object, e As MouseEventArgs) Handles btnLed.MouseDown
        'On envoie l'ordre d'allumer la LED
        SerialPort1.Write("ALLUMER#")
    End Sub

    'Evenement reçu lorsqu'on relache le clic souris du bouton "LED"
    Private Sub btnLed_MouseUp(sender As Object, e As MouseEventArgs) Handles btnLed.MouseUp
        'On envoie l'ordre d'éteindre la led
        SerialPort1.Write("ETEINDRE#")
    End Sub

    'Evenement reçu lorsqu'on reçoit des données sur le port COM provenant de l'arduino
    Private Sub SerialPort1_DataReceived(sender As Object, e As IO.Ports.SerialDataReceivedEventArgs) Handles SerialPort1.DataReceived
        'On lit la ligne de données provenant de l'arduino
        Dim valeurDepuisArduino As String = SerialPort1.ReadLine().ToString()
        'On traite l'information
        SetValeur(valeurDepuisArduino.Substring(0, valeurDepuisArduino.Length - 2))
    End Sub

    'Méthode déléguée. Cela permet de réaliser la mise à jour de l'interface graphique alors que l'on provient d'un autre 
    'thread que celui de l'interface (opération interdite en direct)
    Delegate Sub SetTextCallback(valeur As String)

    'Fonction permettant de gérer l'appel par délégué
    Private Sub SetValeur(valeur As String)
        'On regarde si on a besoin de passer par un délégué ou non
        If Me.InvokeRequired Then
            'Si oui, on invoque le délégué en transmettant la valeur
            Dim d As New SetTextCallback(AddressOf SetValeur)
            Me.BeginInvoke(d, New Object() {valeur})
        Else
            'Si non, on demande à mettre à jour l'affichage directement
            MettreAJourAffichage(valeur)
        End If
    End Sub

    'Fonction permettant de gérer l'affichage. On lui passe en paramètre la valeur reçue depuis l'arduino
    Private Sub MettreAJourAffichage(valeur As String)
        If valeur = "ETEINDRE" Then
            'Si la valeur reçue est "ETEINDRE" on décoche la case à cocher
            chkBouton.Checked = False
        ElseIf valeur = "ALLUMER" Then
            'Si la valeur reçue est "ALLUMER" on coche la case à cocher
            chkBouton.Checked = True
        End If
    End Sub

End Class

Public Class Form1

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load

'Au chargement du programme, on ouvre le port COM 3

SerialPort1.PortName = "COM3"

SerialPort1.Open()

End Sub

Private Sub Form1_FormClosing(sender As Object, e As FormClosingEventArgs) Handles MyBase.FormClosing

'A la fermeture de fenetre, on ferme le port COM et on détruit le composant SerialPort1

SerialPort1.Close()

SerialPort1.Dispose()

End Sub

'Evenement reçu lorsqu'on presse le clic souris sur le bouton "LED"

Private Sub btnLed_MouseDown(sender As Object, e As MouseEventArgs) Handles btnLed.MouseDown

'On envoie l'ordre d'allumer la LED

SerialPort1.Write("ALLUMER#")

End Sub

'Evenement reçu lorsqu'on relache le clic souris du bouton "LED"

Private Sub btnLed_MouseUp(sender As Object, e As MouseEventArgs) Handles btnLed.MouseUp

'On envoie l'ordre d'éteindre la led

SerialPort1.Write("ETEINDRE#")

End Sub

'Evenement reçu lorsqu'on reçoit des données sur le port COM provenant de l'arduino

Private Sub SerialPort1_DataReceived(sender As Object, e As IO.Ports.SerialDataReceivedEventArgs) Handles SerialPort1.DataReceived

'On lit la ligne de données provenant de l'arduino

Dim valeurDepuisArduino As String = SerialPort1.ReadLine().ToString()

'On traite l'information

SetValeur(valeurDepuisArduino.Substring(0, valeurDepuisArduino.Length - 2))

End Sub

'Méthode déléguée. Cela permet de réaliser la mise à jour de l'interface graphique alors que l'on provient d'un autre

'thread que celui de l'interface (opération interdite en direct)

Delegate Sub SetTextCallback(valeur As String)

'Fonction permettant de gérer l'appel par délégué

Private Sub SetValeur(valeur As String)

'On regarde si on a besoin de passer par un délégué ou non

If Me.InvokeRequired Then

'Si oui, on invoque le délégué en transmettant la valeur

Dim d As New SetTextCallback(AddressOf SetValeur)

Me.BeginInvoke(d, New Object() {valeur})

Else

'Si non, on demande à mettre à jour l'affichage directement

MettreAJourAffichage(valeur)

End If

End Sub

'Fonction permettant de gérer l'affichage. On lui passe en paramètre la valeur reçue depuis l'arduino

Private Sub MettreAJourAffichage(valeur As String)

If valeur = "ETEINDRE" Then

'Si la valeur reçue est "ETEINDRE" on décoche la case à cocher

chkBouton.Checked = False

ElseIf valeur = "ALLUMER" Then

'Si la valeur reçue est "ALLUMER" on coche la case à cocher

chkBouton.Checked = True

End If

End Sub

End Class

Téléchargements

Télécharger => Émetteur PC

Télécharger => Émetteur – Arduino

Télécharger => Récepteur Arduino

Communication PC (Visual Studio) vers Arduino

.

Mise à jour le 08/09/2019 : Dans cet article, nous allons envoyer des données depuis le pc vers l’Arduino. Le principe est tout simple : lorsqu’on va déplacer la glissière (trackbar) sur l’application PC, on va modifier l’éclairage de la LED connectée à l’Arduino.

Continuer la lecture →

Écrire Arduino

Codes source du programme arduino permettant de récupérer une valeur provenant du pc (envoyée par le biais d’un programme Visual studio) et code source du programme Visual studio permettant d’envoyer une valeur à l’arduino par le biais d’une petite glissière.

Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .

Facebook Twitter Youtube

Retour à la page principal