Initiation Arduino
Vous avez dit Arduino ?
(extraits du manuel floss : [Link] )
Arduino est une plate-forme de prototypage d'objets interactifs à usage créatif
constituée d'une carte électronique et d'un environnement de programmation.
Sans tout connaître ni tout comprendre de l'électronique, cet environnement matériel
et logiciel permet à l'utilisateur de formuler ses projets par l'expérimentation directe
avec l'aide de nombreuses ressources disponibles en ligne.
Pont tendu entre le monde réel et le monde numérique, Arduino
permet d'étendre les capacités de relations humain/machine ou
environnement/machine.
Arduino est un projet en source ouverte : la communauté
importante d'utilisateurs et de concepteurs permet à chacun de
trouver les réponses à ses questions.
Matériel
1
La carte Arduino repose sur un circuit intégré (un mini ordinateur
appelé également micro-contrôleur) associée à des entrées et
sorties qui permettent à l'utilisateur de brancher différents types
d'éléments externes.
Il existe un grand nombre de variantes :
le Lilipad, pour fixer sur des vêtements, le RBBB qui est une
carte très petite et économique etc...
[Link]
le Teensy, ne fait pas proprement partie des cartes Arduino, mais
on peut le programmer à partir de l'environnement Arduino. Son
processeur est plus puissant, les E/S sont plus nombreuses, il est
minuscule et on peut disposer d'un interface USB MIDI natif...
[Link]
La série Mapple (et compatibles) est
une plateforme 100 fois plus
puissante. La programmation est
similaire à celle de l'Arduino.
Logiciel
L'environnement de programmation
Arduino (IDE en anglais) est une
application écrite en Java inspirée du
langage Processing.
L'IDE permet d'écrire, de modifier un
programme et de le convertir en une
série d'instructions compréhensibles
pour la carte.
Quelques exemples d'applications :
[Link]
electronique/
New : pour créer un nouveau programme (sketch).
Open : ouvrir un programme existant. Le menu n'est pas déroulant à cause d'un
bug...pour obtenir un menu déroulant passer par file/open
Save : sauvegarde le programme, si vous voulez le sauvegarder sous un autre nom, passer
par file/save as
Serial Monitor : pour ouvrir la fenêtre qui permet de visualiser les données
transmise par le port série de l'Arduino (très pratique pour le débogage...)
2
historique
D'après Wired Magazine :
Le projet Arduino est né en hiver 2005. Massimo Banzi enseigne dans une école de
Design à Ivrea en Italie, et souvent ses étudiants se plaignent de ne pas avoir accès à
des solutions bas prix pour accomplir leurs projets de robotique. Banzi en discute avec
David Cuartielles, un ingénieur Espagnol spécialisé sur les micro-contrôleurs…
Ils décident de créer leur propre carte en embarquant dans leur histoire un des
étudiant de Banzi, David Mellis qui sera chargé de créer le langage de
programmation allant avec la carte. En deux jours David écrira le code! Trois jours de
plus et la carte était crée…Ils décidèrent de l’appeler Arduino (un bar fréquenté par
les élèves à proximité de l’école)…
Ca devient un hit tout de suite auprès des étudiants. Tout le monde arrive à en faire
quelquechose très rapidement sans même avoir de connaissances particulière ni en
électronique ni en informatique: réponse à des capteurs, faire clignoter des leds,
contrôler des moteurs… Ils publient les schémas, investissent 3000 euros pour créer le
premier lots de cartes: 200.
Les 50 premières partent directement à des élèves de l’école. En 2006 5 000 cartes
vendues…En 2007 plus de 30 000! en 2011 : >120 000, sans compter les clones !
Prototype de l'Arduino.
3
Structure d'un programme
Le programme est lu par le micro-contrôleur de haut vers le
bas. Une variable doit être déclarée avant d'être utilisée
par une fonction.
La structure minimale est constituée :
– en tête : déclaration des variables, des constantes, indication de
l'utilisation de bibliothèques etc...
– un setup (= initialisation) cette partie n'est lue qu'une seule fois, elle comprend
les fonctions devant être réalisées au démarrage (utilisation des broches en
entrées ou en sortie, mise en marche du midi, du port série de l' I2C etc )
– une loop (boucle) : cette partie est lue en boucle ! C'est ici que les fonctions sont
réalisées.
En plus de cette structure minimale, on peut ajouter :
– des « sous-programmes » ou « routines » qui peuvent être appelées à tous
moments dans la boucle, très pratiquer pour réaliser des morceaux de codes
répétitifs.
– Des « callbacks », ce sont des fonctions qui sont rappelées automatiquement
depuis une bibliothèque.
4
référence :
Structure
Fonctions de base Structures de contrôle Syntaxe de base
Ces deux fonctions sont • if • ; (point virgule)
obligatoires dans tout • if...else • {} (accolades)
programme en langage • for • // (commentaire sur
Arduino une ligne)
• switch case
• /* */ (commentaire
• while sur plusieurs
• void setup() • do... while lignes)
• void loop() • break • #define
• continue • #include
• return
• goto
Opérateurs arithmétiques
Opérateurs de Opérateurs booléens
comparaison
• = (égalité) • && (ET booléen)
• + (addition) • == (égal à) • || (OU booléen)
• - (soustraction) • != (différent de) • ! (NON booléen)
• * (multiplication) • < (inférieur à)
• / (division) • > (supérieur à)
• % (modulo) • <= (inférieur ou égal
à)
• >= (supérieur ou
égal à)
Pointeurs Opérateurs bit à bit Opérateurs composés
• * pointeur • & (ET bit à bit) • ++ (incrémentation)
• & pointeur • |(OU bit à bit) • --
• ^(OU EXCLUSIF bit (décrémentation)
à bit) (à revoir)
Voir également :
• ˜(NON bit à bit) • += (addition composée)
• Manipulation des • -=
• << (décalage à (soustraction
Ports
gauche) composée)
• >> (décalage à • *= (multiplication
droite) composée)
• /= (division
composée)
• &= (ET bit à
bit composé)
• |= (OU bit à
bit composé)
5
Variables et constantes
Les variables sont des expressions que vous pouvez utilisez dans les programmes
pour stocker des valeurs, telles que la tension de sortie d'un capteur présente sur une
broche analogique.
Constantes prédéfinies Types des données Conversion des types
Les constantes prédéfinies Les variables peuvent de données
du langage Arduino sont être de type variés qui • char()
des valeurs particulières sont décrits ci- dessous. • byte()
ayant une • int()
signification spécifique.
• long()
Synthèse des types de
• float()
• HIGH | LOW données Arduino
• word()
• INPUT | OUTPUT • boolean
• true | false • char
• byte Portée des variables et
A ajouter : constantes • int qualificateurs
décimales prédéfinies • unsigned int
• long • Portée des variables
Expressions • unsigned long • static
numériques • float • volatile
(nombres à • const
• Expressions virgules)
numériques • double
entières (nombres à
• Expressions virgules) Utilitaires
numériques à
virgule • Les chaînes de • sizeof()
caractères (opérateur
• objet String NEW sizeof )
• Les tableaux de
variables
• le mot-clé void Référence
(fonctions)
• Code ASCII
• word
• PROGMEM
Voir également :
• Déclaration
des variables
Pour info : les types de
données avr-c
6
Fonctions
Entrées/Sorties Temps Trigonométrie
Numériques
• unsigned long millis() • sin(rad)
• pinMode(broche, • unsigned long • cos(rad)
mode) micros() • tan(rad)
• digitalWrite(broc • delay(ms)
he, valeur) • delayMicroseconds(us
• int ) Bits et Octets
digitalRead(broche) • lowByte()
• highByte()
Entrées analogiques Math • bitRead()
• int • min(x, y) • bitWrite()
analogRead(broche) • max(x, y) • bitSet()
• analogReference(type • abs(x) • bitClear()
) • constrain(x, a, b) • bit()
• map(valeur,
Sorties "analogiques" toLow,
(génération fromHigh, Interruptions Externes
toLow, toHigh)
d'impulsion) • attachInterrupt(interr
• pow(base, exposant) upti on, fonction,
• analogWrite(broc • sq(x) mode)
he, valeur) - PWM
• sqrt(x) • detachInterrupt(inter
rupt ion)
Entrées/Sorties Pour davantage de
Avancées fonctions mathématiques,
• tone() voir aussi la librairie Interruptions
• noTone() math.h : log, log10, asin,
• interrupts()
• shiftOut(broch atan, acos, etc...
• noInterrupts()
e,
BrocheHorloge
, OrdreBit, Nombres randomisés Voir également la librairie
valeur) (hasard) interrupt.h.
• unsigned long
pulseIn(broche, • randomSeed(seed)
valeur) • long random(max)
• long random(min,
Communication
max)
• Serial
[Link]
les bibliothèques (librairies).
Les utilisateurs les plus avertis concoctent des bibliothèques pour interfacer, le plus
simplement possible, une vaste diversité de composants (I2C, SPI...) et de
fonctionnalités (MIDI, Ethernet, OSC...)
Sans ces bibliothèques, la programmation serait vraiment plus complexe ! À utiliser
sans modération.
7
Les bibliothèques doivent être installées dans le répertoire « libraries » et doivent
être inclues dans le programme (exemple : #include <MIDI.h> ).
8
Démarrer avec Arduino sous Windows
1 | Obtenir une carte Arduino et un câble USB
2 | Télécharger l'environnement Arduino
Télécharger le fichier ici :
[Link] décompresser le
fichier et le copier dans « mes documents »
3 | Raccorder la carte à l'ordinateur
La diode verte doit s'allumer.
4 | Installation des pilotes du périphérique Série-USB
– lors d'un premier raccordement d'une carte UNO à l'ordinateur, ce dernier
recherche automatiquement un pilote. Après quelques instants, l'ordinateur
va indiquer qu'il n'a pas trouvé de pilote...
– ouvrir « executer » en passant par le menu démarrer
– taper [Link] et taper sur la touche « entrée »
– Chercher et déployer la rubrique « ports (COM et LPT).
– Il doit apparaître une ligne «Arduino UNO (COMxx) »
– faire un click droit sur «Arduino UNO (COMxx) » et choisir « mettre à jour le pilote... ».
– Choisir « rechercher un pilote sur mon ordinateur »
– selectionner le fichier "[Link]", qui se trouve dans le repertoire «
drivers » de l'installation de l'Arduino...
• Windows va terminer l'installation des pilotes.
5 | Lancer l'aplication Arduino
Double -cliquer sur
9
6 | Ouvrir l'exemple « blink »
Ouvrir le programme (sketch)
File > Examples > [Link] > Blink.
1
0
7 | choisir la carte UNO
8 | sélectionner le port série
Choisir le port série qui est utilisé par la carte arduino : tools > serial port > …
pour connaître quel port série est utilisé par la carte Arduino, lancer le gestionnaire de
périphérique (voir item 4).
9 | charger le programme dans la carte Arduino
Cliquer sur la touche « upload »
après quelques secondes, la LED orange qui est raccordée à la broche 13 devrait
clignoter. En cas de problème : troubleshooting suggestions.
The text of the Arduino getting started guide is licensed under a Creative Commons
Attribution- ShareAlike 3.0 License. Code samples in the guide are released into the
public domain.
1
1
Confronter la théorie à l'épreuve de la réalité...
La carte Arduino est une petite chose fragile, il convient de bien
en comprendre ses limites d'utilisation et vérifier la
compatibilité avec les matériels que l'on souhaite y raccorder...
Tension :
le microcontrôleur placé sur la carte est prévu pour
fonctionner entre 3,3V et 5V.
Intensité :
le courant de sortie de chaque broche (D0 à D13) ne doit pas
dépasser 40mA
le courant issu du port USB ne doit pas dépasser 500mA
le courant soutiré à la broche « 3,3V » ne doit pas dépasser 50mA
exemple :
on souhaite actionner un moteur de 6W sous 5V par l'Arduino, alimenté par l'USB,
est-ce réalisable ?
P = U.I => I = P/U => I = 1,2A
Au niveau du port USB ?
Au niveau d'une broche de sortie ?
1
2
Schémas de référence
LED :
Une diode électroluminescente (DEL ou LED ) est un composant opto-
électronique capable d’émettre de la lumière lorsqu’il est parcouru par
un courant électrique.
Une diode électroluminescente ne laisse passer le courant électrique
que dans un seul sens (le sens passant).
lorsqu'elle est traversée par un courant, la LED oppose une tension fixe
– 1,9V pour une LED rouge,
– 3,2V pour les diodes blanches, ou autres couleurs
– voir les notices des diodes avant d'utiliser.
Le courant dans la LED est aussi limité :
pour les LED ordinaires de 5mm, 24mA environ.
Certaines LED munies de 5 élèments dans un même boitier absorbe jusqu'à 100mA.
(ces LED ne peuvent donc pas être directement commandées par une sortie
d'Arduino...)
raccordement à l'Arduino :
calcul de la résistance de protection :
tension d ' alimentation−tension LED
R= intensité en Ampère
Exemple : pour une diode rouge, l'Arduino alimenté
en 5V : R =
1
3
bouton, interrupteur :
Remarque : lorsque le bouton n'est pas actionné, la broche 5 est « en l'air », le fil va se
comporter comme une antenne de radio et l'état de la broche va varier en
permanence. Il faut donc que le niveau logique de la broche d'entrée soit fixé en
permanence. Pour cela on met en oeuvre une résistance de « pullup » qui va tirer le
potentiel de la broche vers le 5V, lorsque le bouton est au repos.
Void setup() {
pinMode(4, INPUT); // la broche 5 se comporte comme une entrée
digitalWrite(4, HIGH); // une résistance est raccordée entre la broche 5 et le+5V dans le
microcontrolleur
}
void loop() {
…
if(digitalRead(4) == LOW) // attention, logique négative...
{
//faire quelque chose lorsqu'on appuie sur le bouton.
}
}
1
4
moteur :
Les moteur électriques à courant continu consomment trop de courant pour être
commandés directement par une broche de l'Arduino, de plus ils sont inductifs : ils
créent des surtensions à leurs bornes, il faut donc protéger le montage avec une
diode de roue libre.
Il en va de même avec les relais.
On peut aussi utiliser un transistor à effet de champ type N : par exemple IRF Z34N
Servomoteur :
Un servomoteur est constitué d'un moteur,
d'un capteur de position et d'un régulateur
électronique. Le fonctionnement du moteur est
asservi à la position de l'axe.
On le commande en lui indiquant quel angle
doit prendre son axe (entre 0 et 180°) le
moteur se met alors en marche jusqu'à ce que
la position soit atteinte.
En utilisant une bibliothèque toute faite : #include
<Servo.h>
il devient très simple de mettre en œuvre des
servomoteurs de modélisme.
Raccordemen
t : marron :
masse
rouge : +5V
orange : commande, à raccorder à une broche de
sortie de l'Arduino
1
5
potentiomètre, utilisation des entrées analogiques
interface I2C :
1
6
Entrée midi
Sortie midi :
1
7
les liens :
[Link]
n=[Link]
[Link]
n=[Link]
[Link]
[Link]
licence : CC
sources : [Link]
1
8