PHM ARDUINO

Nous sommes le 14-11-2018 et il est 02:24
Dernière mise à jour du site le : 12-12-2015

Introduction

Vous trouverez d'autres articles PHMARDUINO ICI

Vous trouverez le site officiel Arduino ICI

Les schémas des montages ont été réalisés avec le logiciel gratuit Fritzing que vous pouvez télécharger ICI

Vous trouverez sur ce site quelques exemples très simples de mise en œuvre de l'Arduino UNO et de l'Arduino Ethernet sous Windows.

Caractéristiques techniques Arduino UNO:

Micro contrôleurATmega328
Tension de fonctionnement5V
Tension d'alimentation recommandée7 à 12V
Tension d'alimentation limite6 à 20 V
Entrées/sorties numériques14 dont 6 disposent d'une sortie PWM
Entrées analogiques 6 (ATTENTION : le niveau max en entrée doit être de 5 volts)
Courant max par broches E/S40 mA (ATTENTION : 200 mA cumulé pour l'ensemble des broches E/S)
Courant max sur sortie 3,3 V générée par le régulateur interne50 mA
Mémoire Flash 32 KB dont 0.5 KB utilisée par le bootloader
Mémoire SRAM 2 KB
Mémoire EEPROM 1 KB
Fréquence horloge 16 MHz

L’arduino UNO sait gérer des communications de type série RS232 ou I²C (Inter Integrated Circuit), le PWM (Pulse Width modulation), le SPI (Serial Peripheral Interface) et possède deux entrées d'interruption externes.

Installation

Attention, tous les exemples présentés sur ce site ont été réalisés avec la version 1.0 de l'environnement de développement Arduino.

Premiers exemples de réalisations avec l'Arduino

Description du matériel nécessaire

Vous trouverez ci-dessous un tableau de consolidation des principaux composants nécessaires pour ces premières réalisations avec des exemples de fournisseurs et de références :

ComposantPhotoExemple de fournisseurRéférence
Arduino UnoArduino UnoSnootlab
Afficheur LCD 2*16 caractèresSélectronic
Capteur de température LM35 DZLM35Sélectronic

Description des exemples

EX01 : Faire clignoter une LED (Diode Émettrice de Lumière)

EX01a : Avec juste un Arduino UNO sans matériel supplémentaire

Ce premier test permet de vérifier très rapidement en quelques minutes que l'Arduino fonctionne bien en faisant clignoter la LED branchée sur la patte 13 et montée en standard sur la carte Arduino.

Code du programme Arduino :

/* 
Objet : Clignotement de la LED présente sur l'Arduino en série
Nom : phm_blink.ino
Infos sketch : Créé en 2011 le 26 octobre par PHM
 */

// Définition patte de l'arduino sur laquelle est connectée la LED
const int patteLED =  13; // La patte de l'arduino avec la LED est la 13

void setup() {
  // On positionne la patte 13 de l'arduino en sortie
  pinMode(patteLED, OUTPUT);
}

void loop()
{

// On allume et on éteint alternativement la LED sur la patte 13
   digitalWrite(patteLED, HIGH);
   delay(500);
   digitalWrite(patteLED, LOW);
   delay(1000);
  
}



Video du montage :

A compléter

EX01b : Avec une plaque d'essai, une LED et une résistance

Afin de limiter le courant en sortie de l'Arduino, il est nécessaire d'insérer en série avec la LED une résistance. La LED nécessite un courant d'environ 10 mA minimum pour briller correctement. Comme la tension en sortie de l'Arduino est de 5 Volts et que la chute de tension aux bornes de la LED est de 2 Volts, la valeur de la résistance doit être environ de (5-2)/0.01 soit 300 Ohms en théorie. La valeur de résistance normalisée la plus proche est de 270 Ohms.

Pour plus d'informations sur les LED, se reporter au chapitre présentant des bases sur l'électronique.

A compléter

EX02 : Faire un chenillard avec 5 LED

Photo du montage

Arduino Uno Serial

Code du programme Arduino

/*
  Sketch : phm_chenillard.ino
  Auteur : PHMARDUINO
  Date création : 21 12 2012
  Date dernière modification : so
  Description : Chenillard avec 5 Leds et aller retour
 */
 
// 5 leds sont connectées en sortie de l'Arduino sur les sorties 5,6,7,8 et 9
int led1 = 5;
int led2 = 6;
int led3 = 7;
int led4 = 8;
int led5 = 9;

// Initialisations
void setup() {                
  // Init des sorties 
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(led5, OUTPUT);  
}

// Boucle infinie
void loop() {
  // Allumage Aller
  digitalWrite(led1, HIGH);   // allume led1
  delay(100);                 // attente 0,1 seconde
  digitalWrite(led1, LOW);    // extinction led1
  delay(10);                  // attente 0,01 seconde
  digitalWrite(led2, HIGH);   // allume led2
  delay(100);                 // attente 0,1 seconde
  digitalWrite(led2, LOW);    // extinction led2
  delay(10);                  // attente 0,01 seconde
  digitalWrite(led3, HIGH);   // allume led3
  delay(100);                 // attente 0,1 seconde
  digitalWrite(led3, LOW);    // extinction led3
  delay(10);                  // attente 0,01 seconde
  digitalWrite(led4, HIGH);   // allume led4
  delay(100);                 // attente 0,1 seconde
  digitalWrite(led4, LOW);    // extinction led4
  delay(10);                  // attente 0,01 seconde
  digitalWrite(led5, HIGH);   // allume led5
  delay(100);                 // attente 0,1 seconde
  digitalWrite(led5, LOW);    // extinction led5
  delay(100);                 // attente 0,1 seconde
  
  //Allumage puis extinction de toutes les LEDs avant retour
  digitalWrite(led1, HIGH);   // allume led1
  digitalWrite(led2, HIGH);   // allume led2
  digitalWrite(led3, HIGH);   // allume led3
  digitalWrite(led4, HIGH);   // allume led4
  digitalWrite(led5, HIGH);   // allume led5
  delay(1000);                // attente 1 seconde  
  digitalWrite(led1, LOW);    // extinction led1
  digitalWrite(led2, LOW);    // extinction led2
  digitalWrite(led3, LOW);    // extinction led3
  digitalWrite(led4, LOW);    // extinction led4
  digitalWrite(led5, LOW);    // extinction led5
  delay(1000);                // attente 1 seconde  
    
  // Allumages Retour
  digitalWrite(led4, HIGH);   // allume led4
  delay(100);                 // attente 0,1 seconde
  digitalWrite(led4, LOW);    // extinction led4
  delay(10);                  // attente 0,01 seconde
  digitalWrite(led3, HIGH);   // allume led3
  delay(100);                 // attente 0,1 seconde
  digitalWrite(led3, LOW);    // extinction led3
  delay(10);                  // attente 0,01 seconde
  digitalWrite(led2, HIGH);   // allume led2
  delay(100);                 // attente 0,1 seconde
  digitalWrite(led2, LOW);    // extinction led2
  delay(10);                  // attente 0,01 seconde
  digitalWrite(led1, HIGH);   // allume led1
  delay(100);                 // attente 0,1 seconde
  digitalWrite(led1, LOW);    // extinction led1

}

Video du montage

A compléter

EX03 : Lire une valeur binaire (0 ou 1) fournie par un bouton poussoir

A compléter

EX04 : Lire une valeur analogique variable grâce à un potentiomètre

A compléter

EX05 : Réalisation d'un chenillard commandé à l'aide d'un bouton poussoir

Nous allons maintenant mettre en œuvre les trois exemples précédents combinés pour commander un chenillard à l'aide :

A compléter

EX06 : Commande d'un moteur pas à pas

A compléter

EX07 : Mise en œuvre de l'interface série Arduino-PC

Cet exemple reprend l'exemple EX01 d'Allumage/Extinction d'une LED avec en plus écriture sur le port série de la commande Allumage ou Extinction. Ces messages série peuvent être visualisés dans la console de l'IDE Arduino comme dans l'impression d'écran ci-dessous :

Visualisation sortie série :

Arduino Uno Serial
Code du programme Arduino :

/* 
Objet : Clignotement de la LED présente sur l'Arduino en série
Nom : phm_blink_serial.ino
Infos sketch : Créé en 2011 le 26 octobre par PHM
 */

// Définition patte de l'arduino sur laquelle est connectée la LED
const int patteLED =  13; // La patte de l'arduino avec la LED est la 13

void setup() {
  // On positionne la patte 13 de l'arduino en sortie
  pinMode(patteLED, OUTPUT);
  //initialisation de la liaison série à 9 600 bauds
  Serial.begin(9600);
}

void loop()
{

// On allume et on éteint alternativement la LED sur la patte 13
   digitalWrite(patteLED, HIGH);
   Serial.println ("Allumage de la LED"); //Ecriture sur la sortie série avec un saut de ligne
   delay(2000);
   Serial.println ("Extinction de la LED"); //Ecriture sur la sortie série avec un saut de ligne
   digitalWrite(patteLED, LOW);
   delay(2000);
  
}

EX08 : Affichage sur un écran LCD

A compléter

EX09 : Utilisation d'une horloge temps réel avec le DS1307

A compléter

EX 10 : Interfaçage avec un appareil MIDI (Piano numérique par exemple)

A compléter

EX11 : Interfaçage avec un MINITEL

A compléter

Exemples de réalisations utilisant des capteurs

EX12 : Mesure de température

Introduction

Ce montage permet par exemple de mesurer en continu très simplement la température à l'intérieur d'une pièce. Les résultats sont transmis par l'Arduino au PC via l'interface série puis affichés dans la console Arduino.

Composants utilisés

ComposantPhotoExemple de fournisseurRéférence
Arduino UnoArduino UnoSnootlab
Capteur de température LM35 DZLM35Sélectronic

Le capteur retenu pour ce montage permettant la mesure de température est le LM35 DZ car il est très simple à mettre en oeuvre, il est étalonné directement en usine et ne coûte pas très cher (environ 3 euros).

Il permet de faire des mesures de températures assez précises (+/- 0.5 degré) de 0 à 100 degrés.

Il fournit une tension proportionnelle à la température mesurée. Celle-ci augmente de 10 mV par degré : Il fournit 0 V pour 0 degré, 250 mV pour 25 degrés, etc. et un maximum de 1 volt pour 100 degrés.

Le brochage du LM35 DZ est le suivant :

Vue de dessous : LM35 Vue de face : LM35

BrochesDésignation
VSAlimentation du capteur
OUTSortie proportionnelle à la température
GNDMasse du capteur


D'autres versions du LM35 sont disponibles et en particulier les suivantes :
- LM35AH : boitier métal TO46, plage -55 °C à +150 °C
- LM35CZ : boitier plastique TO92, plage -40 °C à +100 °C

Si vous souhaitez plus d'informations sur les capteurs de température LM35, vous pouvez vous reporter au datasheet complet sur le site du constructeur ICI.

Schémas montage

LM35

Code du programme Arduino

//////////////////////////////////////////////////////
// Objet  : Mesure de temperature avec un LM35 DZ    //
// lm35_phm_temperature.ino                          //
// Auteur : PHM                                      //
// Date création : Le 10 juin 2011                   //
// Date dernière mise à jour : Le 27 juin 2011       //
///////////////////////////////////////////////////////

//Déclaration et initialisation des variables
  float mesure=0;        //Variable pour le stockage mesure retournée par le capteur
  float tension=0;       //Variable pour le stockage de la tension 
  float temperature=0;   //Variable pour le stockage de la température 
  float tempmin=100;     //Temperature min
  float tempmax=0;       //Temperature max
  int portana0 = 0;      //Numéro du port analogique sur lequel la température est mesurée

//Traitements initialisation
  void setup()
  {
    analogReference(INTERNAL); //Permet de fixer la temperature de refernce à 1,1 volt
    Serial.begin(9600);        //initialisation de la liaison série à 9 600 bauds
  }

//Traitements itératifs
  void loop()
  {
    mesure = analogRead(portana0);  //Lecture de la valeur fournie par le capteur de température
    tension = mesure * 1.1 / 1024;  //Conversion en tension (en volt)
    
    temperature = tension * 100;    //Conversion en température (en degré Celsius)
    if (temperature < tempmin) {tempmin = temperature;} //Calcul temperature mini
    if (temperature > tempmax) {tempmax = temperature;} //Calcul temperature maxi
    
    //Envoi de la tension et des températures au PC par la liaison série pour affichage dans la console
    Serial.print("Tension : "); Serial.print (tension); Serial.print(" Volts - ");         
    Serial.print("Temperatures :"); 
    Serial.print(" >Actuelle : "); Serial.print (temperature); 
    Serial.print(" >Mini : "); Serial.print (tempmin); 
    Serial.print (" >Max : "); Serial.println (tempmax);
    //Attente de 5 secondes avant de faire une nouvelle mesure
    delay(5000);                    
  }
  
  


Précisions sur le code

Par défaut la tension de référence utilisée par les convertisseurs analogique-numérique de l'Arduino est de 5 volts. Comme la tension maximale délivrée par le LM35 DZ n'est que de 1 volt nous utilisons l'instruction analogReference(INTERNAL) permettant d'optimiser les mesures grâce à une tension de référence de 1.1 volt au lieu de la tension de référence par défaut de 5 volts.

Ainsi pour la tension maximale en entrée de 1 volt, le convertisseur fournira une valeur en sortie de 1 V * 1024 / 1.1 v soit 931 alors que si nous avions gardé la tension de référence par défaut de 5 volt, nous n'aurions eu en sortie que 1 v * 1024 / 5 v soit 205. Un incrément de 1 fourni par le convertisseur correspond à 1.1 V / 1024 volt soit environ 1 mV au lieu de 5 V / 1024 soit environ 41 mV. La résolution est donc ainsi bien meilleure (multipliée par environ 40).

Les paramètres utilisables avec l'instruction analogReference(INTERNAL) sont les suivants :
- DEFAULT : La tension de référence est de 5 volts
- INTERNAL : La tension de référence est de 1.1 volts
- EXTERNAL : La tension de référence est celle appliquée sur la patte AREF de l'Arduino

Photo du montage

A compléter

LM35 Console

Résultats obtenus dans la console

LM35 Console

Vidéo du montage

A compléter

EX13 : Mesure de pression atmosphérique avec le BMP085

A compléter

EX14 : Mesure d'intensité lumineuse avec une LDR

Une LDR (Light Dependent Resistor) appelée parfois photorésistance est une résistance dont la valeur varie en fonction de la lumière. Sa résistance peut passer par exemple de 10 k Ohms en pleine lumière à 2 M Ohms dans l'obscurité.

Par exemple les valeurs de la résistance utilisée dans le montage en fonction de l'éclairage sont :

Schémas montage


Montage LDR

A compléter

EX15 : Utilisation d'un capteur infrarouge

Ce montage va permettre de décoder des émissions infrarouge en provenance de télécommandes par exemple.

Composants utilisés

Nous utilisons le capteur/décodeur HIM 602 infrarouge 940 nm de chez Farnell qui transmets le signal sous forme numérique à l'Arduino. Le capteur envoie des impulsions à la fréquence de 38 Khz. Un bit à un est signalé par un signal carré de 38 kHz et un bit à zéro par l'absence de signal. Il est possible d'utiliser aussi les capteurs infrarouge TSOP4838, PNA4602 ou TSOP2438 (Attention aux brochages qui peuvent être différents).

Montage

La patte 3 est reliée au +5 Volt, la patte 2 à la masse et la dernière patte, la 1 à une des entrées numériques de l'Arduino.

Code du programme Arduino :

Nous allons utiliser la bibliothèque de Ken SHIRIFF que vous pouvez télécharger ici. Le fichier IRRemote.zip doit être décompressé dans le répertoire c:\Program Files\Arduino\Arduino-022\hardware\libraries >>>> à revoir avec la nouvelle version 1.0. Il est possible d'utiliser la librairie IRemote.h ????

A compléter

Exemples de réalisations utilisant une connexion avec internet

Introduction

L'Arduino que nous allons utiliser dans les exemples internet n'est plus l'Arduino Uno mais l'Arduino Ethernet ci-dessous qui comporte une prise RJ45 permettant de le relier à une BOX par exemple :

Arduino Ethernet

L'Arduino peut être utilisé soit comme client WEB soit comme serveur WEB.

Dans les deux cas le programme transféré dans l'Arduino doit être en mesure d'écrire et de décoder des requêtes WEB à savoir HTTP qui est le protocole standard utilisé entre autres par les navigateurs WEB.

Par ailleurs, la carte Arduino Ethernet embarque un lecteur de carte micro SD qui peut être très intéressant par exemple pour stocker un site WEB ou pour enregistrer des données comme un historique de températures.

Pour les débutants, vous trouverez ci-dessous quelques notions de base sur le modèle de réseau classique TCP/IP utilisé ainsi que des éléments de base sur le HTML qui est utilisé pour l'écriture des pages WEB.

Le réseau TCP/IP est composé des 4 couches suivantes :

Couches du modèle TCP/IP
Couche Application (Browser WEB par exemple utilisant le protocole HTTP)
Couche Transport (utilisant par exemple soit le protocole TCP , soit le protocole UDP)
Couche réseau Internet (utilisant le protocole IP)
Couche Accès réseau (utilisant le protocole Ethernet par exemple)

Ethernet

Tous les appareils connectés à un réseau ont au moins une adresse MAC (Media Access Control) appelée aussi adresse physique permettant de les identifier de manière unique sur le réseau. Un PC qui a par exemple une carte réseau et une carte WIFI aura deux adresses MAC, une pour chaque interface réseau. Ces adresses MAC sont attribuées par les constructeurs aux équipements réseau. Les adresses MAC sont constituées de six octets de la manière suivante par exemple : 11:02:01:ad:cb:22

L'Arduino Ethernet qui embarque une puce réseau a donc une adresse MAC qui doit être indiquée dans les scripts Arduino lorsque l'on utilise les fonctions Ethernet.

Dans vos scripts Arduino, il faudra donc remplacer l'adresse MAC présente dans les exemples par celle indiquée sur une étiquette blanche collée sur votre Arduino Ethernet. A défaut vous pouvez utiliser n'importe quelle adresse MAC pourvu que vous ne réutilisiez pas deux fois la même pour deux équipements différents sur le même réseau.

Adressage IP

IP est l'acronyme de Internet Protocol. Les adresses IP permettent d'identifier et d'adresser de manière unique une machine connectée sur le réseau (Serveur, PC, tablette, etc). Elle est formée de 4 chiffres (octets) allant de 0 à 255 séparés par des points, par exemple : 12.23.126.78

Il existe deux types d'adresses IP, les adresses IP publiques et les adresses IP privées.

Les adresses publiques sont accessibles partout dans le monde sur internet, il s'agit par exemple de l'adresse IP de votre box attribuée par votre Fournisseur d'Accès à Internet. Vous la retrouverez parfois dans les scripts Arduino sous le nom de gateway (routeur). C'est celle qui vous permettra par exemple d'accéder à votre Arduino depuis internet pour consulter la température dans votre appartement ou commander l'allumage ou l'extension d'un lampe.

Les adresses IP locales par définition ne seront visibles que sur votre réseau local. Vous pouvez avoir des adresses IP locales pour tous les appareils connectés à votre réseau local comme vos consoles de jeu, vos téléphones, vos PC portables, vos tablettes, vos postes de télévision connectés, etc. et bien sûr vos Arduino. Votre box a une adresse IP locale qui permet de l'identifier sur votre réseau local en complément de son adresse IP publique qui permet de l'identifier sur le réseau internet. Les adresses locales sont par exemple du type 192.168.X.X comme vous le verrez dans les exemples.

Protocole de transport TCP

TCP est l'acronyme de Transmission Control Protocol. Les adresses TCP permettent d'identifier et d'adresser de manière unique une application ou un service sur une machine connectée sur le réseau (browser WEB par exemple). Elle est codée sur 16 bits. Il existe 3 plages de numéros de port TCP : Il existe un autre protocole de transport UDP (User Datagram Protocol) plus simple à utiliser et plus rapide mais aussi moins sûr avec des segments qui peuvent être perdus ou arriver dans le désordre.

Notions HTTP

Description des requêtes HTTP

Les requêtes comprennent : La première ligne comporte les trois éléments suivants qui doivent être séparés par un espace : Exemple de première ligne : GET www.phmarduino.free.fr HTTP/1.0

Les lignes de champs d'en-tête de requête facultatives permettent de donner des informations supplémentaires sur la requête. Chaque ligne est composée d'un nom de champ suivi de deux points et de la valeur du champ.

Les champs suivants peuvent être utilisés par exemple : Le corps de la requête facultatif permet ensuite par exemple d'envoyer des données par la commande POST lors de l'envoi de données via un formulaire.

Exemple de requête HTTP GET complète :
GET /imghp?hl=fr&tab=wi HTTP/1.1
Host: images.google.fr
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; fr; rv:1.9.0.9)
Accept: text/html,application/xhtml+xml
Accept-Language: fr,fr-fr
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 300
Connection: keep-alive

On retrouve dans cet exemple de requête uniquement la ligne de commande et les lignes de champs d'entête de requête car la commande est un GET. Il n'y a donc pas de lignes de corps de requête. Les données sont transmises du client au serveur directement dans la ligne de commande via l'URL : les champs sont indiqués tout de suite après le ? qui suit la ressource demandée: le champ hl est valorisé à fr et le champ tab est valorisé à wi.

Exemple de requête HTTP POST complète :
POST index.html HTTP/1.1
Host: www.phmarduino.free.fr
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1
Accept: text/html,application/xhtml+xml
Accept-Language: fr,fr-fr;q=0.8
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Content-Type: application/x-www-form-urlencoded
Content-Length: 36
Keep-Alive: 300
Connection: keep-alive

nom=martin&prenom=jean&date=20042012


On retrouve dans cet exemple de requête la ligne de commande, les lignes de champs d'entête de requête ainsi que les lignes du corps de requête. Dans le champ Content-length, on indique la longueur du corps de la requête à savoir 36 caractères. Dans le corps de la requête, on retrouve trois champs qui sont transmis au serveur par le client : nom, prénom et date valorisés à martin, jean et 20042012. Les champs d'entête de requête sont séparés du corps de la requête par une ligne blanche.

Description des réponses HTTP

Les réponses comprennent : La première ligne comporte les trois éléments suivants qui doivent être séparés par un espace : Exemple de première ligne : HTTP/1.1 200 OK

Exemples de statut avec sa description: Les lignes de champs d'en-tête de réponse permettent de donner des informations supplémentaires. Chaque ligne est composée d'un nom de champ suivi de deux points et de la valeur du champ.

Les champs suivants sont utilisés par exemple : Le corps de la réponse ensuite contient par exemple une page HTML demandée.

Exemple de réponse HTTP complète :
HTTP/1.1 200 OK
Date: Tue, 22 Jun 2011 14:13:55 GMT
Server: Apache/1.3.26 (Unix) Debian GNU/Linux PHP/4.1.2 mod_ssl/2.8.9 OpenSSL/0.9.6g DAV/1.0.3
Last-Modified: Tue, 22 Jun 2010 13:47:27 GMT
ETag: "63f3e-40-40d8386f"
Accept-Ranges: bytes
Content-Length: 64
Keep-Alive: timeout=15, max=1999
Connection: Keep-Alive
Content-Type: text/html


‹html›
‹body›
‹h1›Page html ‹h1›
‹/body›
‹/html›

Notions HTML

Utilisation des formulaires

Les formulaires permettent aux utilisateurs de saisir des données et de demander l'exécution d'actions dans les pages WEB. Ils peuvent contenir par exemple des champs de saisie, des boutons radios, des cases à cocher, des zones de saisie de texte, des boutons de soumission, etc ...

Les formulaires sont délimitées par les balises ‹FORM› et ‹/FORM›.

Dans la balise d'ouverture du formulaire, il faut indiquer les deux attributs ci-dessous obligatoires : Ce qui donne par exemple : ‹FORM METHOD="GET" ACTION="http://192.168.0.11" ›

Caractéristiques techniques Arduino Ethernet

Micro contrôleurATmega328
Tension de fonctionnement5V
Tension d'alimentation plug (limites)6 à 18V
Tension d'alimentation PoE (limites)36 à 57 V
Entrées/sorties numériques14 dont 4 disposent d'une sortie PWM (Pattes Arduino réservées : 10 à 13 pour la connexion Ethernet, 4 pour la carte SD et 0 (Réception RX) à 1 (Émission TX) si la liaison série est utilisée)
Entrées analogiques 6 (ATTENTION : le niveau max en entrée doit être de 5 volts)
Courant max par broches E/S40 mA (ATTENTION : 200mA cumulé pour l'ensemble des broches E/S)
Courant max sur sortie 3,3 V générée par le régulateur interne50 mA
Mémoire Flash32 KB dont 0.5 KB utilisée par le bootloader
Mémoire SRAM2 KB
Mémoire EEPROM1 KB
Fréquence horloge 16 MHz
Autres Contrôleur Ethernet TCP/IP embarqué W5100, jack magnétique Power Over Ethernet, lecteur carte Micro SD avec transfo de tension active

Installation

Pour la programmation, contrairement à l'Arduino UNO qui est relié au PC via un câble USB classique, l'Arduino Ethernet est relié au PC via un câble avec une prise mini USB.

Une fois l'Arduino Ethernet programmé, pour pouvoir l'utiliser soit comme serveur WEB, soit comme client WEB, il faut le relier à sa BOX avec un câble Ethernet en utilisant la prise RJ45 présente sur l'Arduino.

A compléter.

Description des exemples

Exemple Ethernet 1 : Faire clignoter la LED embarquée

Ce premier test permet de vérifier très rapidement en quelques minutes que l'Arduino Ethernet fonctionne bien en faisant clignoter la LED présente sur la carte et connectée à la patte 9 et pas la 13 comme sur l'Arduino UNO.

Code du programme Arduino :

/* 
Objet : Clignotement de la LED présente sur l'Arduino Ethernet en série
Nom : phm_blink_ethernet.ino
Infos sketch : Créé en 2011 le 26 octobre par PHM
 */

// Définition patte de l'arduino sur laquelle est connectée la LED
const int patteLED =  9; // La patte de l'arduino avec la LED est la 9

void setup() {
  // On positionne la patte 9 de l'arduino en sortie
  pinMode(patteLED, OUTPUT);
}

void loop()
{

// On allume et on éteint alternativement la LED sur la patte 9
   digitalWrite(patteLED, HIGH);
   delay(200); // Attente de 200 ms
   digitalWrite(patteLED, LOW);
   delay(200); // Attente de 200 ms
  
}


Exemple Ethernet 2 : Utilisation de l'Arduino comme client WEB pour accéder à internet

Recherche internet sur le mot clé Arduino avec GOOGLE

Vous trouverez ci-dessous une adaptation du code de l'exemple fourni avec l'IDE Arduino permettant à l'Arduino d'accéder à la page d'accueil de Google sur internet pour une recherche sur le mot-clé Arduino.

Dans la commande Ethernet.begin, on indique uniquement l'adresse MAC, on laisse au serveur DHCP de la BOX le soin de choisir une adresse IP privée locale libre.

Code du programme Arduino

/*
  Nom sketch : phm_WebClient.ino
  Description : Exemple de Web client qui se connecte au site Google pour faire par exemple dans
  le cas présent une recherche sur le mot clé Arduino. Ce sketch s'inspire de l'exemple
  standard de David A. Mellis
  Auteur : PHMARDUINO
  Date modification : 30 07 2013
*/

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x65, 0x6F }; // MAC adresse de mon arduino ethernet
IPAddress server(173,194,67,147); // Initialisation de l'objet server avec l'adresse IP du site
                                  // Google (à vérifier et à modifier éventuellement car 
                                  // car celle-ci peut evoluer)

// Initialisation objet client
EthernetClient client;

void setup() {
  // Initialisation communication série
  Serial.begin(9600);
  Serial.println("Envoi demande de configuration DHCP\n");
  // Initialisation communication Ethernet
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Echec demande configuration DHCP\n");
    // Fin des traitements
    for(;;)
      ;
  }
  Serial.println("Configuration DHCP OK\n");
  // Affichage adresse IP Arduino
  Serial.print("Adresse IP obtenue : ");
  Serial.println(Ethernet.localIP());
  Serial.println();
  // Laisse une seconde au shield Ethernet pour initialisation
  delay(1000);
  Serial.println("Connexion en cours...\n");

  // Connexion obtenue
  if (client.connect(server, 80)) {
    Serial.println("Connexion OK\n");
    // Envoi de la requete HTTP
    client.println("GET /search?q=arduino HTTP/1.0");
    client.println();
  } 
  else {
    // Echec connexion au serveur Google
    Serial.println("Echec connexion");
  }
}

void loop()
{
  // Lecture resultat requete
  if (client.available()) {
    char c = client.read();
    Serial.print(c);
  }

  // Arret client a la deconnexion du serveur
  if (!client.connected()) {
    Serial.println();
    Serial.println("Deconnexion\n");
    client.stop();

    // Arret des traitements
    for(;;)
      ;
  }
}



Il est à noter que l'adresse IP du serveur Google renseignée dans le sketch (ici 173.194.67.147) valable le jour du test peut être modifiée ensuite par Google. En cas de dysfonctionnement du sketch, il faut donc vérifier que celle-ci est toujours bien valide et permet d'arriver sur la page Google en saisissant directement cette adresse IP comme URL dans un navigateur WEB.

L'instruction Ethernet.begin(mac) retourne 0 si l'attribution DHCP n'a pas réussi et 1 si l'attribution par le serveur DHCP de la BOX d'une adresse IP locale a réussi.

On voit ci-dessous dans les messages affichés dans la console que l'adresse IP attribuée à la carte Arduino Ethernet par le serveur DHCP de la BOX est 192.168.0.11

Résultats obtenus dans la console :

Ethernet


Résultats de la requête renvoyés par Google à l'Arduino puis copiés dans un fichier texte et ouvert avec un navigateur :

Ethernet

Recherche sur internet de la température à Laval en Mayenne avec les API YAHOO

Nous allons utiliser une API YAHOO qui permet de récupérer sur internet des informations sur le temps pour une ville donnée. Les résultats sont retournés par l'api YAHOO au format XML.

Précisions : Le paramètre w indiquant le lieu et le paramètre u indiquant l'unité pour les températures, ici Celsius.

Pour obtenir le code d'un lieu, par exemple Laval en Mayenne, entrer dans un navigateur l'URL http://isithackday.com/geoplanet-explorer/index.php?start=laval. On retrouve le code recherché dans le champ WOEID : 601787.

L'adresse IP du serveur Yahoo présente dans le code Arduino (IPAddress server(188,125,73,190)) est obtenue par un ping à weather.yahooapis.com.

Le retour XML obtenu avec l'API météo de Yahoo avce la température surlignée en jaune est le suivant :

meteo yahoo

Code du programme Arduino :
/*
  Nom sketch : phm_WebClient_api_temp.ino
  Description : Exemple de Web client qui se connecte au site Google pour faire par exemple dans
  le cas présent une recherche sur le mot clé Arduino. Ce sketch s'inspire de l'exemple
  standard de David A. Mellis
  Auteur : PHMARDUINO
  Date modification : 31 07 2013
*/

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x65, 0x6F }; // MAC adresse de mon arduino ethernet
IPAddress server(188,125,73,190); // Initialisation de l'objet server avec l'adresse IP du site
                                  // Yahoo pour les API weather

// Initialisation objet client
EthernetClient client;

void setup() {
  // Initialisation communication série
  Serial.begin(9600);
  Serial.println("Envoi demande de configuration DHCP\n");
  // Initialisation communication Ethernet
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Echec demande configuration DHCP\n");
    // Fin des traitements
    for(;;)
      ;
  }
  Serial.println("Configuration DHCP OK\n");
  // Affichage adresse IP Arduino
  Serial.print("Adresse IP obtenue : ");
  Serial.println(Ethernet.localIP());
  Serial.println();
  // Laisse une seconde au shield Ethernet pour initialisation
  delay(1000);
  Serial.println("Connexion en cours...\n");

  // Connexion obtenue
  if (client.connect(server, 80)) {
    // w: ID from your City
    // http://weather.yahooapis.com/forecastrss?w=12893459&u=c
    //
    Serial.println("Connection à l'api Yahoo Weather...");
    client.println("GET /forecastrss?w=601787&u=c HTTP/1.0");
    client.println("HOST:weather.yahooapis.com\n\n");
    client.println();
    Serial.println("Connection OK...");
  } 
  else {
    // Echec connexion au serveur Google
    Serial.println("Echec connexion");
  }
}

void loop()
{
  // Lecture resultat requete
  if (client.available()) {
    char c = client.read();
    Serial.print(c);
  }

  // Arret client a la deconnexion du serveur
  if (!client.connected()) {
    Serial.println();
    Serial.println("Deconnexion\n");
    client.stop();

    // Arret des traitements
    for(;;)
      ;
  }
}



De la même manière, on peut récupérer par exemple le cours de bourse de Apple avec l'url http://www.google.com/ig/api?stock=AAPL. Le résultat obtenu est alors le fichier XML ci-dessous :

xmlstock

Point d'attention : il ne doit pas y avoir d'espace dans une URL, ceux-ci doivent être remplacés par %20, 20 correspondant au code ASCII du caractère espace.

Exemple Ethernet 3 : Utilisation de l'Arduino comme serveur WEB

Vous trouverez ci-dessous une adaptation du code de l'exemple fourni avec l'IDE Arduino permettant d'utiliser l'Arduino comme un serveur WEB pour afficher des données retournées par des capteurs, dans cet exemple la température mesurée par un LM35 :

A compléter.


//
// Nom sketch : phm_WebServer_lm35.ino 
// Date : 28 04 2012
// Auteur : PHM d'après l'exemple standard Arduino
//

#include <SPI.h>
#include <Ethernet.h>

// Remplacer les adresses MAC et IP par celles de votre Arduino Ethernet
byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0xF6, 0x27 };
byte ip[] = { 192,168,0, 20 };
// Création de l'objet server de type EthernetServer disponible sur le port 80

EthernetServer server(80);

void setup()
{
  // Démarrage de la connexion Ethernet et du serveur WEB server
  Ethernet.begin(mac, ip);
  server.begin();
  Serial.begin(9600);
  analogReference(INTERNAL); //Permet de fixer la temperature de refernce à 1,1 volt
}

void loop()
{
  //Déclaration et initialisation des variables
  float mesure=0;        //Variable pour le stockage mesure retournée par le capteur
  float tension=0;       //Variable pour le stockage de la tension 
  float temperature=0;   //Variable pour le stockage de la température 
  float tempmin=100;     //Temperature min
  float tempmax=0;       //Temperature max
  int portana0 = 0;      //Numéro du port analogique sur lequel la température est mesurée

  //Ecoute des requetes client (browser WEB)

  mesure = analogRead(portana0);  //Lecture de la valeur fournie par le capteur de température
  tension = mesure * 1.1 / 1024;  //Conversion en tension (en volt)
  temperature = tension * 100;    //Conversion en température (en degré Celsius)  delay(1000);
  Serial.println(temperature);    //Ecriture de la temperature sur le potr série
  delay(1000);
  EthernetClient client = server.available();
  if (client) {
    // Gestion de la fin de la requête WEB qui est indiquée par l'envoi d'une ligne blanche
    boolean currentLineIsBlank = true;
 
    while (client.connected()) {
      if (client.available()) {
              client.print("Temperature ambiante = ");
              client.print(temperature);  
         client.stop();}
    }}}




Vous trouverez ci-dessous une adaptation du code de l'exemple fourni avec l'IDE Arduino permettant d'utiliser l'Arduino comme un serveur WEB pour afficher la luminosité retournée par une LDR :


//
// Nom sketch : phm_WebServer_ldr.ino 
// Date modification : 19 12 2012
// Auteur : PHMARDUINO d'après l'exemple standard Arduino
// Description : affichage luminosité grace à une ldr dont la sortie est connectée sur l'entrée analogique
// A0 de l'Arduino. La luminosité retournée varie de 0 dans l'obscurité totale à 1024 en pleine lumière.
// La luminosité peut être visualisée soit via le moniteur série, soit en interrogeant le serveur WEB embarqué
// sur l'Arduino Ethernet. Dans le cas présent, il faut saisir pour cela l'adresse IP locale du serveur WEB
// Arduino choisie à savoir 192.168.0.20

#include <SPI.h>
#include <Ethernet.h>

// Initialisation avec de l'adresse MAC avec celle de mon Arduino Ethernet
byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x65, 0x6f };
// Initialisation de l'adresse IP locale de mon serveur WEB Arduino que j'ai choisie
byte ip[] = { 192,168,0, 23 };

// Création de l'objet server de type EthernetServer disponible sur le port 80
EthernetServer server(80);

void setup()
{
  // Initialisation de la connexion Ethernet 
  Ethernet.begin(mac, ip);
  // Démarrage du serveur WEB server
  server.begin();
  // Initialisation de la liaison série
  Serial.begin(9600);
}

void loop()
{
  int lumi=0;        //Variable pour le stockage de la luminosité retourrnée par la ldr
  int portana0 = 0;  //Numéro du port analogique sur lequel la température est mesurée

  lumi = analogRead(portana0);     //Lecture de la valeur fournie par la ldr
  Serial.print("Luminosite : ");   //Ecriture de la temperature sur le port série
  Serial.println(lumi);       
  delay(1000);  // Attente de une second avant de refaire une mesure
  
  //Ecoute des requetes client (browser WEB)
  EthernetClient client = server.available();
  //Une requete est à traiter
  if (client) {
  //Envoi de la réponse HTTP au browser qui a envoyé une requete
    while (client.connected()) {
      if (client.available()) {
        //Envoi du header standard HTTP au browser
        client.println("HTTP/1.1 200 OK");
        client.println("Content-Type: text/html");
        client.println();
        //Envoi des données
              client.print("Luminosite = ");
              client.print(lumi);  
         client.stop();} //Cloture connexion
    }}}




Les résultats obtenus dans la console en faisant varier la luminosité sont les suivants :

ldr console


Les résultats obtenus en interrogeant le serveur WEB sur l'Arduino avec son adresse IP locale (192.168.0.20) renseignée dans l'URL d'un browser sont les suivants :

ldr browser



Photo du montage avec la LDR :

photo montage ldr

Accès au serveur WEB embarqué par l'Arduino depuis internet

Dans les exemples précédents, on pouvait accéder au serveur WEB sur l'Arduino à l'aide d'un browser en local. Pour accéder au serveur WEB Arduino depuis internet, il est nécessaire de paramétrer sa box pour rediriger les appels extérieur via internet vers l'Arduino.

Par exemple sur ma freebox V5, j'ai configuré la redirection de port comme indiqué ci-dessous pour que lorsque je saisis sur mon iphone l'adresse internet de ma freebox, la requête soit reroutée sur l'adresse de mon webserveur Arduino (Adresse IP locale 192.168.0.20 et port 80 qui sont renseignés dans le sketch) :

redir port

Le résultat obtenu est le suivant :

iphone

Exemples de réalisations utilisant une connexion avec Bluetooth

Exemple émission par l'Arduino en Bluetooth avec le HC06

Plusieurs types de modules Bluetooth sont disponibles avec en particulier le HC05 et le HC06.
>> Le HC-05 dispose d'un firmware complet avec beaucoup de commandes AT disponibles, il peut être configuré soit comme maitre, soit comme esclave.
>> Le HC-06 ne peut être configuré que comme esclave et dispose d'un nombre de commandes AT limité.

Pour les exemples de réalisation Bluetooth, nous utiliserons le composant HC-06.

Code du programme Arduino

Dans un premier temps, programmez l'Arduino avec le code ci-dessous (le raccordement du HC-06 à l'arduino doit être fait dans un deuxième temps car le meme port série est utilisé pour la communication PC - ARDUINO et la communication PC - HC-06) :

    /* 
    Objet : Test liaison Bluetooth en emission
    Nom sketch : phm_bluetooth_test.ino
    Infos sketch : Créé le 05 07 2014 par PHMARDUINO
    Commentaire : Ce sketch permet à l'arduino UNO d'envoyer en Bluetooth via le module HC06,
    celui-ci est preregle en usine avec les parametres serie suivant : 9600, N, 8, 1
    */
     int compteur = 0;    // Compteur de messages envoyes
     unsigned long temps; // Mesure temps ecoule
     
    void setup() {
        Serial.begin(9600);    //Demarrage liaison serie
        pinMode(13, OUTPUT);   //La LED 13 est utilisee comme temoin de bon fonctionnement
    }
     
    void loop() {
        digitalWrite(13, HIGH);   // Allumage de la LED 13
        delay(200);               // Temporisation de 200 ms 
        digitalWrite(13, LOW);    // Extinction de la LED 13
        ++compteur                // Incrementation compteur de message
        temps = millis();
        // Envoi message via Bluetooth
        Serial.print("PHMARDUINO - Test du module Bluetooth HC06 - "); 
        Serial.print("Compteur de messages : "); Serial.print(compteur);
        Serial.print(" - Temps en ms : "); Serial.println(temps);      
        delay(1000);  //Delai d une seconde
    }




Photos du montage

Une fois l'Arduino programmé, on peut réaliser le montage ci-dessous avec le cablage à réaliser entre le module HC06 et l'Arduino suivant :
Module HC06 (4 pattes utilisées) -> Arduino
VCC –> +5V
GND –> GND
TXD –> Patte 0 (RX)
RXD –> Patte 1 (TX)


Arduino BT montage

Une fois le montage réalisé, une LED rouge sur le HC-06 doit clignoter.

Installation périphérique Bluetooth

Le montage étant réalisé, il faut passer à l'installation du périphérique BT HC-06 sous Windows.
Par défaut, le mot de passe est 1234, le port série est configuré avec une vitesse de 9600 Bauds, 8 bits de données, pas de bit de parité et 1 bit de stop (9600,N,8,1).

Arduino BT install 1



Arduino BT install 2

Résultats obtenus dans le terminal Putty

Ouvrir ensuite un terminal Putty configuré comme indiqué ci-dessous pour afficher les messages envoyés par l'Arduino au PC en BT à l'aide du HC-06.

Arduino BT res 1



Arduino BT res 2



Arduino BT res 3

Résultats obtenus en utilisant un terminal Bluetooth avec mon smartphone sous Android

On peut utiliser comme dans cet exemple l'application Android "Term for BT" ou par exemple "BlueTerm", etc.

Arduino BT res 4

Exemple de modification des parametres du HC06 avec des commandes AT

Les principales commandes AT disponibles sont :
>> AT : commande de tests pour vérifier si le HC-06 est bien opérationnel,
>> AT+VERSION : pour obtenir la version du HC-06,
>> AT+NAMEmonnom : pour changer du HC-06 par défaut et la remplacer par monnom,
>> AT+BAUDi : pour changer la vitesse de transmission qui est par défaut à 9600 bauds,
>> AT+PINxxxx : pour changer le mot de passe.

Code du programme Arduino


    /* 
    Objet : Commandes AT Bluetooth
    Nom sketch : phm_bluetooth_at.ino
    Infos sketch : Créé le 06 07 2014 par PHMARDUINO
    Commentaire : Ce sketch permet à l'arduino UNO d'envoyer des commandes Bluetooth au HC-06
    */
    #include <SoftwareSerial.h>   
    #define RxD 10    //Pin 10 pour RX 
    #define TxD 11    //Pin 11 pour TX
    SoftwareSerial BTSerie(RxD,TxD); 
    void setup() 
    { 
      Serial.begin(9600);  
      delay(500); 
      Serial.println("PHMARDUINO - Veuillez entrer une commande AT"); 
      pinMode(RxD, INPUT); 
      pinMode(TxD, OUTPUT); 
      BTSerie.begin(9600);  
      delay(1000); 
    } 
    void loop() 
    { 
      char caractereRecu; 
      //Lecture message envoyé par le HC06 et ecriture sur le terminal serie 
      if (BTSerie.available()) { 
        caractereRecu = BTSerie.read(); 
        Serial.print(caractereRecu); 
      } 
      // Lecture message envoye par le terminal serie et envoi au HC06
      if (Serial.available()) { 
        caractereRecu = Serial.read(); 
        BTSerie.write(caractereRecu); 
      } 
    } 




Commande test HC-06

Arduino AT 1

Commande version HC-06

Arduino AT 2

Changement nom HC-06

Nom par défaut du HC-06 avant changement avec une commande AT (ici HC-06):

Arduino AT 3

Changement du nom :

Arduino AT 4

Le nom après changement est désormais phmarduinobt2 :

Arduino AT 5

Arduino AT 6

Mise en œuvre de l'Arduino Yun

Introduction

L'Arduino que nous allons utiliser dans les exemples suivants est l'Arduino Yun qui comporte entres autres une liaison WIFI qui permet de le programmer à distance.

Arduino Yun

Installation Arduino Yun

L'installation des drivers sous Windows 7 est effectuée automatiquement après le branchement sur une prise USB du PC. Le résultat obtenu est le suivant : Arduino Yun

Intégration avec d'autres logiciels

Intégration avec le logiciel Processing

Introduction

Processing est utilisé en complément de l'Arduino afin de disposer d'un interface graphique sur PC pour commander l'Arduino et pour restituer les données collectées par l'Arduino. Vous pouvez le télécharger ICI.

Des bibliothèques spécialisées permettent en outre de compléter les fonctionnalités offertes de base par Processing. Vous trouverez ci-dessous les bibliothèques que j'ai utilisées dans les applications décrites sur ce site.

Par exemple, pour la gestion des échanges entre l'Arduino et Processing via le port série, j'ai utilisé la bibliothèque "Serial" qui offre les commandes suivantes : Pour plus d'informations sur cette bibliothèque vous pouvez vous rendre ICI.

Pour la gestion de l'interface utilisateur (boutons, case à cocher, champs textes, slider, etc.), les bibliothèques suivantes sont proposées par le site Processing : Dans les exemples de mise en oeuvre de Processing présentés sur ce site, j'ai utilisé la bibliothèque controlP5.

Pour plus d'informations sur la liste des bibliothèques disponibles pour Processing vous pouvez vous rendre ICI.

Exemple Processing 1 : Visualisation température dans la console processing

Nous reprenons dans cette réalisation le montage de mesure de température utilisant le capteur LM35 DZ. Mais cette fois-ci, au lieu d'afficher la température sous forme de texte dans la console Arduino, nous allons afficher la température instantanée dans la console Processing dans cet exemple puis sous forme graphique avec son évolution dans le temps grâce à Processing dans un l'exemple suivant.

Code du programme Arduino

///////////////////////////////////////////////////////////////////////////////////////////
// Objet  : Mesure de temperature avec un LM35 DZ et envoi à Processing pour affichage   //
// Nom sketch Arduino : phm_lm35_processing.ino                                          //
// Auteur : PHM                                                                          //
// Date création : Le 24 juin 2011                                                       //
// Date dernière mise à jour : Le 28 octobre 2011                                        //
///////////////////////////////////////////////////////////////////////////////////////////

//Déclaration et initialisation des variables
  int mesure=0;       //Variable pour le stockage mesure retournée par le capteur
  int portana0 = 0;   //Numéro du port analogique sur lequel la température est mesurée

//Traitements initialisation
  void setup()
  {
    analogReference(INTERNAL); //Permet de fixer la temperature de refernce à 1,1 volt
    Serial.begin(9600);        //initialisation de la liaison série à 9 600 bauds
  }

//Traitements itératifs
  void loop()
  {
    mesure = analogRead(portana0);  //Lecture de la valeur fournie par le capteur de température  
    Serial.println (mesure);   //Envoi mesure au PC par la liaison série pour affichage dans Processing
    delay(5000);               //Attente de 5 secondes avant de faire une nouvelle mesure              
  }
  
  



Code du programme Processing

 ///////////////////////////////////////////////////////////////////////////////////////////
 // Objet  : Affichage temperature ambiante mesurée par un LM35 et envoyée par Arduino    //
 // Nom skecth processing : phm_lm35_console.pde                                          //
 // Auteur : PHM                                                                          //
 // Date création : Le 24 juin 2011                                                       //
 // Date dernière mise à jour : Le 27 octobre 2011                                        //
 // Commentaires : Utiliser avec un Arduino et un LM35 pour la capture de temperature     // 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 //Import de la librairie communication serie
 import processing.serial.*;
 
 //Initialisation des variables
 Serial monPort;  //Déclatation port série pour la lecture des données envoyées par l'Arduino
 int mesure;      //Mesure lue sur le port 
 
 //Traitements d'initialisation
 void setup() {
    println(Serial.list());    // Affichage dans la console de la liste des ports serie du PC
    monPort = new Serial(this, "COM7", 9600);   //Initialisation de la communicaiton port serie
    monPort.bufferUntil('\n'); //Attend la réception d'un fin de ligne pour généer un serialEvent() 
 }
 
 //Traitements itératifs de lecture et affichage temperature
 void draw() {
  // pas de traitement car tout est réalisé dans la fonction serialEvent()
 }
 
 //Traitements à réception d'une fin de ligne
 void serialEvent (Serial monPort) {
   //Récupération sur le port série de la tension sous forme de chaine de caractères
   String tensionCar = monPort.readStringUntil('\n');
   if (tensionCar != null) {
   // Suppression des blancs
   tensionCar = trim(tensionCar);
   // Conversion tensoin en caractères en décimal et calcul température
   int tensionNum = int(tensionCar); 
   float temperature = 100 * tensionNum * 1.1 / 1024;
   println ("La temperature est de : " + temperature + " degrés");
   }
 }



Résultat dans la console Processing

LM35 Console Processing

Exemple Processing 2 : Visualisation température sous forme graphique dans processing

Code du programme Arduino

C'est le même que pour l'exemple 14.

Code du programme Processing

///////////////////////////////////////////////////////////////////////////////////////////
// Objet  : Affichage temperature sous forme graphique                                   //
// Nom skecth : phm_lm35_graph.pde                                                       //
// Auteur : PHM                                                                          //
// Date création : Le 29 aout 2011                                                       //
// Date dernière mise à jour : Le 28 octobre 2011                                        //
///////////////////////////////////////////////////////////////////////////////////////////

 //Import de la librairie communication serie
 import processing.serial.*;
 
 //Initialisation des variables
 Serial monPort;  //Déclatation port série pour la lecture des données envoyées par l'Arduino
 int mesure;      //Mesure lue sur le port 

//Initialisation des variables

 int temperature=25;      //Temperature mesurée par l'Arduino
 int tempmini=34;         //Temperature mini mesurée par l'Arduino
 int tempmax=12;          //Temperature maxi mesurée par l'Arduino
 int j;           //Indice de travail
 int k;           //Indice de travail
 int x=0;          //Abcisse
 int x0=0;         //Abcisse précédente
 int y=0;           //Ordonnée
 int y0;           //Ordonnée précédente
 PImage thermometre;
 PFont police;

//Traitements d'initialisation
void setup() {
  
 //Initialisations port série
 println(Serial.list());    // Affichage dans la console de la liste des ports serie du PC
 monPort = new Serial(this, "COM7", 9600);   //Initialisation de la communicaiton port serie
 monPort.bufferUntil('\n'); //Attend la réception d'un fin de ligne pour généer un serialEvent() 
 
 //Initialisatiopns graphiques
 size (1000,610);
 background(#9FB84D);
 smooth();  //On active le lissage

 //Dessin des cadres -------------------------
 stroke(0);
 strokeWeight(1);
 fill(230);
 rect (20,20,210,500); //Thermometre
 rect (20,525,210,65); //Textes
 rect (240,20,750,500); //Courbe historique

 //Dessin des titres  -------------------------
 fill(255,0,0);
 police = loadFont("SansSerif.italic-16.vlw");
 textFont(police,16);
 text("Température instantanée", 35, 40);
 text("Historique température", 520, 40);
 thermometre = loadImage("thermometre.jpeg");
 image(thermometre,290,525,65,65);
 fill(0,0,255);
 police = loadFont("TimesNewRomanPS-BoldItalicMT-50.vlw");
 textFont(police,48);
 text("Suivi température", 420, 570);
 police = loadFont("Corbel-14.vlw");
 textFont(police,14);

 //Dessin du thermomètre -----------------------
 fill(50);
 noStroke();
 rect(100,70,20,420);
 ellipse(110, 490, 40, 40);

 //Dessin du réservoir
 ellipse(110, 70, 20, 20);
 fill(#0BB305);
 ellipse(110, 490, 30, 30);

 //Gradations et textes tous les 5 degrés
 fill(50);
 strokeWeight(2);
 stroke(50);

 //à gauche
 for (int i = 0; i < 11; i++) {
      j=i*40;
      k=i*5;
      line(90, 475-j, 100,475-j);
      text(k+" °C", 50, 475-j);
  }

 //à droite
 for (int i = 0; i < 11; i++) {
      j=i*40;
      k=i*5;
      line(120, 475-j, 130,475-j);
      text(k+" °C", 140, 475-j);
 }

 //Gradations fines des degrés
 
 //à gauche
 strokeWeight(1);
 stroke(50);
 for (int i = 0; i < 50; i++) {
         j=i*8;
         line(95, 475-j, 100,475-j);
 }
 
 //à droite
 strokeWeight(1);
 stroke(50);
 for (int i = 0; i < 50; i++) {
          j=i*8;
          line(120, 475-j, 125,475-j);
 }

 //Affichage courbe -----------------------

 //Tracé des axes
 fill(0,0,255);
 stroke(#0650E4);
 strokeWeight(2);
  
 //horizontal
 line (290,475,960,475);
 triangle(960, 475, 950, 480, 950, 470);
 text("Température (°C)", 250, 40);
 
 //vertical
 line (290,475,290,50);
 triangle(290, 50, 295, 60, 285, 60);
 text("Tempts (mn)", 910, 510);

 //Gradations et textes tous les 5 degrés
 fill(0,0,255);
 strokeWeight(2);
 stroke(#0650E4);
 for (int i = 0; i < 11; i++) {
     j=i*40;
     k=i*5;
     line(285, 475-j, 290,475-j);
     text(k, 260, 480-j);
 }

 //Gradations fines des degrés
 strokeWeight(1);
 stroke(#0650E4);
 for (int i = 0; i < 50; i++) {
          j=i*8;
          line(285, 475-j, 290,475-j);
 }

 //Gradations des minutes
 strokeWeight(2);
 for (int i = 0; i < 11; i++) {
          j=i*60;
          line(290+j, 475, 290+j,480);
          text(i, 295+j, 490);
 }

}

//Traitements itératifs 
 void draw() {
        // Pas de traitement car tout est réalisé dans la fonction serialEvent()
   }

//Traitements à réception d'une fin de ligne
 void serialEvent (Serial monPort) {
 
 //Récupération sur le port série de la tension sous forme de chaine de caractères
 String tensionCar = monPort.readStringUntil('\n');
 if (tensionCar != null) {
      tensionCar = trim(tensionCar); // Suppression des blancs
      int tensionNum = int(tensionCar);  // Conversion tensoin en caractères en décimal et calcul température
      float temperature = 100 * tensionNum * 1.1 / 1024;
      int tempInt = int(temperature);
      println ("La temperature est de : " + temperature + " degrés : " + tempInt);
 
      //Dessin graphe avec temperature actuelle -----------------------
      stroke (0,255,0);
      strokeWeight(1);
  
      //dessin du nouveau point sur la courbe
      x0=x; // Mémorisation abscisse point précédent
      x=x+5; // L'Arduino envoie une nouvelle mesure de température toutes les 5 secondes
      if (x >600) {x=5;}
    
      y0=y; // Mémorisation ordonnée point précédent
      y = tempInt*8; // Un degré correpond à 8 points sur les ordonnées
    
      if (y > tempmax*8)  {tempmax = y/8;} //Mise à jour temp max
      if (y < tempmini*8) {tempmini = y/8;} //Mise à jour temp min
    
      if (x == 5) {   //Si on rédémarre une nouvelle courbe
        noStroke();
        fill(230);
        rect(291,65,655,410); //Effacement courbe précédente
        point(x+287,475-y);
      }
      else {
        line(x0+287,475-y0,x+286,475-y);
      }
  
      //Dessin thermometre avec temperature actuelle -----------------------
      temperature=y/8;
      noStroke();
      fill(#0BB305);
      rect(105,475-temperature*8,10,temperature*8+5);
      fill(#08F500);
      rect(110,480-temperature*8,3,temperature*8-5);
    
      //Affichage des températures ----------------
    
      //Dessin des cadres -------------------------
      stroke(0);
      strokeWeight(1);
      fill(230);
      rect (20,525,210,65);
    
      //Dessin du thermomètre -----------------------
      fill(50);
      noStroke();
      rect(100,70,20,420);
      ellipse(110, 490, 40, 40);
    
      // Dessin du réservoir
      ellipse(110, 70, 20, 20);
      fill(#0BB305);
      ellipse(110, 490, 30, 30);
    
      //Dessin temperature actuelle -----------------------
      noStroke();
      fill(#0BB305);
      rect(105,475-temperature*8,10,temperature*8+5);
      fill(#08F500);
      rect(110,480-temperature*8,3,temperature*8-5);
    
      noStroke();
      fill(230);
      rect(160,500,70,20); //effacement texte précédent heure
      rect(25,500,60,20); //effacement texte précédent date
      fill(0,0,255);
      text(hour()+" : "+minute()+" : "+second(), 160, 514);
      text(day()+" / "+month()+" / "+year(), 25, 514);
    
      //Textes
      fill(0,0,255);
      text("Température actuelle :", 40, 540);
      text("Température mini :", 40, 560);
      text("Température max :", 40, 580);
      textAlign(RIGHT);
      fill(#0BB305);
      text(temperature+" °C", 220, 540);
      fill(0,0,255);
      text(tempmini+" °C", 220, 560);
      fill(255,0,0);
      text(tempmax+" °C", 220, 580);
      textAlign(LEFT);
   
   }
 }


Résultat dans Processing

LM35 Console Processing

Exemple Processing 3 : Commande d'un chenillard

Cette réalisation permet de commander un chenillard réalisé à l'aide de LEDs connectées à l'Arduino avec un interface graphique réalisé à l'aide de Processing.

Cet interface graphique permet de démarrer/arrêter le chenillard, de modifier la vitesse de défilement et de choisir le sens de défilement.
La trame définie pour les communications de Processing vers l'Arduino est : #PARAM1:PARAM2$ (# : et $ pour délimiter).

Code du programme Arduino (à compléter)


Code du programme Processing (à compléter)


A compléter

Intégration avec le logiciel Pure Data

A compléter

Liens

Liens en français

SiteThèmes principauxDescription
http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.HomePageGénéralTraduction partielle en français du site de référence en anglais
http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ARDUINOGénéralSite très complet avec plus d'une centaine d'exemples
http://www.jlectronique.org/index.htmEthernetQuelques exemples sur les entrées/sorties analogiques et les accès à internet via un shield Ethernet

A compléter

Liens en anglais

A compléter

Quelques bases sur l'électronique

LED (Light Emitting diode)

Introduction

Le brochage des LED est le suivant :

LED

Les LED doivent être alimentées via une résistance afin de limiter le courant qui les traverse. Celle-ci est calculée de la manière suivante :
La tension aux bornes d'une LED (rouge, jaune, orange ou verte) est d'environ 2 Volt et le courant qui la parcourt doit être d'environ 10 mA à minima pour une luminosité correcte.

Avec une alimentation de 5 Volts, la tension aux bornes de la résistance est donc de 5 - 2 = 3 Volts.

Comme R = U / I, la résistance doit être dans ce cas de 3 / 0,010 soit 300 Ohms.

Montage

Dans le montage présenté, la résistance choisie est de 220 Ohms afin d'avoir une meilleure luminosité. :

Montage LED

Photos

La LED est alimentée avec une source de tension d'environ 5 Volts (4.96 Volts sur la photo ci-dessous). La chute de tension aux bornes de la LED est d'environ 2 Volts (1,97 Volt exactement comme indiqué avec le multimètre sur la photo ci-dessous) :

Tension LED

Comme la résistance choisie est de 220 Ohms (couleurs rouge, rouge et marron), l'intensité traversant la LED est de 5 Volts - 2 Volts c'est à dire 3 Volts / 220 Ohms soit environ 13 mA (12,8 exactement comme indiqué avec le multimètre sur la photo ci-dessous ) :

Intensite LED

Circuit NE555

Le 555 est un circuit intégré très utilisé par les amateurs d'électronique comme oscillateur car il est très économique et très simple à mettre en œuvre.

ne555

Le brochage est le suivant :

Brochage 555

N° PatteDésignationDescription
1GNDMasse
2TRIGDéclenchement
3OUTSortie
4RESETRemise à zéro
5CONTAccès à la référence interne (2/3 Alimentation)
6THRESSignale la fin de la temporisation lorsque la tension dépasse 2/3 de l'alimentation
7DISCHDécharge
8VCCAlimentation comprise en tre 5 et 15 Volts


Exemple de montage :

Montage 555

Le signal obtenu en sortie sur la patte 3 est un signal carré de période T et de fréquence F=1/T.
T=T1+T2 avec T1 = 0,7 x ( R1 + R2 ) x C1 et T2 = 0,7 x R2 x C1.

Montage 555

La charge est effectuée au travers des deux résistances R1 et R2 en série et la décharge au travers de R2 uniquement.

Exemple : Avec C1 = 10 Microfarad et R1 = R2 = 100 K Ohms, on obtient T1 = 1,4 s, T2 = 0,7 s, T = 2,1 s, la fréquence est de 0,5 Hz et le rapport cyclique est de 67 %.

Amplification

On peut utiliser pour alimenter un haut-parleur à partir d'une sortie Aduino par exemple un amplificateur TDA 7052 qui peut produire jusqu'à un watt et qui nécessite très peu de composants supplémentaires.
Vous trouverez un exemple de montage ICI. incluant le schéma ci-dessous :
TDA7052

Radiofréquences

Tableau des radiofréquences utilisées en France

FréquenceUtilisation
433,9 MHz????
2,7 GHz????