Archives par étiquette : GROVE

Récupérer les coordonnées GPS de l’arduino sur une application PC (Visual Studio)

–

Mise à jour le 22/09/2017.Lorsque vous utilisez un Arduino, vous avez peut être besoin de récupérer des informations depuis celui ci sur votre PC.

Prérequis

Vous devez avoir Visual Studio installé sur votre PC. Si vous souhaitez reproduire notre article chez vous, il vous faudra également un arduino avec un système grove GPS afin de récupérer les trames GPGGA de celui ci.

Côté Arduino

Il faudra réaliser un montage très simple : reliez le 5v et gnd du module GPS à votre Arduino. Reliez ensuite la broche TX du GPS au pin D2 et la broche RX du GPS au pin D3 de l’arduino

Envoyez ensuite le programme Arduino suivant qui permettra de récupérer les trames GPGGA du GPS et qui les route vers le port série relié au PC

#include <SoftwareSerial.h>

//Création de la variable SoftSerial (connexion software au port serie) RX sur le pin D2 et TX sur le pin D3
SoftwareSerial SoftSerial(2, 3);
//On crée un tableau de caractères qui contiendra notre trame GPS
unsigned char buffer[200];
//la variable count nous servira à ne pas dépasser les 200 caractères du tableau.
int count=0;   

void setup() {
  //On initialise le port série software 
  SoftSerial.begin(9600);
  //On initialise le port série de l'arduino
  Serial.begin(9600); 
}

void loop() {
  //On récupère la trame GPS
  getGPS();
}

void getGPS() {
  //Si le port série contient des données
  if (SoftSerial.available())                    
    {
        char currentchar = '.';
        
        //Dans cette boucle, on va attendre de recontrer le caractère $ qui indique un début de ligne
        while(SoftSerial.available())
        {
          //On récupère un caractère depuis le port série
          char currentchar = SoftSerial.read();
          //Si ce caractère est $, on est alors en début de trame
          if(currentchar == '

#include <SoftwareSerial.h>

//Création de la variable SoftSerial (connexion software au port serie) RX sur le pin D2 et TX sur le pin D3

SoftwareSerial SoftSerial(2, 3);

//On crée un tableau de caractères qui contiendra notre trame GPS

unsigned char buffer[200];

//la variable count nous servira à ne pas dépasser les 200 caractères du tableau.

int count=0;

void setup() {

//On initialise le port série software

SoftSerial.begin(9600);

//On initialise le port série de l'arduino

Serial.begin(9600);

}

void loop() {

//On récupère la trame GPS

getGPS();

}

void getGPS() {

//Si le port série contient des données

if (SoftSerial.available())

{

char currentchar = '.';

//Dans cette boucle, on va attendre de recontrer le caractère $ qui indique un début de ligne

while(SoftSerial.available())

{

//On récupère un caractère depuis le port série

char currentchar = SoftSerial.read();

//Si ce caractère est $, on est alors en début de trame

if(currentchar == '

Côté PC : Création du projet Visual Studio

Lancez visual studio puis créez un nouveau projet Windows Forms Application. Vous verrez apparaître alors une fenêtre qui est la fenêtre de votre application.

Visual Studio Serial Port

Dans la boite à outils (toolbox), sélectionnez le composant SerialPort puis glissez-le sur votre fenêtre. Vous le verrez apparaître en bas de l’écran.

Insérez également deux boutons (un pour Connecter, un pour déconnecter), un numericUpDown (pour préciser le port COM) et un textbox (qui affichera les données de l’arduino) dont l’option multiline est active.

En double cliquant sur un bouton, vous entrez dans le code de son événement de clic. C’est ici que l’on doit coder ce qui doit se produire quand on clique sur le bouton.

Voici le code permettant de se connecter ou déconnecter du port com de l’arduino :

    'Evenement déclenché quand on clique sur le bouton connecter
    Private Sub btnConnecter_Click(sender As Object, e As EventArgs) Handles btnConnecter.Click
        'On indique le nom du port com à utiliser en concaténant "COM" avec le numéro sélectionné dans le controle numericupdown
        SerialPort1.PortName = String.Format("COM{0}", numPortSerie.Value)
        'On ouvre la connexion série
        SerialPort1.Open()
    End Sub

    'Evenement déclenché quand on clique sur le bouton déconnecter
    Private Sub btnDeconnecter_Click(sender As Object, e As EventArgs) Handles btnDeconnecter.Click
        'On ferme la connexion série
        SerialPort1.Close()
    End Sub

'Evenement déclenché quand on clique sur le bouton connecter

Private Sub btnConnecter_Click(sender As Object, e As EventArgs) Handles btnConnecter.Click

'On indique le nom du port com à utiliser en concaténant "COM" avec le numéro sélectionné dans le controle numericupdown

SerialPort1.PortName = String.Format("COM{0}", numPortSerie.Value)

'On ouvre la connexion série

SerialPort1.Open()

End Sub

'Evenement déclenché quand on clique sur le bouton déconnecter

Private Sub btnDeconnecter_Click(sender As Object, e As EventArgs) Handles btnDeconnecter.Click

'On ferme la connexion série

SerialPort1.Close()

End Sub

Dans la connexion, on indique quel est le port à utiliser sous la forme d’une chaîne de caractères (Exemple : COM8) puis on ouvre la communication. Dans le bouton déconnecter, on ferme la connexion série.

Afin de récupérer les données envoyées depuis l’arduino vers le PC, on va s’abonner à un événement du port série.

'Evenement déclenché quand on reçoit des données sur le port série
    Private Sub SerialPort1_Receiving(sender As Object, e As IO.Ports.SerialDataReceivedEventArgs) Handles SerialPort1.DataReceived
        'On lit la ligne complète
        SetText(SerialPort1.ReadLine().ToString())
    End Sub

    'Délégué permettant de mettre à jour l'interface graphique alors qu'on n'est pas sur le même thread
    Delegate Sub SetTextCallback(text As String)

    'Gestion par délégué de la mise à jour de l'interface graphique
    Private Sub SetText(text As String)
        'Si on constate qu'on n'est pas sur le bon thread
        If txtInputArduino.InvokeRequired Then
            'On fait appel au délégué qui va pointer sur cette même fonction
            Dim d As New SetTextCallback(AddressOf SetText)
            Me.Invoke(d, New Object() {text})
        Else
            'Cas où on provient du délégué, on est sur le bon thread pour mettre à jour l'interface graphique
            AfficherLatitudeLongitude(text)
        End If
    End Sub

'Evenement déclenché quand on reçoit des données sur le port série

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

'On lit la ligne complète

SetText(SerialPort1.ReadLine().ToString())

End Sub

'Délégué permettant de mettre à jour l'interface graphique alors qu'on n'est pas sur le même thread

Delegate Sub SetTextCallback(text As String)

'Gestion par délégué de la mise à jour de l'interface graphique

Private Sub SetText(text As String)

'Si on constate qu'on n'est pas sur le bon thread

If txtInputArduino.InvokeRequired Then

'On fait appel au délégué qui va pointer sur cette même fonction

Dim d As New SetTextCallback(AddressOf SetText)

Me.Invoke(d, New Object() {text})

Else

'Cas où on provient du délégué, on est sur le bon thread pour mettre à jour l'interface graphique

AfficherLatitudeLongitude(text)

End If

End Sub

SerialPort1_Receiving est l’événement qui indique que le port Série virtuel du PC a reçu des données. A chaque fois qu’il se déclenche, on va lire ces données puis les envoyer à la suite du texte déjà présent dans le textbox. Etant donné que la récupération sur le port série se passe sur un autre thread (processus) que celui de l’application, on ne peut pas directement mettre à jour l’interface graphique (afficher le texte) depuis l’évenement du port série sous peine d’avoir une erreur à l’exécution. On va donc passer depuis un délégué qui va se charger de transmettre l’information et mettre à jour l’interface graphique (partie avec le Delegate et méthode SetText).

Maintenant, nous allons récupérer indépendamment la latitude et la longitude et les afficher à l’écran.

'Partie permettant de traiter l'information transmise par l'Arduino
    Private Sub AfficherLatitudeLongitude(trameGPGGA As String)
        'On ajoute la nouvelle trame reçue à l'affichage dans le textbox
        txtInputArduino.Text = String.Format("{0}{1}", txtInputArduino.Text, trameGPGGA)
        'Si la trame ne commence pas par $, on quitte la fonction
        If Not trameGPGGA.StartsWith("$") Then Exit Sub
        'On coupe la trame à chaque virgule
        Dim parties As String() = trameGPGGA.Split(",")
        'On récupère la partie longitude et la partie latitude et on remplace le . par , pour pouvoir les utiliser en tant que valeur numérique (culture fr-FR)
        Dim partielatitudeBrute As String = parties(2).Replace(".", ",")
        Dim partielongitudeBrute As String = parties(4).Replace(".", ",")
        'Si une des deux valeurs est vide ou bien n'est pas numérique, on quitte la fonction
        If String.IsNullOrWhiteSpace(partielatitudeBrute) OrElse Not IsNumeric(partielatitudeBrute) Then Exit Sub
        If String.IsNullOrWhiteSpace(partielongitudeBrute) OrElse Not IsNumeric(partielongitudeBrute) Then Exit Sub
        'On remet les données à la bonne echelle (on divise par 100)
        Dim partielatitude As String = CDec(partielatitudeBrute) / 100
        Dim partielongitude As String = CDec(partielongitudeBrute) / 100
        'On affiche les données
        LabelLatitude.Text = String.Format("Latitude : {0}", partielatitude)
        LabelLongitude.Text = String.Format("Longitude : {0}", partielongitude)
    End Sub

'Partie permettant de traiter l'information transmise par l'Arduino

Private Sub AfficherLatitudeLongitude(trameGPGGA As String)

'On ajoute la nouvelle trame reçue à l'affichage dans le textbox

txtInputArduino.Text = String.Format("{0}{1}", txtInputArduino.Text, trameGPGGA)

'Si la trame ne commence pas par $, on quitte la fonction

If Not trameGPGGA.StartsWith("$") Then Exit Sub

'On coupe la trame à chaque virgule

Dim parties As String() = trameGPGGA.Split(",")

'On récupère la partie longitude et la partie latitude et on remplace le . par , pour pouvoir les utiliser en tant que valeur numérique (culture fr-FR)

Dim partielatitudeBrute As String = parties(2).Replace(".", ",")

Dim partielongitudeBrute As String = parties(4).Replace(".", ",")

'Si une des deux valeurs est vide ou bien n'est pas numérique, on quitte la fonction

If String.IsNullOrWhiteSpace(partielatitudeBrute) OrElse Not IsNumeric(partielatitudeBrute) Then Exit Sub

If String.IsNullOrWhiteSpace(partielongitudeBrute) OrElse Not IsNumeric(partielongitudeBrute) Then Exit Sub

'On remet les données à la bonne echelle (on divise par 100)

Dim partielatitude As String = CDec(partielatitudeBrute) / 100

Dim partielongitude As String = CDec(partielongitudeBrute) / 100

'On affiche les données

LabelLatitude.Text = String.Format("Latitude : {0}", partielatitude)

LabelLongitude.Text = String.Format("Longitude : {0}", partielongitude)

End Sub

Comme la communication série récupère les données par bribes, on doit donc recomposer les trames GPGGA pour pouvoir les traiter une à une. La fonction remplirTrame se charge de récupérer les données et reformer une trame GPGGA complète. Dès que la trame est complète, on va la traiter à l’aide de la fonction AfficherLatitudeLongitude pour découper la trame, récupérer les informations puis les convertir en affichage réutilisable.

Le code source en téléchargement

Code source complet du programme

Code source à télécharger

Pour utiliser l’application, réaliser le montage Arduino/GPS puis envoyer le programme de notre article sur le module GPS Grove. Connectez l’arduino au pc, lancez le programme GPS Localiser puis choisissez le port com correspondant à l’arduino. Cliquez sur connecter et attendez que les trames GPGGA apparaissent. Vous aurez alors la latitude et la longitude dès que le GPS aura accroché les satellites.

Réalisé par Steeve / Hervé

Grove OLE42178P : Exemple 88 Réglage du niveau de gris

Exemple 88
Réglage du niveau de gris

Continuer la lecture →

Grove OLE42178P : Exemple 87 Visualisation de 2 entrées analogique

***

Mise à jour le 22/03/2017

Le but de cet exemple n’est pas d’optimisé le programme mais de montrer le principe de fonctionnement de celui-ci ( dans la partie void setup la présentation du numéro de l’exemple idem à l’exemple 86 )

Exemple 87. Affichage de valeur analogique

Matériel nécessaire

– 1 Carte Arduino Mega 2560
– 1 Carte Grove Mega Shield
– 1 Afficheur Oled 96×96 OLE42178P
– 1 Détecteur de lumière Grove SEN11302P
– 1 Module potentiomètre Grove COM08212P

A savoir

– la fonction d’initialisation setup() qui est exécutée une seule fois au démarrage.Cette fonction est utilisée pour initialiser les variables, le sens des broches, les librairies utilisées
– la fonction « boucle sans fin » loop() qui est exécutée en boucle une fois que la fonction setup() a été exécutée une fois.
– Toutes les lignes qui commencent par // sont ignorées par le compilateur et sont appelées des commentaires.Les commentaires sont des lignes de texte incluses dans le programme, de plus elles n’occupent aucun espace mémoire dans le microcontrôleur
– Le code de la fonction est compris entre des accolades qui sont en quelque sorte les « bornes » délimitant la fonction.Les accolades sont un élément majeur de la programmation en langage C. Elles sont utilisées dans plusieurs constructions différentes.

Notion à savoir :

//
//
// ***************************************************
// *   Programme réaliser par RedOhm                 *
// *                                                 *
// *   1- Positionnement d'un texte sur plusieurs    *
// *      lignes                                     *
// *   2- une pause de 3 secondes                    *
// *   3- efface l'ecran                             *
// *   4- recuperation et affichage des entrees      *
// *      analogique                                 *
// *                                                 *
// *                                                 *
// *  H.Mazelin                                      *
// ***************************************************



//Cette bibliothèque vous permet de communiquer avec des périphériques  I2C
#include <Wire.h>
//bibliothèque de gestion de l’afficheur SeeedGrayOLED.h
#include <SeeedGrayOLED.h>
// avr/pgmspace.h .Afin de Stocker les données  dans la mémoire 
// Flash (mémoire  programme) au  lieu de  la mémoire SRAM
#include <avr/pgmspace.h>

// Potentiometre connectée a l'entrée analogique 0
const int potentiometrePin =0;
// Détecteur de lumière Grove SEN11302P connectée a l'entrée analogique 2
const int lumierePin = 2;



 
// 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
// etc… ( void setup )
 
void setup()
{

  
  //initialise la librairie Wire et se connecte au bus I2C  
  //cette instruction ne doit normalement n'être appelée qu'une seule fois 
  Wire.begin();
   
   
 
 //initialiser l'écran OLED SEEED
  SeeedGrayOled.init();
 //Effacer l'écran            
  SeeedGrayOled.clearDisplay(); 
 //Réglage du mode d'affichage en normal 
  SeeedGrayOled.setNormalDisplay(); 
 // Passez en mode vertical pour l'affichage du texte  
  SeeedGrayOled.setVerticalMode();  
 
  
  {
 //Réglez le niveau Niveaux de gris. Ne importe quel nombre entre 0-15.
  SeeedGrayOled.setGrayLevel(15);    
  
  //position du curseur pour régler ligne 1, colonne 0
  SeeedGrayOled.setTextXY(1,0); 
  // Afficher RedOhm
  SeeedGrayOled.putString("RedOhm"); 
  
  //position du curseur pour régler ligne 2, colonne 3
  SeeedGrayOled.setTextXY(2,3); 
  // Afficher Bonjour 
  SeeedGrayOled.putString("bonjour"); 
  
  //position du curseur pour régler ligne 5, colonne 3
  SeeedGrayOled.setTextXY(5,0); 
  // Afficher Exercice 
  SeeedGrayOled.putString("Exercice"); 
  
  //position du curseur pour régler ligne 6, colonne 5
  SeeedGrayOled.setTextXY(7,5); 
  // N 87 
  SeeedGrayOled.putString("N 87"); 
  
  
  
  // pause de 3 secondes 
  delay (3000);
  //initialiser l'écran OLED SEEED
  SeeedGrayOled.init();
  //Effacer l'écran            
  SeeedGrayOled.clearDisplay(); 
  
 
  
  }
}

// Le programme principal s’exécute par une boucle infinie appelée Loop () 
void loop()
{
    //position du curseur pour afficher potemtiometre ligne 9, colonne 0
     SeeedGrayOled.setTextXY(9,0);
    // affiche le nom Potar  
    SeeedGrayOled.putString("Potar");
    //position du curseur pour afficher lumiere ligne 7, colonne 0
     SeeedGrayOled.setTextXY(7,0);
    // affiche le nom lumiere  
    SeeedGrayOled.putString("Lumiere");
  
  
  
  
    
  
 // lit la tension présente sur la broche analogique pin.La fonction 
 // analogRead() renvoie la valeur lue , convertie en un entier 
 // compris entre 0 et 1023 
 int valeurpo = analogRead(potentiometrePin);
  int valeurlumiere = analogRead(lumierePin);
 
 
 // debut du traitement efface 1
 
  // si la valeur valeurpo et strictement inférieure à 10
  // efface le derniere caractere
  if (valeurpo<10)
     {
     //position du curseur pour effacer le dernier caractére ligne 10, colonne 6
     SeeedGrayOled.setTextXY(10,6);
    // affiche un espace vide  
    SeeedGrayOled.putString(" ");   
     }
     
     
  // si la valeur valeurpo et strictement inférieure à 100
  // efface le derniere caractere  
  else if (valeurpo<100)
     {
     //position du curseur pour effacer le dernier caractére ligne 10, colonne 7
     SeeedGrayOled.setTextXY(10,7);
     // affiche un espace vide
     SeeedGrayOled.putString(" ");
     }
     
  // si la valeur valeurpo et strictement inférieure à 1000
  // efface le derniere caractere    
  else if (valeurpo<1000)
     {
     //position du curseur pour effacer le dernier caractere ligne 10, colonne 8
     SeeedGrayOled.setTextXY(10,8);
     // affiche un espace vide
     SeeedGrayOled.putString(" ");
     }
   
// fin de traitement efface 1   
   
   
  
// debut du traitement efface 2
 
  // si la valeur valeurpo et strictement inférieure à 10
  // efface le derniere caractere
  if (valeurlumiere<10)
     {
     //position du curseur pour effacer le dernier caractére ligne 8, colonne 6
     SeeedGrayOled.setTextXY(8,6);
    // affiche un espace vide  
    SeeedGrayOled.putString(" ");   
     }
     
     
  // si la valeur valeurpo et strictement inférieure à 100
  // efface le derniere caractere  
  else if (valeurlumiere<100)
     {
     //position du curseur pour effacer le dernier caractére ligne 8, colonne 7
     SeeedGrayOled.setTextXY(8,7);
     // affiche un espace vide
     SeeedGrayOled.putString(" ");
     }
     
  // si la valeur valeurpo et strictement inférieure à 1000
  // efface le derniere caractere    
  else if (valeurlumiere<1000)
     {
     //position du curseur pour effacer le dernier caractere ligne 8, colonne 8
     SeeedGrayOled.setTextXY(8,8);
     // affiche un espace vide
     SeeedGrayOled.putString(" ");
     }
   
// fin de traitement efface 2   
      
   
   
   
       
       
  //position du curseur pour régler ligne 10, colonne 5
   SeeedGrayOled.setTextXY(10,5); 
  // Affiche la valeur du potentiometre 
  SeeedGrayOled.putNumber(valeurpo); 
  
   //position du curseur pour régler ligne 8, colonne 5
   SeeedGrayOled.setTextXY(8,5); 
  // Affiche la valeur du detecteur de lumiere 
  SeeedGrayOled.putNumber(valeurlumiere); 
 
   
  
  
}

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

// ***************************************************

// * Programme réaliser par RedOhm *

// * *

// * 1- Positionnement d'un texte sur plusieurs *

// * lignes *

// * 2- une pause de 3 secondes *

// * 3- efface l'ecran *

// * 4- recuperation et affichage des entrees *

// * analogique *

// * *

// * H.Mazelin *

// ***************************************************

//Cette bibliothèque vous permet de communiquer avec des périphériques I2C

#include <Wire.h>

//bibliothèque de gestion de l’afficheur SeeedGrayOLED.h

#include <SeeedGrayOLED.h>

// avr/pgmspace.h .Afin de Stocker les données dans la mémoire

// Flash (mémoire programme) au lieu de la mémoire SRAM

#include <avr/pgmspace.h>

// Potentiometre connectée a l'entrée analogique 0

const int potentiometrePin =0;

// Détecteur de lumière Grove SEN11302P connectée a l'entrée analogique 2

const int lumierePin = 2;

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

// etc… ( void setup )

void setup()

{

//initialise la librairie Wire et se connecte au bus I2C

//cette instruction ne doit normalement n'être appelée qu'une seule fois

Wire.begin();

//initialiser l'écran OLED SEEED

SeeedGrayOled.init();

//Effacer l'écran

SeeedGrayOled.clearDisplay();

//Réglage du mode d'affichage en normal

SeeedGrayOled.setNormalDisplay();

// Passez en mode vertical pour l'affichage du texte

SeeedGrayOled.setVerticalMode();

{

//Réglez le niveau Niveaux de gris. Ne importe quel nombre entre 0-15.

SeeedGrayOled.setGrayLevel(15);

//position du curseur pour régler ligne 1, colonne 0

SeeedGrayOled.setTextXY(1,0);

// Afficher RedOhm

SeeedGrayOled.putString("RedOhm");

//position du curseur pour régler ligne 2, colonne 3

SeeedGrayOled.setTextXY(2,3);

// Afficher Bonjour

SeeedGrayOled.putString("bonjour");

//position du curseur pour régler ligne 5, colonne 3

SeeedGrayOled.setTextXY(5,0);

// Afficher Exercice

SeeedGrayOled.putString("Exercice");

//position du curseur pour régler ligne 6, colonne 5

SeeedGrayOled.setTextXY(7,5);

// N 87

SeeedGrayOled.putString("N 87");

// pause de 3 secondes

delay (3000);

//initialiser l'écran OLED SEEED

SeeedGrayOled.init();

//Effacer l'écran

SeeedGrayOled.clearDisplay();

}

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

void loop()

{

//position du curseur pour afficher potemtiometre ligne 9, colonne 0

SeeedGrayOled.setTextXY(9,0);

// affiche le nom Potar

SeeedGrayOled.putString("Potar");

//position du curseur pour afficher lumiere ligne 7, colonne 0

SeeedGrayOled.setTextXY(7,0);

// affiche le nom lumiere

SeeedGrayOled.putString("Lumiere");

// lit la tension présente sur la broche analogique pin.La fonction

// analogRead() renvoie la valeur lue , convertie en un entier

// compris entre 0 et 1023

int valeurpo = analogRead(potentiometrePin);

int valeurlumiere = analogRead(lumierePin);

// debut du traitement efface 1

// si la valeur valeurpo et strictement inférieure à 10

// efface le derniere caractere

if (valeurpo<10)

{

//position du curseur pour effacer le dernier caractére ligne 10, colonne 6

SeeedGrayOled.setTextXY(10,6);

// affiche un espace vide

SeeedGrayOled.putString(" ");

}

// si la valeur valeurpo et strictement inférieure à 100

// efface le derniere caractere

else if (valeurpo<100)

{

//position du curseur pour effacer le dernier caractére ligne 10, colonne 7

SeeedGrayOled.setTextXY(10,7);

// affiche un espace vide

SeeedGrayOled.putString(" ");

}

// si la valeur valeurpo et strictement inférieure à 1000

// efface le derniere caractere

else if (valeurpo<1000)

{

//position du curseur pour effacer le dernier caractere ligne 10, colonne 8

SeeedGrayOled.setTextXY(10,8);

// affiche un espace vide

SeeedGrayOled.putString(" ");

}

// fin de traitement efface 1

// debut du traitement efface 2

// si la valeur valeurpo et strictement inférieure à 10

// efface le derniere caractere

if (valeurlumiere<10)

{

//position du curseur pour effacer le dernier caractére ligne 8, colonne 6

SeeedGrayOled.setTextXY(8,6);

// affiche un espace vide

SeeedGrayOled.putString(" ");

}

// si la valeur valeurpo et strictement inférieure à 100

// efface le derniere caractere

else if (valeurlumiere<100)

{

//position du curseur pour effacer le dernier caractére ligne 8, colonne 7

SeeedGrayOled.setTextXY(8,7);

// affiche un espace vide

SeeedGrayOled.putString(" ");

}

// si la valeur valeurpo et strictement inférieure à 1000

// efface le derniere caractere

else if (valeurlumiere<1000)

{

//position du curseur pour effacer le dernier caractere ligne 8, colonne 8

SeeedGrayOled.setTextXY(8,8);

// affiche un espace vide

SeeedGrayOled.putString(" ");

}

// fin de traitement efface 2

//position du curseur pour régler ligne 10, colonne 5

SeeedGrayOled.setTextXY(10,5);

// Affiche la valeur du potentiometre

SeeedGrayOled.putNumber(valeurpo);

//position du curseur pour régler ligne 8, colonne 5

SeeedGrayOled.setTextXY(8,5);

// Affiche la valeur du detecteur de lumiere

SeeedGrayOled.putNumber(valeurlumiere);

}

Grove OLE42178P : Exemple 86 Visualisation de 4 entrées

***

Visualisation de 4 entrées sur l ‘afficheur OLE42178P

Mise à jour le 19/01/2017

Le but de cet exemple n’est pas d’optimisé le programme mais de montrer le principe de fonctionnement de celui-ci.

Matériel nécessaire

– 1 Carte Arduino Mega 2560
– 1 Carte Grove Mega Shield
– 1 Afficheur Oled 96×96 OLE42178P
– 1 Bouton poussoir ou un fil shunt

A savoir

– la fonction d’initialisation setup() qui est exécutée une seule fois au démarrage. Cette fonction est utilisée pour initialiser les variables, le sens des broches, les librairies utilisées
– la fonction “boucle sans fin” loop() qui est exécutée en boucle une fois que la fonction setup() a été exécutée une fois.
– Toutes les lignes qui commencent par // sont ignorées par le compilateur et sont appelées des commentaires. Les commentaires sont des lignes de texte incluses dans le programme, de plus elles n’occupent aucun espace mémoire dans le microcontrôleur
– Le code de la fonction est compris entre des accolades qui sont en quelque sorte les “bornes” délimitant la fonction. Les accolades sont un élément majeur de la programmation en langage C. Elles sont utilisées dans plusieurs constructions différentes.

//
//
// ***************************************************
// *   Programme réaliser par RedOhm                 *
// *                                                 *
// *   1- Positionnement d'un texte sur plusieurs    *
// *      lignes                                     *
// *   2- une pause de 3 secondes                    *
// *   3- efface l'ecran                             *
// *   4- Un petite menu pour controler les entrees  *
// *                                                 *
// *                                                 *
// *                                                 *
// *  H.Mazelin                                      *
// ***************************************************



//Cette bibliothèque vous permet de communiquer avec des périphériques  I2C
#include <Wire.h>
//bibliothèque de gestion de l’afficheur SeeedGrayOLED.h
#include <SeeedGrayOLED.h>
// avr/pgmspace.h .Afin de Stocker les données  dans la mémoire 
// Flash (mémoire  programme) au  lieu de  la mémoire SRAM
#include <avr/pgmspace.h>

//definition du numéro de la broche pour le boutons poussoirs
//correspondant
const int entree03Pin = 3;  
const int entree05Pin = 5;
const int entree07Pin = 7;
const int entree09Pin = 9;

// variable pour la lecture de l'état des boutons poussoirs
int entree03State = 0;
int entree05State = 0;
int entree07State = 0;
int entree09State = 0;

 
// 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
// etc… ( void setup )
 
void setup()
{
  Wire.begin();
//initialiser les broches des boutons-poussoirs en entrées  
   pinMode(entree03Pin, INPUT);
   pinMode(entree05Pin, INPUT);
   pinMode(entree07Pin, INPUT);
   pinMode(entree09Pin, INPUT);
   
   
 
 //initialiser l'écran OLED SEEED
  SeeedGrayOled.init();
 //Effacer l'écran            
  SeeedGrayOled.clearDisplay(); 
 //Réglage du mode d'affichage en normal 
  SeeedGrayOled.setNormalDisplay(); 
 // Passez en mode vertical pour l'affichage du texte  
  SeeedGrayOled.setVerticalMode();  
 
  
  {
 //Réglez le niveau Niveaux de gris. Ne importe quel nombre entre 0-15.
  SeeedGrayOled.setGrayLevel(15);    
  
  //position du curseur pour régler ligne 1, colonne 0
  SeeedGrayOled.setTextXY(1,0); 
  // Afficher RedOhm
  SeeedGrayOled.putString("RedOhm"); 
  
  //position du curseur pour régler ligne 2, colonne 3
  SeeedGrayOled.setTextXY(2,3); 
  // Afficher Bonjour 
  SeeedGrayOled.putString("bonjour"); 
  
  //position du curseur pour régler ligne 5, colonne 3
  SeeedGrayOled.setTextXY(5,0); 
  // Afficher Exercice  
  SeeedGrayOled.putString("Exercice"); 
  
  //position du curseur pour régler ligne 6, colonne 5
  SeeedGrayOled.setTextXY(7,5); 
  // Afficher N 86 
  SeeedGrayOled.putString("N 86"); 
  
  
  
  // pause de 3 secondes 
  delay (3000);
  //initialiser l'écran OLED SEEED
  SeeedGrayOled.init();
  //Effacer l'écran            
  SeeedGrayOled.clearDisplay(); 
  
 
  
  }
}

// Le programme principal s’exécute par une boucle infinie appelée Loop () 
void loop()
{
   
   //position du curseur pour régler ligne 0, colonne 0
  SeeedGrayOled.setTextXY(0,0); 
  // Etat entrées 
  SeeedGrayOled.putString("Etat entree"); 
  
  
  // lire l'état de la valeur du bouton poussoir
  entree03State = digitalRead(entree03Pin);
  //vérifie si le bouton est appuyé
   if (entree03State == HIGH) {     
    
  //position du curseur pour régler ligne 2, colonne 0
  SeeedGrayOled.setTextXY(2,0); 
  // Afficher E-3 ->ON
  SeeedGrayOled.putString("E-3 ->ON ");  
    
  } 
  else {
  //position du curseur pour régler ligne 2, colonne 0  
  SeeedGrayOled.setTextXY(2,0); 
  // Afficher E-3 ->OFF
  SeeedGrayOled.putString("E-3 ->OFF");   
  }

 // lire l'état de la valeur du bouton poussoir
 entree05State = digitalRead(entree05Pin);
 ////vérifie si le bouton est appuyé
   if (entree05State == HIGH) {     
    
  //position du curseur pour régler ligne 3, colonne 0
  SeeedGrayOled.setTextXY(3,0); 
  // Afficher E-5 ->ON
  SeeedGrayOled.putString("E-5 ->ON ");  
    
  } 
  else {
  
  //position du curseur pour régler ligne 3, colonne 0  
  SeeedGrayOled.setTextXY(3,0); 
  // Afficher E-5 ->OFF
  SeeedGrayOled.putString("E-5 ->OFF");
}


 // lire l'état de la valeur du bouton poussoir
 entree07State = digitalRead(entree07Pin);
 //vérifie si le bouton est appuyé
   if (entree07State == HIGH) {     
    
  //position du curseur pour régler ligne 4, colonne 0
  SeeedGrayOled.setTextXY(4,0); 
  // Afficher E-7 ->ON
  SeeedGrayOled.putString("E-7 ->ON ");  
    
  } 
  else {
  
  //position du curseur pour régler ligne 4, colonne 0  
  SeeedGrayOled.setTextXY(4,0); 
  // Afficher E-7 ->OFF
  SeeedGrayOled.putString("E-7 ->OFF");
}


 // lire l'état de la valeur du bouton poussoir
 entree09State = digitalRead(entree09Pin);
 //vérifie si le bouton est appuyé
   if (entree09State == HIGH) {     
    
  //position du curseur pour régler ligne 5, colonne 0
  SeeedGrayOled.setTextXY(5,0); 
  // Afficher E-9 ->ON
  SeeedGrayOled.putString("E-9 ->ON ");  
    
  } 
  else {
  
  //position du curseur pour régler ligne 5, colonne 0  
  SeeedGrayOled.setTextXY(5,0); 
  // Afficher E-9 ->OFF
  SeeedGrayOled.putString("E-9 ->OFF");
}


}

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

// ***************************************************

// * Programme réaliser par RedOhm *

// * *

// * 1- Positionnement d'un texte sur plusieurs *

// * lignes *

// * 2- une pause de 3 secondes *

// * 3- efface l'ecran *

// * 4- Un petite menu pour controler les entrees *

// * *

// * H.Mazelin *

// ***************************************************

//Cette bibliothèque vous permet de communiquer avec des périphériques I2C

#include <Wire.h>

//bibliothèque de gestion de l’afficheur SeeedGrayOLED.h

#include <SeeedGrayOLED.h>

// avr/pgmspace.h .Afin de Stocker les données dans la mémoire

// Flash (mémoire programme) au lieu de la mémoire SRAM

#include <avr/pgmspace.h>

//definition du numéro de la broche pour le boutons poussoirs

//correspondant

const int entree03Pin = 3;

const int entree05Pin = 5;

const int entree07Pin = 7;

const int entree09Pin = 9;

// variable pour la lecture de l'état des boutons poussoirs

int entree03State = 0;

int entree05State = 0;

int entree07State = 0;

int entree09State = 0;

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

// etc… ( void setup )

void setup()

{

Wire.begin();

//initialiser les broches des boutons-poussoirs en entrées

pinMode(entree03Pin, INPUT);

pinMode(entree05Pin, INPUT);

pinMode(entree07Pin, INPUT);

pinMode(entree09Pin, INPUT);

//initialiser l'écran OLED SEEED

SeeedGrayOled.init();

//Effacer l'écran

SeeedGrayOled.clearDisplay();

//Réglage du mode d'affichage en normal

SeeedGrayOled.setNormalDisplay();

// Passez en mode vertical pour l'affichage du texte

SeeedGrayOled.setVerticalMode();

{

//Réglez le niveau Niveaux de gris. Ne importe quel nombre entre 0-15.

SeeedGrayOled.setGrayLevel(15);

//position du curseur pour régler ligne 1, colonne 0

SeeedGrayOled.setTextXY(1,0);

// Afficher RedOhm

SeeedGrayOled.putString("RedOhm");

//position du curseur pour régler ligne 2, colonne 3

SeeedGrayOled.setTextXY(2,3);

// Afficher Bonjour

SeeedGrayOled.putString("bonjour");

//position du curseur pour régler ligne 5, colonne 3

SeeedGrayOled.setTextXY(5,0);

// Afficher Exercice

SeeedGrayOled.putString("Exercice");

//position du curseur pour régler ligne 6, colonne 5

SeeedGrayOled.setTextXY(7,5);

// Afficher N 86

SeeedGrayOled.putString("N 86");

// pause de 3 secondes

delay (3000);

//initialiser l'écran OLED SEEED

SeeedGrayOled.init();

//Effacer l'écran

SeeedGrayOled.clearDisplay();

}

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

void loop()

{

//position du curseur pour régler ligne 0, colonne 0

SeeedGrayOled.setTextXY(0,0);

// Etat entrées

SeeedGrayOled.putString("Etat entree");

// lire l'état de la valeur du bouton poussoir

entree03State = digitalRead(entree03Pin);

//vérifie si le bouton est appuyé

if (entree03State == HIGH) {

//position du curseur pour régler ligne 2, colonne 0

SeeedGrayOled.setTextXY(2,0);

// Afficher E-3 ->ON

SeeedGrayOled.putString("E-3 ->ON ");

}

else {

//position du curseur pour régler ligne 2, colonne 0

SeeedGrayOled.setTextXY(2,0);

// Afficher E-3 ->OFF

SeeedGrayOled.putString("E-3 ->OFF");

}

// lire l'état de la valeur du bouton poussoir

entree05State = digitalRead(entree05Pin);

////vérifie si le bouton est appuyé

if (entree05State == HIGH) {

//position du curseur pour régler ligne 3, colonne 0

SeeedGrayOled.setTextXY(3,0);

// Afficher E-5 ->ON

SeeedGrayOled.putString("E-5 ->ON ");

}

else {

//position du curseur pour régler ligne 3, colonne 0

SeeedGrayOled.setTextXY(3,0);

// Afficher E-5 ->OFF

SeeedGrayOled.putString("E-5 ->OFF");

}

// lire l'état de la valeur du bouton poussoir

entree07State = digitalRead(entree07Pin);

//vérifie si le bouton est appuyé

if (entree07State == HIGH) {

//position du curseur pour régler ligne 4, colonne 0

SeeedGrayOled.setTextXY(4,0);

// Afficher E-7 ->ON

SeeedGrayOled.putString("E-7 ->ON ");

}

else {

//position du curseur pour régler ligne 4, colonne 0

SeeedGrayOled.setTextXY(4,0);

// Afficher E-7 ->OFF

SeeedGrayOled.putString("E-7 ->OFF");

}

// lire l'état de la valeur du bouton poussoir

entree09State = digitalRead(entree09Pin);

//vérifie si le bouton est appuyé

if (entree09State == HIGH) {

//position du curseur pour régler ligne 5, colonne 0

SeeedGrayOled.setTextXY(5,0);

// Afficher E-9 ->ON

SeeedGrayOled.putString("E-9 ->ON ");

}

else {

//position du curseur pour régler ligne 5, colonne 0

SeeedGrayOled.setTextXY(5,0);

// Afficher E-9 ->OFF

SeeedGrayOled.putString("E-9 ->OFF");

}

***

Grove OLE42178P : Exemple 85 affichage d’un message

Positionnement d’un message puis on efface l’écran

Matériel nécessaire

– 1 Carte Arduino Mega 2560
– 1 Carte Grove Mega Shield
– 1 Afficheur Oled 96×96 OLE42178P Continuer la lecture →

Grove : Afficheur Oled 96×96 OLE42178P

***

Mise à jour le 08/03/2015

Module graphique Oled 96 x 96 points à 16 niveaux de gris compatible Grove présentant une haute luminosité, un bon contraste, un grand angle de vue et une faible consommation.

Continuer la lecture →

Grove : Capteur UV Grove 101020043

***

Mise à jour le 11/04/2016

101020043 remplace SEN00700P
Capteur UV Grove

Capteur de lumière UV compatible Grove basé sur le circuit GUVA-S12D avec une plage de 200 à 370 nm.Le module émet un signal électrique qui varie avec l’intensité du rayonnement UV

Caractéristique technique

Interface: compatible Grove
Alimentation: 5 Vcc
Plage de mesure: 200 à 370 nm
Temps de réponse: 20 à 30 s
Dimensions: 20 x 20 mm
Température de service: -30°C à +85°C
Connectique uniquement compatible avec le système Grove
Référence fabricant Seeedstudio: 101020043 (remplace SEN00700P)

Prix en général de 8 à 12€ suivant fournisseur

Quelques information supplémentaires

UV-A, UV-B , UV-C

Ces trois types de rayonnements UV sont classés en fonction de leur activité biologique et de leur pouvoir de pénétration de la peau. Ils correspondent à trois plages de longueurs d’onde. Plus le rayonnement UV a une longueur d’onde longue, moins il est nocif (il se rapproche de la lumière visible) mais plus il a un pouvoir de pénétration cutanée important. Quand sa longueur d’onde diminue, il possède plus d’énergie, se rapproche des rayons X et donc est plus destructeur.

UV-A (400-315 nm) :
Les UV-A, dont la longueur d’onde est relativement longue, représentent près de 95 % du rayonnement UV qui atteint la surface de la Terre. Ils peuvent pénétrer dans les couches profondes de la peau.

UV-B (315-280 nm) :
Les UV-B, de longueur d’onde moyenne, ont une activité biologique importante, mais ne pénètrent pas au-delà des couches superficielles de la peau, ils sont relativement absorbés par la couche cornée de l’épiderme (mélanine). Une partie des UV-B solaires sont filtrés par l’atmosphère.

UV-C (280-100 nm) :
Les UV-C, de courte longueur d’onde, sont les UV les plus énergétiques ainsi que les plus nocifs (l’énergie croît quand la longueur d’onde décroît), mais ils sont complètement filtrés par la couche d’ozone de l’atmosphère et n’atteignent donc pas théoriquement la surface de la Terre. Toutefois, des lampes UV-C sont utilisées en laboratoire de biologie pour les effets germicides, afin de stériliser des pièces ou des appareils

Exemple d’application des UV

13.5 nm: Lithographie par ultraviolets extrêmes
230-365 nm: suivi de balises sur les produits, code-barres
230-400 nm: détecteurs optiques, instrumentation diverse
240-280 nm: Désinfection, assainissement d’eau et de surfaces (son absorption par ADN atteignit son comble à 260 nm), effaceur d’EPROM
200-400 nm: Science forensique, dépistage de drogues
270-360 nm: Analyse de protéines, séquençage de l’ADN, recherches pharmaceutiques
280-400 nm: Imagerie médicale des cellules
300-320 nm: Luminothérapie
300-365 nm: Séchage de polymères d’encres
300-400 nm: Éclairage à semi-conducteurs
350-370 nm: Piège à insectes (les mouches sont attirées le plus par la longueur 365 nm)

Exemple de programme du constructeur

void setup(){
 
  Serial.begin(9600);
}

void loop()
{  
  int sensorValue;
  long  sum=0;
  for(int i=0;i&lt;1024;i++)
   {  
      sensorValue=analogRead(A0);
      sum=sensorValue+sum;
      delay(2);
   }   
 sum = sum &gt;&gt; 10;
 Serial.print("La valeur de la tension:");
 Serial.print(sum*4980.0/1023.0);
 Serial.println("mV");
 delay(20);
 Serial.print("\n");
  
}

void setup(){

Serial.begin(9600);

}

void loop()

{

int sensorValue;

long sum=0;

for(int i=0;i<1024;i++)

{

sensorValue=analogRead(A0);

sum=sensorValue+sum;

delay(2);

}

sum = sum >> 10;

Serial.print("La valeur de la tension:");

Serial.print(sum*4980.0/1023.0);

Serial.println("mV");

delay(20);

Serial.print("\n");

}

Source technique : Seedwiki ,

Grove : Capteur de température 101020015 (remplace SEN23292P)

–

Mise à jour le 28/12/2017 : Ce capteur de température compatible Grove délivre un signal analogique de 0 à 5 Vcc en fonction de la température mesurée.

Continuer la lecture →

Grove : Capteur d’humidité et de T° SEN11301P

***

Mise à jour le 28/01/2015

Ce capteur de température et d’humidité compatible Grove utilise une thermistance CTN et un capteur capacitif et délivre une sortie digitale. Il délivre les mesures de températures et d’humidité au même moment. Quand le capteur se trouve dans des conditions d’humidité relative de HR 20 % et 90 % et de température 0° C et 50° C, il donne des lectures fiables

Ne fonctionne pas en-dessous de 0°C.
Tension de travail: 3, 3V ~ 5V
Plage de mesure :
Humidité : 20 % – 90 % RH
Température: 0 ~ 50 ° C

Précision :
Humidité: ± 5 % HR
Température: ± 2 ° C
Sensibilité :
Humidité : ±1 % hr
Température : 1° C
Signal collecte période: 2 s

Source technique : Seeedwiki