Archives de l’auteur : Hervé Mazelin

Librairie Arduino Servo

Mise à jour le 13/03/2019 : Dans cette rubrique , vous allez retrouver des informations et des exemples utils pour l’utilisation de cette librairie .Celle-ci permet à une carte Arduino de contrôler des servomoteurs .

Continuer la lecture →

Librairie Arduino LiquidCrystal

***

Mise à jour le 21/03/2015

A savoir : Cette librairie permet à une carte Arduino de contrôler un afficheur LCD alphanumérique standard à cristaux liquides basé sur le circuit intégré Hitachi HD44780 (ou compatible), ce qui est le cas de la plupart des afficheurs alphanumériques LCD disponibles. La librairie fonctionne aussi bien en mode 4 bits qu’en mode 8 bits (utilisant 4 ou 8 broches numériques en plus des broches de contrôle RS, Enable et RW (optionnel)). Ainsi, en mode 4 bits, 6 broches numériques de la carte Arduino suffisent pour contrôler un afficheur LCD alphanumérique Continuer la lecture →

Poste de travail multi-écrans 12/2014

Réalisation d’un poste de travail multi screen (l’utilisation de 3 écrans individuels pour un seul ordinateur. Cela permet d’obtenir un champ de vision élargi ou multipages). Exemple d’utilisation : Ce système est particulièrement utile en développement, car il permet par exemple de coder sur un écran et de tester sur l’autre. En développement web, on peut vérifier plus facilement aussi le rendu d’une application sur des écrans différents, et/ou avec des navigateurs différents.

A savoir : Sous Windows 8, le moniteur principal et les secondaires disposent d’une barre de tâche. En mode jeu plein écran, le jeu occupe l’écran principal. Selon la résolution des jeux, il est possible de jouer sur un écran et de laisser autre chose ouvert sur l’autre. Par exemple, il est possible de jouer à un jeu sur l’écran principal et de laisser un page contenant les solutions sur l’autre. Certains logiciels permettent de choisir un fond d’écran par moniteur.

Tout d’abord vous devez disposer de minimum 3 sorties vidéo sur votre carte graphique. Chaque écran devra être raccordé sur les prises correspondantes, cela peut être à la fois deux prises DVI et une HDMI ou bien une VGA et/ou une DVI et une HDMI ou bien même deux DVI et une DP (display port). L’utilisation de prise HDMI sur PC nécessite un paramétrage de la carte graphique pour que le rendu soit optimal, les prises DVI n’ont besoin que d’une mise au point de la résolution

DVI : La spécification DVI analogique est compatible avec l’interface VGA, Cette compatibilité, associée aux autres avantages du DVI
DVI-A (DVI-Analog) qui transmet uniquement le signal analogique .
DVI-D (DVI-Digital), en lien simple ou double, qui transmet uniquement le signal numérique.

DVI-D RedOhm

DVI-I (DVI-Integrated), en lien simple ou double, qui transmet (sur des broches séparées) soit le signal numérique du DVI-D, soit le signal analogique du DVI-A (un seul type de signal selon ce qui est branché, sans faire de conversion de l’un vers l’autre).

DVI-I RedOhm

HDMI : Le High Définition MultiMedia Interface (HDMI) (en français, « Interface Multimédia Haute Définition ») est une norme et interface audio/vidéo totalement numérique pour transmettre des flux chiffrés, généralement non compressés et destinée au marché grand public. Le HDMI permet de relier une source audio/vidéo DRM – comme un lecteur Blu-ray, un ordinateur ou une console de jeu (source Wikipédia)

Prise HDMI

DP : DisplayPort est une interface numérique pour écran mise en place par le consortium « Vidéo Electronics Standards Association (VESA). Il définit une nouvelle interconnexion numérique audio/vidéo, sans droit ni licence. Celle-ci est d’abord conçue pour relier un ordinateur à ses moniteurs, ou un ordinateur et un système de home cinéma (source Wikipédia).

Prise DP

VGA : Un connecteur VGA est un connecteur de type D-sub, plus précisément DE-15. Il est utilisé pour connecter une carte graphique à un écran d’ordinateur en analogique. Ce connecteur est parfois appelé connecteur RGB, HD-15 ou D-sub 15. Il possède 15 broches organisées en trois rangées. Ce connecteur existe en deux générations.

PRISE VGA

Avec les carte graphique AMD il est obligatoire aux delà de deux écrans de mettre une prise DP active pour que les écrans puissent être étendu au-delà de 2, sinon votre troisième écran restera désespérément noir. En revanche Les cartes Nvidia n’ont aucune restriction ni besoin de prise active

Arrière de la Nvidia Geforce GTX670

Vue complète de la Nvidia Geforce GTX670

Attention toutefois les prise display port ressemble aux prises HDMI, sauf que celles-ci ont un côté comme les prises USB

Vous devez être aussi équipe de carte graphique pouvant gérer l’affichage en 5760×1080 . Il faut donc utiliser au minimum une carte d’entrée de gamme de version R7 270 Ou GTX 670 équivalent ou supérieur.

Assurez-vous d’acheter des écrans compatibles avec la connectique dont vous disposez sur votre ordinateur.

Depuis la nouvelle version de carte graphique R7, R9 il est désormais possible de connecter jusqu’à 3 écrans sans avoir besoin de câble actif

Assurez-vous d’avoir une alimentation suffisamment calibrée pour accepter les dernières carte graphiques et le tour est joué.

Auteur : RedOhm/Sullivan . Hervé

Les librairies Arduino

***

Mise à jour le 07/04/2015

Les bibliothèques sont un ensemble de codes qui vous permettent d’utiliser des fonctions élaborées de votre carte Arduino. Ces programmes spécialisés se trouvent dans le répertoire librairie du dossier Arduino .
Les fonctions sont disponible après son importation depuis l’IDE .

D’où une notion de « Classe »
On appelle « Classe » un regroupement de fonctions

Continuer la lecture →

Arduino Mega 2560 Rev3

–

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

Album photo complet du projet Inmoov-renaissance

Redohm vous présente l’album de photos du projet Inmoov-renaissance à ce jour

Diaporama

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

}