Vous êtes sur la page 1sur 24

ARDUINO

,
exploration d’un designer
Assumed by Joshfre
Chloé Payot
Ce projet ne se veut pas expert en la matière Arduino.
Voici juste les notes d’un designer qui se penche avec curiosité
sur le domaine.
Prélude
L’arduino est une «plate-forme de prototype électronique open-source»
permettant d’utiliser simplement un microcontrôleur ATMEL AVR.
L’arduino récupère les informations de l’extérieur à travers des capteurs
de tout genre et peut contrôler des mécanismes comme des petits
moteurs ou des LED.
C’est une interface d’entrée/sortie simple qui se programme avec un
langage basé sur Wiring. Elle utilise l’environnement processing.
Comme l’interface de l’arduino est standardisée, les gens peuvent
créer des extensions (wif, écran...) qu’on peut clipser directement sur
la carte sans avoir à souder les composants.
L’arduino permet une interaction autonome entre l’objet et son
environnement. Une action physique ou analogique déclenche une
information digitale et inversement.
C’est pourquoi on trouve souvent de l’arduino dès qu’il s’agit de créer
des objets «intelligents».
Pour l’histoire, il a été développé par des designers d’interaction italien
Massimo Banzi et David Cuartielles.
L’arduino
HARDWARE
L’Arduino de base possède un microcontrôleur, qui rassemble la
mémoire (morte et vive), le processeur et les périphériques d’entrées
et sorties ; des entrées et sorties USB (spécifque à ce model) et
des prises power jack pour transmettre les informations et alimenter
l’Arduino avec une tension entre 7 et 12V, permettant d’utiliser
diférents types d’alimentations (piles, batteries, adaptateur...) ; des
LED qui servent surtout à indiquer l’état d’activité de l’arduino ; un
bouton reset manuel ; un ICSP Header qui permet de programmer le
microcontrôleur sans passer par la «couche» Arduino ; une puce FTDI
USB qui convertit l’information usb et enfn ; des pins dans tous les
sens.
Les éléments
Les pins sont les entrées et sorties sur lesquelles on peut confgurer
des actions pour l’arduino. Ils peuvent donc être programmés en Input,
Output ou comme des résistances. Par défaut, ils sont programmés en
Input. Sur tous les Arduinos, on trouve 3 types de pins diférents :
- Les pins digitaux
Les pins digitaux peuvent être des entrées ou des sorties. Ils vont gérer
des informations de type ON/OFF (Est-ce que le courant passe ou
non ?) Parmis les pins, certains ont une double fonction spécifque,
comme la fonction AREF qui défni la tension de référence pour les
pins Analogiques entre 0 et 1024.
- Les pins power
Les pins power assurent l’alimentation du circuit. Le Gnd est le ground,
le - du circuit ; 5V, 3V3 et VIN sont les + du circuit et sont choisis en
fonction du voltage du circuit. (le VIN permet de lier la sortie à la prise
power jack)
- Les pins analogiques
Les pins analogiques par opposition aux numériques traduisent
l’information dans un rapport continu (une variable). Ils permettent de
mesurer les résultats des capteurs analogiques.
Les pins
Il existe au moins 14 Arduino diférents avec chacun des spécifcités.
Etant donné que le board de l’arduino peut aussi être fait main, on imagine
qu’il y a une infnité de possibilités.
Mais voici ceux que l’on trouve le plus souvent et leurs caractéristiques :
Les modèles
Arduino UNO
L’arduino Uno est un générique
qui possède une sortie usb et qui
gère très bien les communications
avec l’ordinateur.
Arduino Ethernet
Comme son nom l’indique il peut
se connecter au web grâce à sa
prise ethernet.
Arduino Léonardo
Il est possible de le connecter
avec un ordinateur comme une
souris, car il gère le mode «usb-
host»
Arduino Micro
C’est la même que l’arduino
Léonardo mais elle fait 5 cm par
1,77.
Arduino Lilypad
Cet arduino est souvent utilisé
dans les textiles car il est souple
et petit.
Arduino Mega
Possède beaucoup plus de pins
pour gérer plus d’actions par
l’arduino.
Motor Shield
Voici un shield spécialement
pensé pour lier l’arduino à des
petits moteurs.
Arduino Duemilanove
C’est un modèle quasi identique
à l’arduino UNO
Wif Shield
Ceci est un shield que l’on va
«pluger» sur un arduino et qui
permet de se connecter en wif.
Les shields sont des extensions des cartes Arduino. C’est ce qui donne
tout son potentiel à l’usage des Arduinos. Par exemple : si je voulais
envoyer des coordonnées GPS par wif, il faudrait un arduino pour
faire tourner la logique, un shield GPS pour récupérer les données de
localisation et un shield wif pour la connexion. Je les branche simplement
sans soudure en les empilant et je peux programmer l’arduino.

Les Shields
Les capteurs vont permettre d’obtenir des informations analogiques
qui seront ensuite traduites par l’arduino. Voici quelques exemples de
capteurs et de ce que l’on peut capter.

Les capteurs
Capteur LDR
Photoresistance pour capter
l’intensité lumineuse.
Détecteur de choc Détecteur d’inclinaison
Ampoule à bille
Capte l’inclinaison (renversement)
Capteur CTN
Thermistance pour capter la
chaleur.
Capteur d’humidité, de gaz et
de température.
ÉLECTRONIQUE
Téléchargez le logiciel arduino sur la page :
http://arduino.cc/en/Main/Software
Connectez l’arduino avec le câble adapté. Il s’agit en général de câble
USB, mais pour l’arduino ethernet c’est un câble wiznet ethernet
interface.
Une fois connecté à l’ordinateur, des LED vertes s’allument sur la carte.
Ouvrez le logiciel.
Dans la partie Outils/Type de carte, sélectionnez l’arduino que vous
utilisez.
Assurez vous que le Port Serial (sur Mac OS X) donne une adresse de
ce genre : /dev/tty.usbmodem621 ou /dev/tty.usbserial-A02f8e
Pour l’arduino ethernet, le serial usb n’apparait pas naturellement,
à cause du wiznet. Il faut installer un FTDI serialdriverusb que vous
trouverez ici : http://hofmannsven.com/2012/laboratory/arduino-
ethernet/
Faites un test en «téléversant» un exemple de sketch que vous trouverez
dans le menu Fichier/exemples.
Le plus simple est d’utiliser Blink qui fera clignoter la LED sur le pin 13
(ou 9 pour l’arduino ethernet)
Si problème : http://arduino.cc/en/Guide/Troubleshooting#toc1
Connexion
Lorsqu’un Arduino démarre, il va lancer par défaut le dernier programme
téléchargé. Une petite partie logicielle sert de chargeur d’amorçage
et va vérifer si l’ordinateur nous envoie un autre programme. C’est le
bootloader.
S’il y a un nouveau code, l’arduino démarre le nouveau programme.
Sinon il répète l’ancien.
On ne touche quasiment jamais au bootloader, mais si on avait besoin
de modifer le système d’accès aux programmes (télécharger le
programme en wif par exemple), on peut trouver les méthodes sur
internet.
Pour modifer les préférences sur le bootloader :
http://arduino.cc/en/Hacking/Bootloader
Le démarrage
SOFTWARE
Le logiciel Arduino est d’un usage très simple.
On peut déjà programmer des actions à travers cet outil, mais pour ceux
qui ne savent pas programmer ou pour des codes plus complexes, on
peut télécharger des bibliothèques.
On crée un nouveau fchier, on sélectionne notre support arduino dans
la liste et notre serial port, on code l’information, on verife grâce au
correcteur, on envoie sur la carte arduino et le port sur lequel il est
branché réagit par un clignotement des LED. On peut vérifer sur le
terminal quelles informations ont été reçues par la carte.

Le logiciel
Les sketchs sont les programmes que l’on peut coder avec le logiciel
Arduino.
Conseil d’usage
Pour soi, il est parfois appréciable de pouvoir mettre des commentaires
pour décrire l’action attendue. Les notes s’écrivent ainsi :
/*
* Blink
*
* The basic Arduino example. Turns on an LED on for one second,
* then off for one second, and so on... We use pin 13 because,
* depending on your Arduino board, it has either a built-in LED
* or a built-in resistor so that you need only an LED.
*
* http://www.arduino.cc/en/Tutorial/Blink
*/
Tout ce qui se trouve entre /* et */ n’est pas pris en compte.
Un autre moyen est de l’écrire ainsi, avec // ceux-ci s’arrêtent à la fn
de la ligne.
int ledPin = 13; // LED connected to digital pin 13
Pour des raccourcis on peut utiliser des variables.
La variable pour une broche (pin) s’écrit ainsi :
int ledPin = 13
Plus tard, 13 sufra à signifer la LED.
Premier sketch
EXEMPLE
int ledPin = 13;
// LED connected to digital pin 13
void setup()
{
pinMode(ledPin, OUTPUT);
// sets the digital pin as output
}
void loop()
{
digitalWrite(ledPin, HIGH);
// sets the LED on
delay(1000); // waits for a
second
digitalWrite(ledPin, LOW);
// sets the LED off
delay(1000); // waits for a
second
}
Tous les sketchs doivent posséder deux lignes de code minimum : void
setup et void loop qui vont diférencier les fonctions d’initialisation et la
boucle principale du programme.
Il est nécessaire dans chaque sketch arduino d’intégrer les fonctions
setup() et loop(), même si on ne les utilise pas.
La fonction setup est appelée une fois au démarrage du programme,
elle permet d’intialiser des bibliothèques ou de paramétrer les pins.
La fonction loop est appelée en boucle tout le temps où l’arduino est
allumé.
void setup() indique les actions qui se lancent 1 fois et va contenir
souvent les variables à initialiser, les modes des pins et les bibliothèques.
Pour chaque pin qu’on va utiliser, il est nécessaire de spécifer dans
quel mode (input ou output) le pin est connecté pinMode() où pin =
numéro du pin
void loop() contient les actions qui tournent en continu.
if () va permettre de choisir de faire une action ou une autre selon une
condition. Exemple : if (température<0) {Serial.printin(«FROID»)
.write() ou digitalWrite() permet d’indiquer la valeur low ou high.
.printIn() permet de voir écrite une information sur le programme.
delay() laisse un temps d’attente.
On trouve une grande partie des éléments du langage sur ce lien :
http://arduino.cc/en/Reference/HomePage
void setup()
{
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}
void loop()
{
if (digitalRead(buttonPin) == HIGH)
Serial.write(‘H’);
else
Serial.write(‘L’);
delay(1000);
}
Langage
Les fonctions donnent les actions du code.
Voici un exemple d’écriture d’une fonction.
void setup()
{
pinMode(ledPin, OUTPUT); // sets the digital pin as output
}
Il faut dans un premier temps coder l’information liée à chaque broche,
pin. Sont-elles in or output ? Input, c’est une donnée extérieure que je
veux lire. Output, c’est une action que je veux faire.
digitalWrite(ledPin, HIGH) ;
digitalWrite() est la fonction qui permet de choisir la valeur d’une
broche. Ici en HIGH, elle correspond à 5 volts. S’il y avait écrit LOW,
elle correspondrait au ground, à une valeur de 0 volt.
On peut ajouter un délai pour demander à l’arduino de laisser un lapse
de temps entre deux actions. Pour laisser 1 seconde, il faut convertir
en milliseconde. On écrira la fonction delay() :
delay(1000) ;
Lorsqu’on touche à des programmes plus complexes, on trouve les
tutoriaux et codes sur les bibliothèques :
http://arduino.cc/en/Reference/Libraries
EXEMPLE
La LED s’allume en High, laisse
un délai de une seconde et
passe en of, Low.
int ledPin = 13;
// LED connected to digital pin 13
void setup()
{
pinMode(ledPin, OUTPUT);
// sets the digital pin as output
}
void loop()
{
digitalWrite(ledPin, HIGH);
// sets the LED on
delay(1000);
// waits for a second
digitalWrite(ledPin, LOW);
// sets the LED off
delay(1000);
// waits for a second
}
Fonction input et output
Lorsqu’il s’agit de récupérer les informations d’un capteur qui envoie
une donnée non-binaire, on passe par les broches analogiques. Voici
un exemple avec un potentiomètre.
On connecte deux broches en input et output et la dernière sur le 0 /
GND.
Il faut lire la valeur actuelle du capteur et la mettre dans une variable p
de type int(nombre entier). C’est une façon de déterminer la sensibilité
du capteur.
analogRead() renvoie une valeur entre 0 et 1024, qui correspond à la
tension qui arrive au pin.
int sensorValue = analogRead(A0);
Ensuite il faut pouvoir visionner les résultats du capteur en récupérant
une quantité décimale sur la fenêtre du programme avec la commande
Serial.println().
Serial.println(sensorValue, DEC)

/*
AnalogReadSerial
Reads an analog input on pin 0, prints the
result to the serial monitor.
Attach the center pin of a potentiometer
to pin A0, and the outside pins to +5V and
ground.

This example code is in the public domain.
*/
// the setup routine runs once when you press
reset:
void setup() {
// initialize serial communication at 9600 bits
per second:
Serial.begin(9600);
}
// the loop routine runs over and over again
forever:
void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// print out the value you read:
Serial.println(sensorValue);
delay(1); // delay in between reads for
stability
}
Programmer pour l’analogique
Pour se connecter à internet il est nécessaire de posséder un arduino
ethernet ou wif et de télécharger une bibliothèque ethernet.
L’adresse mac, est l’adresse «matérielle» de l’arduino sur le réseau.
Sur les versions récentes elle est écrite sur le Shield , sinon il faut en
choisir une au hasard. Autrement l’adresse IP de connexion s’obtient
en utilisant :
Ethernet.begin(mac), avec le réseau internet choisi. mac = Media
Access Control
Sur l’exemple à gauche on voit comment indiquer la connexion d’un
utilisateur.
On reconnait l’utilisateur :
EthernetClient client;
client.connect(«adressedusiteweb»,80)
On demande d’indiquer l’état de la connexion ethernet avec la fonction
Serial.printIn(«connecting..»)
Pour la connexion du client on entre une condition :
if (client.connect()) {
Serial.println(«connected»);
client.println(«GET /search?q=arduino HTTP/1.0»);
client.println();
}
Pour indiquer quand elle échoue:
else {
Serial.println(«connection failed»);
}
#include <Ethernet.h>
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF,
0xFE, 0xED };
byte ip[] = { 10, 0, 0, 177 };
byte server[] = { 64, 233, 187, 99 }; // Google
Client client(server, 80);
void setup()
{
Ethernet.begin(mac, ip);
Serial.begin(9600);
delay(1000);
Serial.println(«connecting...»);
if (client.connect()) {
Serial.println(«connected»);
client.println(«GET /search?q=arduino
HTTP/1.0»);
client.println();
} else {
Serial.println(«connection failed»);
}
}
void loop()
{
if (client.available()) {
char c = client.read();
Serial.print(c);
}
if (!client.connected()) {
Serial.println();
Serial.println(«disconnecting.»);
client.stop();
for(;;)
;
}
Se connecter en ethernet
EXERCICE
Sur le site Arduino.cc, on trouve les codes et tutoriaux pour réaliser de
simple projet avec l’arduino de base.
http://arduino.cc/en/Tutorial/HomePage
Pour tester les circuits on utilise les platines d’essai.

Premier projet
Voici un sketch qui permet de controler l’allumage d’une led grâce à un
bouton.
Il faut connecter les câbles power, rouge 5V et noir Gnd, ainsi que la
broche 2 côté digital.
Ce programme allume et éteint la LED intégrée du pin 13 lorsque l’on
appuie sur le bouton. Seul le bouton a besoin de recevoir le courant
électrique 5V depuis l’arduino.
// constants won’t change. They’re used here
to
// set pin numbers:
const int buttonPin = 2; // the number of
the pushbutton pin
const int ledPin = 13; // the number of
the LED pin
// variables will change:
int buttonState = 0; // variable for
reading the pushbutton status
void setup() {
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
}
void loop(){
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);
// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (buttonState == HIGH) {
// turn LED on:
digitalWrite(ledPin, HIGH);
}
else {
// turn LED off:
digitalWrite(ledPin, LOW);
}
}
Un bouton et une LED
La majorité de ces informations sont une traduction du site :
www.arduino.cc/
Les autres sites :
http://fr.wikipedia.org/wiki/Arduino
http://www.ladyada.net/learn/arduino/
http://video.mit.edu/watch/arduino-tutorial-1-10950/

Crédit
Assumed by Joshfre
Chloé Payot