Archives de catégorie : Hardware/Software

–

Mise à jour le 20/10/2017 . Dans cet article vous trouverez les caractéristiques principales de la carte Arduino Mega 2560 , ainsi que les cartes additives de différents constructeurs pour son utilisation .

Continuer la lecture →

Télémètre laser Lidar

Sommaire :

Presentation du laser lidar
Différents types de matériels
- Capteur de Distance Laser LIDAR-Lite
- Capteur Laser LIDAR-Lite 3
- Capteur de Distance à Balayage Laser URG-04LX-UG01 Hokuyo
Pour tout probléme
Retour au menu tutoriel

Son fonctionnement est le même que celui du radar, la différence étant le domaine spectral dans lequel il travaille et le type de faisceau utilisé : alors que le radar fonctionne dans le domaine des ondes radio, le lidar couvre en particulier le domaine du visible, et également les domaines ultraviolet (UV) et infrarouge (IR), d’autre part, le lidar utilise un faisceau laser, tandis que le radar utilise un faisceau électromagnétique classique, non polarisé.

Un lidar se compose d’un système laser chargé d’émettre l’onde lumineuse, d’un télescope qui récoltera l’onde rétrodiffusée par les particules rencontrées, et d’une chaîne de traitement qui quantifiera le signal reçu.

Le principe de la télémétrie (détermination de la distance d’un objet), qui concerne une grande partie des applications du lidar, requiert généralement l’utilisation d’un laser impulsionnel. La distance est donnée par la mesure du délai entre l’émission d’une impulsion et la détection d’une impulsion réfléchie, connaissant la vitesse de la lumière.

Retour au sommaire

Différents types de matériels

Capteur de Distance Laser LIDAR-Lite

Capteur optique de mesure de distance compact et de haute performance

Signal détectable minimum : 1 nW – 256 rafales intégrées
Puissance de transmission (laser) : 1,5 W en crête à entraînement de 3 A
Alimentation : de 4,75 à 5,5 VCC (nominal), 6 VCC (maximum)

Information technique sur ce matériel

Retour au menu tutoriel

Retour au sommaire

Capteur de Distance Laser LIDAR-Lite 3

Module laser LIDAR-Lite V3 de Garmin permettant de mesurer des distances de 0 à 40 m. Ce module communique avec un microcontrôleur type Arduino via une liaison PWM ou I2C.

Il est paramétrable pour obtenir un compromis entre précision, plage de mesure et temps d’acquisition. Il est compact, léger et économe en énergie. Applications: drones, robots, modélisme, etc.

Remarque: ce module utilise un laser de Classe 1, sans danger dans des conditions d’utilisation normales. Il est cependant recommandé de ne pas regarder directement le capteur de face.

Cartographie 3D d’une pièce à l’aide d’un LIDAR-Lite v3 en rotation

Documentation constructeur Garmin

Capteur de Distance à Balayage Laser URG-04LX-UG01 Hokuyo

est un scanner laser petit, abordable et précis qui est parfait pour les applications robotiques. Le URG-04LX-UG01 est capable d’indiquer la distance de 20 mm à 5600 mm (résolution 1 mm) dans un arc de 240º (résolution angulaire 0,36º). Sa consommation énergétique, 5 V 500 ma, lui permet d’être utilisé sur des plateformes alimentées par batterie. Il est idéal pour les étudiants et les chercheurs en robotique.

LASER LIDAR URG-04LX-UG01 Hokuyo

La portée de détection URG-04LX-UG01 d’Hokuyo est de 20 mm à 5600 mm.
– 100 m sec/balayage
– Tension de fonctionnement 5 V
– Portée de balayage 240° avec résolution angulaire de 0,36°

Constructeur : Hokuyo
Logiciel : Logiciels et pilotes Hokuyo

Retour au sommaire

Pour tout problème

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 en haut de page

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 ,

Documentation carte SaberTooth 2 x 60

Mise à jour le 08/01/2015

SaberTooth 2x60A - REDOHM - 001

– La carte SaberTooth 2 x 60 est idéale pour les commandes différentielles de robots, les tanks, voitures et bateaux, etc. Elle convient pour des poids de 450 kg (55 kg pour des robots de combat). La commande des deux moteurs CC à balais peut se faire à l’aide d’une tension analogique, d’un signal RC ou d’un signal série.

La carte SaberTooth possède des modes indépendants pour la vitesse et la direction, facilitant la commande différentielle. Lors de chaque ralentissement ou changement de sens de rotation du moteur, la carte recharge la batterie, permettant une autonomie accrue du robot.
Elle autorise les brusques changements de direction et les arrêts rapides. Une sortie 5 Vcc est disponible pour alimenter un microcontrôleur ou un récepteur RC.

Ce type de carte est utilisé dans notre châssis LL-1.01 , HM-3.10.

Caractéristiques:

Alimentation: 6 à 30 Vcc (NiCd, NiMh, Lithium, accu au plomb)
Cette carte ne peut pas être alimentée par une alimentation secteur.
Courant de sortie: 2 x 60 A en continu (2 x 120 A en pointe)
Signal de commande:
– tension analogique 0 à 5 Vcc
– signal radio RC
– liaison série
Indication de statut par Leds
Protection thermique et contre les surcharges
Dimensions: 89 x 76 x 47 mm
Poids: 250 gr

Le mode de fonctionnement se sélectionne avec les interrupteurs DIP présent sur la carte. Les modes de fonctionnement sont : tension analogique de 0 à 5 Vcc, signal radio RC venant d’une télécommande ou une liaison série
La carte Sabertooth est le premier pilote moteur synchrone régénératrice dans sa catégorie. Le fonctionnement régénératrice signifie que vos batteries sont rechargées à chaque fois que vous ralentissez ou vous changez de sens de déplacement. La carte vous permet également de faire des arrêts très rapides.
La carte peut alimenter en 5V votre récepteur RC ou votre carte microcontrôleur.
Les transistors de la carte sont commutés à une vitesse 24kHz pour un fonctionnement silencieux.

Fabricant: Dimension Engineering