Cours Arduino v0.2

Cours dinitiation Arduino ASTUPS - CampusFab LECHALUP Julien

Universit Paul Sabatier Mai 2014

Cours dinitiation Arduino


UPS ASTUPS - CampusFab 1

Sommaire

Introduction ................................................................................................................................ 2

I) Prsentation de la carte ..................................................................................................... 4

A) Quest ce quun microcontrleur ............................................................................. 4

B) Caractristiques techniques de lArduino UNO ....................................................... 4

C) Un atout : les shields ................................................................................................ 5

II) Prsentation du logiciel ...................................................................................................... 6

A) IDE Arduino .............................................................................................................. 6

B) Langage Arduino ...................................................................................................... 7

III) Fonctionnalit de base ..................................................................................................... 12

A) Les entres/sorties ................................................................................................. 12

B) La gestion du temps ............................................................................................... 14

C) Les Interruptions .................................................................................................... 15

IV) Pratique ......................................................................................................................... 17

A) Hello LED ................................................................................................................ 17

B) Push the button ..................................................................................................... 17

C) Turn the potentiometer ......................................................................................... 17

D) Corrections ............................................................................................................. 18

V) Quelques librairies............................................................................................................ 22

Conclusion ................................................................................................................................ 24



Introduction

Ce cours pour but de prsenter et dinitier lutilisation dArduino. Les cartes

Arduino sont conues pour raliser des prototypes et des maquettes de cartes lectroniques

pour linformatique embarque.

Ces cartes permettent un accs simple et peu couteux linformatique embarque. De

plus, elles sont entirement libres de droit, autant sur laspect du code source (Open Source)

que sur laspect matriel (Open Hardware). Ainsi, il est possible de refaire sa propre carte

Arduino dans le but de lamliorer ou denlever des fonctionnalits inutiles au projet.

Le langage Arduino se distingue des langages utiliss dans lindustrie de linformatique

embarque de par sa simplicit. En effet, beaucoup de librairies et de fonctionnalits de

base occulte certains aspects de la programmation de logiciel embarque afin de gagner en

simplicit. Cela en fait un langage parfait pour raliser des prototypes ou des petites

applications dans le cadre de hobby.

Les possibilits des cartes Arduino sont normes, un grand nombre dapplication ont

dj t ralise et testes par bon nombre dinternautes. On retrouve par exemple diverse

forme de robot (voir Fig.1), des stations mto (voir Fig.2). Dautres exemples dapplications

sont disponibles sur le web aux adresses suivantes :

http://www.hackaday.com/category/arduino-hacks/

http://www.instructables.com/tag/type-id/category-technology/channel-arduino/



Figure 1 - Robot Arduino http://hackaday.com/2014/04/28/opensource-rhinobot-is-well-suited-for-hacking-and-sumo-robotics/

Figure 2 - Station mto http://www.instructables.com/id/Google-Weather-on-graphical-display-with-Arduino/



I) Prsentation de la carte

A) Quest ce quun microcontrleur

Les cartes Arduino font partie de la famille des microcontrleurs. Un microcontrleur

est une petite unit de calcul accompagn de mmoire, de ports dentre/sortie et de

priphriques permettant dinteragir avec son environnement. Parmi les priphriques, ont

recense gnralement des Timers, des convertisseurs analogique-numrique, des liaisons

Sries, etc. On peut comparer un micro contrleurs un ordinateur classique, mais systme

dexploitation et avec une puissance de calcul considrablement plus faible.

Les microcontrleurs sont invitables dans les domaines de linformatique embarque,

de lautomatique et de linformatique industrielle. Ils permettent de rduire le nombre de

composant et de simplifier la cration de cartes lectroniques logiques.

B) Caractristiques techniques de lArduino UNO

Un des modles les plus rpandu de carte Arduino est lArduino UNO (voir Fig.3). Cest

la premire version stable de carte Arduino. Elle possde toutes les fonctionnalits dun

microcontrleur classique en plus de sa simplicit dutilisation.

Elle utilise une puce ATmega328P [1] cadence 16Mhz. Elle possde 32ko de

mmoire flash destine recevoir le programme, 2ko de SRAM (mmoire vive) et 1 ko

dEEPROM (mmoire morte destine aux donnes). Elle offre 14 pins (broches)

dentre/sortie numrique (donnes accepte 0 ou 1) [2] dont 6 pouvant gnrer des PWM

(Pulse Width Modulation, dtaill plus tard). Elle permet aussi de mesurer des grandeurs

analogiques grce ces 6 entres analogiques [3]. Chaque broche est capable de dlivr un

courant de 40mA pour une tension de 5V.

Cette carte Arduino peut aussi salimenter et communiquer avec un ordinateur grce

son port USB [4]. On peut aussi lalimenter avec unes alimentions comprise en 7V et 12V

grce sa connecteur Power Jack [5].



Figure 3 - Arduino UNO

C) Un atout : les shields

Pour la plupart des projets, il est souvent ncessaire dajouter des fonctionnalits aux

cartes Arduino. Plutt que dajouter soit mme des composants extrieurs (sur une platine

dessai, circuit imprim, etc.), il est possible dajouter des shields. Un shield est une carte

que lon connecte directement sur la carte Arduino qui a pour but dajouter des composants

sur la carte. Ces shield viennent gnralement avec une librairie permettant de les contrler.

On retrouve par exemple, des shields Ethernet, de contrle de moteur, lecteur de carte SD,

etc.

Le principal avantage de ces shields est leurs simplicits dutilisation. Il suffit des les

emboiter sur la carte Arduino pour les connecter, les circuits lectronique et les logiciels sont

dj faits et on peut en empiler plusieurs. Cest un atout majeur pour ces cartes pour

pouvoir tester facilement de nouvelles fonctionnalits. Cependant il faut bien garder

lesprit que les shields ont un prix. Suivant les composants quils apportent, leurs prix

peuvent aller de 5 100 !



II) Prsentation du logiciel

A) IDE Arduino

Un IDE (environnement de dveloppement) libre et gratuit est distribu sur le site

dArduino (compatible Windows, Linux et Mac) ladresse

http://arduino.cc/en/main/software. Dautres alternatives existent pour dvelopper pour

Arduino (extensions pour CodeBlocks, Visual Studio, Eclipse, XCode, etc.) mais nous

naborderons dans ce cours que lIDE officiel.

Linterface de lIDE Arduino est plutt simple (voir Fig.4), il offre une interface

minimale et pure pour dvelopper un programme sur les cartes Arduino. Il est dot dun

diteur de code avec coloration syntaxique [1] et dune barre doutils rapide [2]. Ce sont les

deux lments les plus importants de linterface, cest ceux que lon utilise le plus souvent.

On retrouve aussi une barre de menus [3] plus classique qui est utilis pour accder aux

fonctions avances de lIDE. Enfin, une console [4] affichant les rsultats de la compilation

du code source, des oprations sur la carte, etc.



Figure 4 - IDE Arduino

B) Langage Arduino

Le langage Arduino est inspir de plusieurs langages. On retrouve notamment des

similarits avec le C, le C++, le Java et le Processing. Le langage impose une structure

particulire typique de linformatique embarque. La fonction setup contiendra toutes les

oprations ncessaires la configuration de la carte (directions des entres sorties, dbits de

communications srie, etc.). La fonction loop elle, est excute en boucle aprs lexcution

de la fonction setup. Elle continuera de boucler tant que la carte nest pas mise hors tension,



redmarre (par le bouton reset). Cette boucle est absolument ncessaire sur les

microcontrleurs tant donn quil non pas de systme dexploitation. En effet, si lon

omettait cette boucle, la fin du code produit, il sera impossible de reprendre la main sur la

carte Arduino qui excuterait alors du code alatoire.

Au niveau de la syntaxe, on retrouve des similarits avec les langages prcdemment

cits. La dclaration des variables se fait gnralement dans lespace global (de faon

partager les variables les plus importantes entre les deux fonctions principales). On retrouve

les types de base suivant :

Nom Contenu Taille (en octet) Plage de valeurs

(unsigned) char Entier ou caractre 1 (0->255) -128 -> 127

(unsigned) int Entier 2

(0->65 535)

-32 768 -> 32 767

(unsigned) long Entier

4

(0 -> 4 294 967 295)

-2 147 483 648 ->

2 147 483 647

float/double Nombre virgule

flottante 4

-3,4028235E+38 ->

3,4028235E+38

String Chaine de caractres

(Objet) variable Aucune

boolean Boolen 1 True / False

Il existe dautres types de base mais ils ne sont quun alias de ceux cits

prcdemment, la liste des types est disponible sur la page des rfrences du site Arduino

(http://arduino.cc/en/Reference/HomePage). La dclaration des variables suit cette syntaxe:

(const) ([]) (= valeur);

Exemples :



const int constante = 12 ;

float univers = 42.0 ;

char lettre = b ;

String chaine = "Hello World " ;

long tableau[12] ;

boolean vrai = true ;

On retrouve les oprateurs les plus courants pour les types de bases. Parmi eux, =

(affectation), == (comparaison), != (diffrence), , =, && (et logique), || (ou

logique), ! (non logique). On retrouve aussi les oprateurs mathmatiques (+, -, *, /, %) et les

oprateurs logiques bit bit (^ (XOR), & (et), | (ou), ~(non), > (dcalage logique droite)).

Les structures de contrle sont elles aussi similaires aux langages de rfrences. On y

retrouve toutes les structures de contrle standard, conditions, boucle, switch, fonctions,

etc. On peut aussi crire des structures et des classes. Chaque structure de contrle est

suivie dun bloc dinstructions dlimites par des accolades. Voici une liste des structures de

contrles les plus utilises :

Nom Utilit Syntaxe

If-else Condition logique If ( ) {

} else {

}



If-else if - else Condition logique multiples If ( ) {

} else if () {

} else {

}

Switch Slecteur Switch ( ) {

case :

break ;

default :

}

While Boucle While () {

}

For Boucle itrative For ( ; ; ) {

}

Voici quelques exemples dutilisation de structure de contrle.

If ( variable < 2 ){

switch (variable) {

case 1 :

doSomething(10) ;

break ;

case 0 :

doSomething(1) ;

default :



doSomething(0) ;

}

} else if ( variable > 4 ) {

while ( variable != 10 ) {

variable = doSomethingElse(variable-1) ;

}

} else {

for ( int i = 0 ; i < 10 ; i++ ) {

variable = variable *2 ;

}

}

Les fonctions, les structures et les classes se dclarent de la mme faon quen C++.

Elles se dclarent sous cette forme :

Structure :

struct {

;

} ;

Fonction :

() {

}

Classe :

class {

public :

private :

protected :



} ;

III) Fonctionnalit de base

A) Les entres/sorties

Le langage Arduino vient avec un nombre important de fonction de base permettant

dinteragir avec son environnement. Les fonctions les plus utilise sont les fonctions

dentre/sorties. Ce sont elles qui permettent denvoyer ou de mesurer une tension sur une

des broches de la carte.

Dans un premier temps, avant deffectuer une mesure ou denvoyer une commande. Il

est ncessaire de dfinir la direction des broches utilises. Pour cela on fait appel la

fonction pinMode en lui donnant dune part, la broche concerne, et dautre part, la

direction :

void setup() {

pinMode(1,OUTPUT) ; // Broche 1 en sortie

pinMode(2,INPUT) ; // Broche 2 en entre

}

Une fois cette configuration faite, on peut procder lutilisation des broches. Toutes

les broches sont capables dcrire et de lire des donnes numriques (c'est--dire des 0 (0V)

ou des 1 (5V)). Mais, certaines disposent de fonctionnalit supplmentaire.

Tout dabord, toutes les cartes Arduino possdent des entres analogiques. Ce sont

les broches A0-A1-A2 etc. Elles permettent de lire des tensions analogiques (comprise entre

0 et 5V) et de le convertir en entier (compris entre 0 et 1023) proportionnellement la

tension mesure. Certaines cartes Arduino possde des sorties analogique faisant

lopration inverse (met une tension sur la broche proportionnellement lentier donn),

mais ce nest pas le cas pour lArduino UNO.



Pour pouvoir tout de mme contrler des composants autrement quen tout ou

rien il est possible dutiliser des broches PWM. Ce sont les broches annots par un tilde ~

sur la carte. Les PWM (Pulse Width Modulation) sont utilises pour synthtiser des signaux

analogiques en modulant le temps pass ltat 1 (5V). Le signal obtenu est reprsent

figure 5. En utilisant une frquence relativement leve, les PWM permettent de

commander certains composants comme si il recevait une tension analogique. Cela provient

du fait que les composants utiliss dans llectronique analogique, ne changes pas dtats

instantanment. Par exemple, une ampoule incandescence reste chaude et claire un

court instant aprs avoir t teinte. Ce phnomne est gnralement invisible lil nu.

Grce elles, on pourra par exemple faire varier lintensit dune LED. La plupart des cartes

Arduino utilisent des PWM cadences 490Hz environ.

Toutes ces fonctionnalits sur les broches dentres sorties sont utilisables par le biais

de quatre fonctions :

digitalRead(pin) : mesure une donne numrique sur une des broches, la broche en

question doit tre rgle en entre.

digitalWrite(pin, value) : crit une donne numrique sur une des broches, la broche

concerne doit tre rgle en sortie. Le paramtre value doit tre gal HIGH (tat 1

soit 5V) ou LOW (tat 0 soit 0V).

analogRead(pin) : mesure une donne analogique sur une des broches (compatible

seulement), la broche doit tre rgle sur entre.

analogWrite(pin, value) : crit une donne sous forme de PWM sur une des broches

(compatible uniquement), la broche doit tre rgle en sortie. Le paramtre value

doit tre compris dans lintervalle [0;255]



Figure 5 - Signal PWM

B) La gestion du temps

Pour la plupart des applications de domotique, il est ncessaire de faire intervenir des

intervalles de temps. Par exemple, pour grer le temps dappui sur un bouton ou pour faire

une sonnerie qui se rpte un certains nombre de fois. Le langage Arduino fournis quelques

fonctions permettant de grer le temps.

Il est possible dinsrer une pause dans son programme pendant un instant. Pour cela,

on utilise les fonctions delay et delayMicroseconds qui insre une pause suivant le

paramtre pass (en milliseconde pour lun, en microseconde pour lautre). Cependant ces

fonctions bloquent le microcontrleur, on ne peut alors plus effectuer aucune action.

En plus dinsrer une pause, il est possible de mesurer le temps. De la mme manire

que les fonctions de dlai, on utilise les fonctions millis et micros qui donnent le nombre de

milliseconde (respectivement microseconde) depuis le lancement de la carte. Attention, ces

fonctions incrmente une variable (interne). Ces variables se remettent zro une fois le

maximum atteint (overflow). La variable utilise pour les millisecondes atteint sont

maximum au bout de 49 jours et 17 heures et la variable utilise pour les microsecondes au

bout de 71 minutes et 34 secondes environ. Il faut donc faire attention lors de lutilisation de

ces fonctions pour des utilisations longues dures.



C) Les Interruptions

Il est parfois ncessaire en informatique embarque, dattendre un vnement

externe (appui sur un bouton, donnes dun capteur, etc.) pour effectuer une action. Pour ce

type de problme, on utilise les interruptions. Les interruptions sont des portions de code

(fonctions) appels lorsque quun vnement (interne ou externe) survient et besoin

dtre trait sur le champ. Il faut cependant faire attention, ce mcanisme interrompt le

code excut, il est prioritaire par rapport au reste du code. Vu quil est possible de mesurer

les vnements ponctuellement (via les fonctions dentres/sorties) on utilise gnralement

les interruptions pour du code critique (arrt durgence par exemple) ou des vnements

non-ponctuels (transmissions de donnes depuis un ordinateur par exemple).

Aussi, le nombre dinterruption externe est limit sur 2 sur la plupart des cartes

Arduino. Les interruptions sont utilisables sur les broches compatibles seulement (broches 2

et 3 sur lArduino UNO). Pour choisir la fonction et la broche utilise pour linterruption, on

utilise la fonction attachInterrupt. On peut utiliser detachInterrupt pour supprimer

linterruption. Il est possible de partir en interruptions sur 4 types dvnements :

LOW : Lorsque la broche est ltat 0 (0V)

RISING : Lorsque la broche passe de ltat 0 (0V) ltat 1 (5V) (front montant).

FALLING : Lorsque la broche passe de ltat 1 (5V) ltat 0 (0V) (front descendant).

CHANGE : Lorsque la broche change dtat (front montant et front descendant).

Voici un exemple dutilisation :



volatile boolean etat = false ;

void appuiBouton() {

etat = !etat ; // Changement dtat

}

void setup() {

pinMode(2,INPUT) ; // Broche 2 en entre

attachInterrupt(0,appuiBouton,RISING) ; // On attache linterruption 0 (broche 2) la

fonction appuiBouton sur un front montant

}

On remarque lapparition du mot clef volatile avant la dclaration de la variable etat.

Ce mot clef est ncessaire pour toutes les variables qui sont modifie dans une interruption.

Cela une incidence sur la manire dont le compilateur traite laccs la variable.

Il est parfois ncessaire de dsactiver temporairement les interruptions par exemple

lorsque lon excute du code critique (activation dun moteur, etc.). Deux fonctions

permettent de changer lactivation des interruptions interrupts et noInetrrupts pour activer

(respectivement dsactiver) les interruptions.



IV) Pratique

A) Hello LED

Nous allons maintenant passer la pratique. Pour cette premire manipulation, il est

demand de faire clignoter une LED de faon rgulire. Vous pouvez soit utiliser une LED

avec une rsistance en srie sur une breadboard. Ou alors, vous pouvez utiliser la LED

directement sur lArduino (broche 13 sur la carte Arduino UNO).

Si vous souhaitez plus de difficult, essayer de faire ce mme programme en utilisant

la fonction millis plutt que delay.

B) Push the button

Maintenant, nous allons exprimenter la mesure sur une des broches. Le but est

dallumer une LED selon si un bouton est enfonc ou non. Pour le cblage du bouton, il est

ncessaire dy mettre en srie une rsistance reli la masse. Cela pour but dviter les

court circuits lorsque le bouton est enfonc.

Ici aussi, on peut augmenter la difficult en utilisant les interruptions plutt que la

lecture directe de la broche.

C) Turn the potentiometer

Pour terminer, nous allons nous intresser aux fonctions analogiques . Il est

maintenant question dallumer une LED et de faire varier son intensit en fonction de la

position dun potentiomtre.

Pour augmenter la difficult, on pourrait ajouter quelques LEDs et dterminer la LED

allume allumer en fonction de la valeur du potentiomtre en plus de faire varier leurs

intensits.



D) Corrections

Hello LED

Code avec delay :

const int pinLed = 13;

void setup()

{

pinMode(pinLed, OUTPUT); // Broche 13 en sortie

}

void loop()

{

delay(500); // Attente d'une demi seconde

digitalWrite(pinLed, HIGH); // Allumage de la LED

delay(500);

digitalWrite(pinLed, LOW); // Eteignage de la LED

}

Code avec millis :


int temps;

int etat;

void setup()

{


etat = LOW; // LED teinte

}

void loop()

{

int present = millis();

if ( temps+500 < present ) // Vrification du chronomtre

{

temps = present; // Actualisation du chronomtre

etat = !etat; // Changement d'tat

digitalWrite(pinLed,etat); // Changement d'tat de la LED

}

}

Push the button

Code sans interruptions :


const int pinBouton = 2;

void setup()

{




pinMode(pinBouton, INPUT); // Broche 2 en entre

}

void loop()

{

int etat = digitalRead(pinBouton); // On lit la valeur du bouton

digitalWrite(pinBouton,etat); // On allume (ou non) la LED

delay(50); // On peut mettre un delay pour viter les allumages

// intenpestifs

}

Code avec interruption :


const int pinBouton = 2;

volatile int temps;

volatile boolean etat;

void interruption()

{

int present = millis(); // Lecture du chronomtre

// Attention, la valeur de millis() NE VARIE PAS

// pendant une interruption ! On l'utilise ici

// seulemnt pour viter un changement d'tat

// intempestif

if ( temps+100 < present ) // Vrification du chronomtre

{

etat = !etat; // Changement d'tat

temps = present;

}

}

void setup()

{


pinMode(pinBouton, INPUT); // Broche 2 en entre

attachInterrupt(0,interruption, CHANGE); // Mise en place de

l'interruption

}

void loop()

{

}

Turn the potentiometer

Code pour une LED :


const int pinPotar = A0;

void setup()

{

pinMode(pinLed, OUTPUT); // Broche 11 en sortie (broche PWM)



pinMode(pinPotar, INPUT); // Broche A0 en entre (broche analogique)

}

void loop()

{

int valeur = analogRead(pinPotar); // Lecture de la valeur du

potentiomtre

valeur = map(valeur,0,1023,0,255); // Change l'intervalle de valeur

[0;1023]->[0;255]

analogWrite(pinLed,valeur); // criture sur la broche 11 en PWM

delay(50);

}

Code pour plusieurs LEDs (3):

const int pinLed[3] = {9,10,11};

const int pinPotar = A0;

const int nbLed = 3;

void setup()

{

for ( int i = 0 ; i < nbLed ; i++ )

{

pinMode(pinLed[i], OUTPUT); // Broche LED en sortie (broche PWM)

}

pinMode(pinPotar, INPUT); // Broche A0 en entre (broche analogique)

}

void loop()

{

int valeur = analogRead(pinPotar); // Lecture de la valeur du

potentiomtre

int ledCourante;

valeur = map(valeur,0,1023,0,255); // Change l'intervalle de valeur

[0;1023]->[0;255]

if ( valeur < 85 ) // Choix de la LED

{

ledCourante = 0;

}

else if ( valeur < 170 )

{

ledCourante = 1;

}

else

{

ledCourante = 2;

}

for ( int i = 0 ; i < nbLed ; i++ ) // Allumage de la led donne

{

if ( i == ledCourante )

{

// Allumage de la LED correspondante en fonction de la tension



// lue sur le potentiomtre

analogWrite(pinLed[i],(valeur%(85))*3);

}

else

{

analogWrite(pinLed[i],0);

}

}

delay(50);

}



V) Quelques librairies

En plus de la simplicit du langage et des nombreuses fonctionnalits quoffre. LIDE

vient avec un nombre important de librairies vitant ainsi dimplmenter des fonctions

courantes dans linformatique embarque.

Une des librairies les plus utilise est celle implmentant la communication srie. La

majorit des cartes Arduino possde un mulateur de connexion srie pour communiquer

au travers de lUSB. Ainsi, on peut communiquer avec lordinateur sur lequel la carte

Arduino est connecte. Cela permet, par exemple, de dboguer un programme en affichant

la valeur des variables ou simplement afficher la valeur des capteurs. Cette librairie t

directement implmente dans le langage Arduino. On peut accder la communication

srie (au travers lUSB) grce lobjet Serial. Une autre librairie existe pour communiquer

par liaison srie via une des broches de la carte.

Il est parfois ncessaire de stocker des informations mme aprs larrt de la carte. Il

est possible de stocker une petite quantit dinformation sur la mmoire EEPROM

(Electricaly Erasable Programmable Read Only Memory) intgre. Une librairie est aussi

fournie pour dialoguer avec cette mmoire. Il est possible de lire et dcrire sur cette

mmoire sans rien ajouter sur la carte. Cette mmoire est accessible via lobjet EEPROM et

en ajoutant la librairie du mme nom. Attention, la mmoire EEPROM une dure de vie

limite (environ 100 000 cycles dcritures). Il faut donc veiller ne pas crire

rptitivement les donnes. Dautres alternatives existent pour ajouter de plus grandes

quantits de mmoires mortes lArduino (carte SD notamment) mais cela demande lajout

de composants externes.

Pour terminer, il existe aussi des librairies permettant de contrler des composants

externes. Parmi ces librairies, une des plus populaires est celle contrlant des servomoteurs.

Un servomoteur est un composant lectronique compos dun moteur et dune carte

dasservissement. On peut le contrler en position (c'est--dire choisir langle du moteur)

grce aux PWM. Une librairie Arduino est implmente pour contrler simplement ces

moteurs : la librairie Servo. Il faut toutes fois faire attention viter dalimenter les



servomoteurs directement sur une des broches dalimentation de la carte. En effet, un

servomoteur consomme une quantit important de courant (suivant le couple exerc par le

moteur). Il est donc fortement conseill de relier les servomoteurs sur des alimentations

externes (batteries, piles de 9V, etc.).



Conclusion

On peut conclure sur le fait que les cartes Arduino sont un puissant outil de

prototypage pour les cartes lectroniques. Mais aussi, elles permettent un accs facile et

intuitif linformatique embarqu. On pourra ainsi enrichir tout ces projets dun

microcontrleur pour leurs donner une plus value importante.

LArduino UNO est une des cartes les plus courantes. Cest la premire de ce genre. Il

existe cependant dautres versions de cartes Arduino plus adaptes pour certains projets.

Pour certains projet il va falloir, par exemple, plus dentres/sorties. On pourra alors opter

pour lArduino Mga.

Il ne faut cependant pas oublier quArduino nest pas la seule marque proposer ce

type de cartes. En effet, des concurrents on rapidement vu le jour. Il existe deux types de

concurrences. Les cartes compatibles Arduino, ce sont des produits diffrents (de par les

composants quils proposent ou leurs prix) mais entirement compatible avec le logiciel et

les librairies Arduino (on peut par exemple citer Freeduino). Il existe aussi des cartes

similaires mais qui ne sont pas compatible avec Arduino (par exemple le LaunchPad de Texas

Instrument).

Pour plus dinformations sur le projet Arduino, de laide pour la ralisation dun projet

ou des documentations, reportez vous sur le site officiel Arduino : http://www.arduino.cc/.

Contact : [email protected]

Documents

Cours Arduino v0.2