Arduino, c’est quoi ?

Récemment, on m’a dit à propos d’un article précédent : “C’est sympa mais pour moi c’est du chinois !”

Donc, je vais reprendre les bases.

Arduino, c’est quoi?

Wikipédia répond précisément à cette question.

Arduino

Arduino est un circuit imprimé en matériel libre sur lequel se trouve un microcontrôleur qui peut être programmé pour analyser et produire des signaux électriques, de manière à effectuer des tâches très diverses comme la domotique, le pilotage d’un robot, etc. …
http://fr.wikipedia.org/wiki/Arduino

Arduino Uno révision 3

Ce qu’il faut savoir en bref : c’est un circuit imprimé programmable, qui possède plusieurs entrées/sorties (pins) sur lesquelles l’Arduino peut lire ou écrire des données électriques.

Ce circuit est en matériel libre, c’est à dire en résumé que ses plans de fabrication sont rendus publics et leur utilisation est libre sans avoir à verser de droits.
Chacun peut acheter les composants nécessaires et monter lui-même sa puce de type Arduino.

L’arduino montré en exemple ici est un Arduino Uno (rév 3) officiel, qui coûte 20€ sur le store arduino hors frais d’envois (hors-stock au moment où j’écris).

Les chinois ont bien exploité le côté matériel libre (open hardware) et produisent en masse des clones d’Arduino, beaucoup moins chers du fait de leur production massive.
On parle ici de clones et non pas de contrefaçons, car le matériel est à peu près identique à l’original, mais le nom “Arduino” n’est pas utilisé. C’est donc tout à fait autorisé.

Par exemple sur AliExpress on trouve des clones d’Arduino Uno pour moins de 3€, avec la livraison gratuite (mais comptez 3 semaines de livraison) :

UNO R3 MEGA328P CH340G Arduino Compatible

Ce modèle est parfait pour commencer car il n’est vraiment pas cher, et demeure polyvalent.

C’est donc le modèle que j’ai choisi pour me plonger dans cet univers !
Pour le relier à l’ordinateur, on a besoin d’un câble USB “carré”, identique à celui souvent utilisé pour les imprimantes.

Comment programmer un Arduino ?

Les gens de chez Arduino ont mis à disposition le logiciel de référence pour programmer son Arduino, il s’agit de Arduino IDE. => http://www.arduino.cc/en/Main/Software

Pour mes tests ici sur un Windows XP, je vais installer la version 1.6.4 de l’IDE (windows installer).

Notez que les drivers fournis par défaut avec l’IDE Arduino, sous Windows XP, ne reconnaissent pas mon clone Arduino Uno.

J’ai donc eu besoin d’installer ce driver : http://www.wch.cn/download/CH341SER_EXE.html

Une fois les drivers installés avec succès, la carte est reconnue et on peut commencer à l’utiliser avec le logiciel.

Il faut d’abord sélectionner le type de carte utilisé dans Outils > Type de carte

Puis choisir le port COM qui a été assigné à la carte lors de l’installation du driver :

Nous sommes prêts à commencer.

Pour un premier test, l’exemple “blink” sera utilisé.

Chargez cet exemple via Fichier > Exemples > 01.Basics > Blink

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.
 
  This example code is in the public domain.
 */
 
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}

Ce code (dans le monde Arduino on appelle cela un Sketch) va envoyer à intervalle régulier un signal sur le port 13 de la carte, afin d’allumer et éteindre une LED.

Il vous faudra donc faire un montage rapide avec un LED, et une résistance (valeur entre 220 ohms et 1 Kohm)

Montage “blink led”

Dans l’IDE Arduino, appuyez sur le deuxième bouton (Téléverser) afin de compiler le sketch et de l’envoyer sur notre carte.

Après avoir rebooté, la carte doit maintenant suivre le “loop” du programme, et allumer puis éteindre la LED à chaque fois avec une seconde d’intervalle !

_{illustration article (c) http://creativity103.com/} 

Arduino, DHT22 et écran OLED 128*64

Capteur de température et humidité, avec affichage sur un petit écran LCD.

Suite à mon article précédent sur l’écran OLED 0,96″ 128*64, j’ai ajouté sur mon Uno une sonde DHT22 afin de faire des relevés de température et d’humidité, puis de les afficher sur le petit écran.

L’afficheur OLED possède 4 connecteurs :

1. VCC
2. GND
3. SCL
4. SDA

Pour la sonde de température et humidité :

1. + (positif)
2. out (données)
3. – (négatif)

Aussi bien le DHT22 que l’afficheur peuvent être alimentés en 3,3V comme en 5V, on a donc le choix avec l’Uno qui possède deux connecteurs 5V et un 3,3V !

J’ai donc connecté l’afficheur ainsi :

• VCC sur 3,3V
• GND sur GND
• SCL sur SCL
• SDA sur SDA

Pour la sonde :

• + sur 5V
• – sur GND
• out sur le port 6

Résultat, presque bien :

Ah, l’UTF-8 vient nous embêter même ici 🙂

Une solution est de remplacer dans le code les caractères non standards (comme les accents, ou le signe “degré”) par leur code hexadécimal, comme indiqué dans le tableau suivant.

Pour obtenir “é” on prend donc l’avant-dernière ligne, puis on commence à 0xe0, puis on compte de 0 à 9 puis A à F (c’est de l’hexadécimal…) ce qui nous donne Oxe9.

La ligne suivante :

u8g.print("Humidité: " + String(charhumidite) + "%");

va devenir :

u8g.print("Humidit" "\xe9" ": " + String(charhumidite) + "%");

Une autre solution est de recompiler l’IDE Arduino en mode UTF-8. Un peu moins évident…

Voici le code modifié :

#include "U8glib.h"
#include <dht.h>

U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NO_ACK);

dht DHT;
float temperature;
float humidite;

#define DHT22_PIN 6

void draw(float temperature, float humidite) {
  char chartemperature[10];
  char charhumidite[10];
  u8g.setFont(u8g_font_unifont);
  dtostrf(temperature, 4, 1, chartemperature);
  dtostrf(humidite, 4, 1, charhumidite);

  u8g.setPrintPos(0, 22);
  u8g.print("Temp. : " + String(chartemperature) + "\xb0" "C");
  u8g.setPrintPos(0, 44);
  u8g.print("Humidit" "\xe9" ": " + String(charhumidite) + "%");
}

void setup(void) {
  // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 ) {
    u8g.setColorIndex(255);     // white
  }
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) {
    u8g.setColorIndex(3);         // max intensity
  }
  else if ( u8g.getMode() == U8G_MODE_BW ) {
    u8g.setColorIndex(1);         // pixel on
  }
  else if ( u8g.getMode() == U8G_MODE_HICOLOR ) {
    u8g.setHiColorByRGB(255,255,255);
  }
}

void loop(void) {
  int chk = DHT.read22(DHT22_PIN);
  // READ DATA
  humidite = DHT.humidity;
  temperature = DHT.temperature;

  delay(1000);
  u8g.firstPage();  
  do {
    draw(temperature, humidite);
  } while( u8g.nextPage() );
  
  // rebuild the picture after some delay
  delay(50);
}

Si vous voulez le commander :
Ecran OLED 0.96″ 128X64 blanc pour Arduino

DHT22 Digital Temperature and Humidity Sensor AM2302 Module+PCB with Cable

Ecran OLED 128×64 0,96″ pour Arduino

Aujourd’hui j’ai reçu un petit écran OLED pour Arduino :

Ecran OLED 0.96″ 128X64 blanc pour Arduino

Il s’agit donc d’un petit écran d’une résolution de 128 pixels de large par 64 pixels de haut, qui peut être suffisant pour certaines applications. Aussi, la technologie OLED est la plus confortable car chaque pixel est sa propre source de lumière, il n’y a donc pas de rétro-éclairage nécessaire.

J’ai utilisé la librairie U8Glib qui semble etre la plus simple:

https://github.com/olikraus/u8glib

Pour le câblage:

VCC sur 3.3V
GND sur GND
SCL sur SCL
SDA sur SDA

Simple, n’est-ce pas ?

Sketch utilisé pour cette démo:

#include "U8glib.h"
U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NO_ACK);  // Identifier for this display board

void draw(void) {
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  //u8g.setFont(u8g_font_osb21);
  u8g.drawStr( 0, 22, "Hello World!");
}

void setup(void) {
  // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 ) {
    u8g.setColorIndex(255);     // white
  }
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) {
    u8g.setColorIndex(3);         // max intensity
  }
  else if ( u8g.getMode() == U8G_MODE_BW ) {
    u8g.setColorIndex(1);         // pixel on
  }
  else if ( u8g.getMode() == U8G_MODE_HICOLOR ) {
    u8g.setHiColorByRGB(255,255,255);
  }
}

void loop(void) {
  // picture loop
  u8g.firstPage();  
  do {
    draw();
  } while( u8g.nextPage() );
  
  // rebuild the picture after some delay
  delay(50);
}

Et voilà !

ESP8266 and Arduino IDE – blink example

Cet article sur iot-playground.com explique comment programmer un ESP8266 directement à partir de l’IDE Arduino :

⇒http://iot-playground.com/2-uncategorised/38-esp8266-and-arduino-ide-blink-example

Il s’agit d’utiliser une version modifiée de l’IDE Arduino, disponible ici https://github.com/esp8266/arduino, qui permet de compiler et envoyer le code directement sur l’ESP8266 en passant par un module FT232RL (USB vers série).

Branchement : comme ci-dessous, mais sans brancher GPIO 0, qui ne sert que lorsque l’on veut flasher le firmware de l’ESP.

Si vous êtes sous Windows ou Mac, vous pouvez télécharger la version déjà compilée pour votre système à cette adresse https://github.com/esp8266/Arduino/releases (pour mes tests, il s’agit du fichier pour windows).

La version compilée n’étant plus présente sur la page GitHub du projet, voici celle que j’ai utilisée (Version 1.6.1) : https://www.dropbox.com/s/7yqvvbwiy0ovnsk/arduino-1.6.1-windows.zip?dl=0

Une fois décompressé, executez “Arduino.exe”, et vous voilà dans la version spéciale ESP8266 de l’IDE ARduino !

Il faut cependant encore faire quelques réglages : sélectionnez le bon port COM(Tools->Port) puis le bon programmeur (Tools->Programmer->esptool)

et enfin sélectionner le type de carte (Tools->Board->Generic ESP8266 Board)

Pour la suite, chargons le même exemple que dans l’article précédent Arduino, c’est quoi ? en remplaçant PIN 13 par PIN 2 qui est PIN02 sur les entrées/sorties GPIO de l’ESP8266.

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.
 
  This example code is in the public domain.
 */
 
// indication de PIN 2 pour connexion de la LED.
int led = 2;

// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}

Enfin, le montage avec la LED :

ESP8266 serial WIFI wireless module wireless transceiver (ESP-01)

FT232RL FTDI USB to TTL Serial Adapter Module for Arduino