Ce cours a pour objectifs : 

- Initier à la programmation et la réalisation de montages avec une
carte Arduino. 
-  Créer des systèmes électroniques plus ou moins complexes. 
La carte Arduino est une plate-forme de prototypage basée sur un
microcontrôleur ATMEL.
C'est un circuit de commande capable de piloter des capteurs et des
actionneurs afin de simuler ou créer des systèmes automatisés. 
Elle dispose d'un logiciel de programmation qui permet de programmer la
carte en fonction du comportement désiré. 
Il existe une grande variété de cartes arduino :Uno, Duemilanove,
Diecimila. Leonardo, mega, ….

        - Prix: peu coûteux, par exemple la carte Arduino uno a un prix  qui

tourne aux environs de 50 dinars TTC 
 - Compatibilité Linux, Windows et Mac 
 - Logiciel et matériel sous licence libre 
 - Le logiciel : gratuit et open source, développé en Java. 
 - Le matériel : cartes électroniques dont les schémas sont en libre
circulation sur internet.
   Une grande communauté d’amateurs et de passionnés
contribuent à développer des applications et à les partager.

  

CARTE ARDUINO UNO BROCHAGE EXTERNE

1 : Port d’alimentation externe Pour fonctionner, la carte a besoin d'une
alimentation qui est comprise entre 6 et 20 V. On conseille en général de
l'alimenter plutôt entre 7 V et 1 2V pour garder une marge en basse tension et
éviter que le circuit ne chauffe trop (car le régulateur de tension disperse toute
surtension en chaleur). Cette tension doit être continue et peut par exemple
être fournie par une pile 9V. Un régulateur se charge ensuite de réduire la
tension à 5V pour le bon fonctionnement de la carte. 

2 : Port USB Permet de communiquer avec la carte et de l’alimenter en 5V. 

3: Les entrées/sorties numériques 4 entrées/sorties numériques dont 6

peuvent assurer une sortie PWM peuvent actionner de nombreux composants
(LED, transistor, etc.) mais elles ne peuvent pas fournir beaucoup de courant
(40 mA pour une carte Arduino UNO). Pour piloter des circuits de plus forte
puissance, il faut passer par des transistors ou des relais. 

4: Les entrées analogiques lui permettent de mesurer une tension variable

(entre 0 et 5 V) qui peut provenir de capteurs 6 ou d'interfaces diverses
(potentiomètres, etc).
 5: Connecteur In-Circuit Serial Programming ICSP pour le téléchargement du
programme.

Avec une pile 9v et un connecteur Avec un adaptateur secteur 9 à 12V

c'est une solution très pratique et sûre
Connecteru 2.1mm avec le + au centre
pour éviter tout problème avec le port courant continu (DC)
USB de son Ordinateur
 
        6: Microcontrôleur ATMega328 est un microcontrôleur ATMEL de la famille
AVR 8bits.
Les spécifications du Microcontrôleur ATmega328:

Microcontrôleur ATmega328

Tension de fonctionnement 5V

E/S numériques 23: 3 ports PortB, PortC, PortD

6 Entrées
Entrée analogiques multiplexées :   ADC0(PC0) à
ADC5(PC5)

Mémoire Flash 32 Ko

SRAM 2 Ko

EEPROM 1 Ko

Vitesse de l'horloge 20MHz

Timers Timer0 et Timer1, Timer2

PWM 6 broches

Interruptions externes 24

Le microcontrôleur dispose d’autres fonctionnalités, entre autres: 

- Analog to Digital Converter (résolution 10bits)  =  6 entrées multiplexées
ADC0(PC0) à ADC5(PC5)
- PWM = 6 broches OC0A(PD6), OC0B(PD5), 0C1A(PB1), OC1B(PB3), OC2A(PB3),
OC2B(PD3)
- Port série (USART): émission/réception série via les broches
TXD(PD1)/RXD(PD0)
- Gestion bus I2C (TWI Two Wire Interface) = le bus est exploité via les broches
SDA(PC5)/SCL(PC4). 
- Comparateur Analogique: broches AIN0(PD6) et AIN1 (PD7) peut déclencher
interruption 
- Watchdog Timer programmable
Gestion d'interruptions (24 sources possibles): En résumé
  – Interruptions liées aux entrées INT0 (PD2) et INT1 (PD3) 
  – Interruptions sur changement d'état des broches PCINT0à PCINT23 
  – Interruptions liées aux Timers 0, 1 et 2 (plusieurs causes configurables) 
  – Interruption liée au comparateur analogique
  – Interruption de fin de conversion ADC 
  – Interruptions du port série USART 
  – Interruption du bus TWI(I2C) 
Pour plus d'info, visitez ce lien 

CARTE ARDUINO UNO BROCHAGE INTERNE

Arduino fournit un environnement de développement avec un éditeur de

source, les   opérations de compilation et de chargement dans la mémoire du
microcontrôleur étant ramenées à des clicks sur des boutons dans l'IHM (très
simple). La communication entre le PC et la carte se fait via le port USB,
moyennant installation d'un driver adapté (fourni parArduino)
 ENVIRONNEMENT DE DEVELOPPEMENT ARDUINO

       Téléchargez la dernière version du logiciel Arduino disponible ICI

          Apres la préparation du programme, il y’a des étapes à faire afin de terminer la

programmation, qui sont les suivantes : 

- Obtenir une carte Arduino et un câble USB 

- Télécharger l'environnement Arduino 
- Raccorder la carte à l'ordinateur
- Installation des pilotes du périphérique Série-USB 
- Lancer l'application Arduino

    Etape 1 : lancer le logiciel. 

    Etape 2 : ouvrir et modifier le programme. 
    Etape 3 : vérifier le programme. 

              Etape 4 : connecter la carte à l’ordinateur avec le cordon USB. 

    Etape 5 : transférer le programme vers la carte. 
    Etape 6 : vérifier le fonctionnement. 
          Le langage Arduino est très proche du C et du C++.Pourtant il y a des différences
surtout   au niveau des de l’ecriture des fichiers 

- Pas de fonction main

- Deux fonctions sont obligatoires (setup et loop)
- Et bien d’autres points de différences 

Un programme Arduino est composé de 3 parties:

- La partie déclaration des variables (optionnelle)

- Fonction setup () : C’est une partie initialisation et configuration
des entrées /sorties. Elle est appelée une seule fois lorsque le programme
commence. 
- Fonction loop() : C’est la partie principale contenant le programme. Elle est
répétée indéfiniment en boucle infinie 
  Pour plus de détails, voir lien

Structure

Fonctions de base
Syntaxe de base 
Structures de
contrôle  •  ;    (point
• void  setup()  virgule) 
• void  loop() • if  •  {}  (accolades) 
• if...else  •  // 
• for  (commentaire sur
• switch case  une ligne) 
 • while  •  /* */   
• do... while  (commentaire sur
• break  plusieurs lignes)
• continue  •  #define 
• return  •  #include
• goto

Opérateurs de
Opérateurs comparaison Opérateurs
arithmétiques booléens
• ==   (égal à) 
• =  (égalité)  • !=  (différent de)  •  &&  (ET booléen) 
• +    (addition)  • <  (inférieur à)  •  || (OU booléen) 
• -    (soustraction)  • >  (supérieur à)  •  !  (NON booléen)
• *  (multiplication)  • <=  (inférieur ou
• /  (division)  égal à) 
• %  (modulo) • >=  (supérieur ou
égal à)

Opérateurs bit à Pointeurs

Opérateurs composés bit   
  •  * pointeur 
• ++  (incrémentation)  • &  (ET bit à bit)  •  &  pointeur
• --  (décrémentation) (à • | (OU bit à bit) 
revoir)  • ^  (OU EXCLUSIF
• +=  (addition bit à bit) 
composée)  • ˜  (NON bit à bit) 
• -=   (soustraction • <<  (décalage à
composée)  gauche) 
• *=  (multiplication • >>  (décalage à
composée)  droite)
• /=   (division
composée) 
• &= (ET bit à bit
composé) 
• |= (OU bit à bit
composé)
Fonctions
Entrées/Sorties Trigonométrie 
Numériques
  •  sin(rad) 
•  pinMode(broche, Temps  •  cos(rad) 
mode)  •  tan(rad) 
•  digitalWrite(broch •  unsigned
e, valeur)  long  millis()  Bits et Octets 
•  int digitalRead(bro •  unsigned
che) long  micros()  •  lowByte() 
•  delay(ms) •  highByte() 
  Entrées •  delayMicrosecond •  bitRead() 
analogiques  s(us)  •  bitWrite() 
•  bitSet() 
•  int analogRead(br Math  •  bitClear() 
oche)  •  bit() 
•  analogReference(t •  min(x, y) 
ype) •  max(x, y)  Interruptions
•  abs(x)  Externes 
Sorties •  constrain(x, a, b) 
"analogiques" •  map(valeur, •  attachInterrupt(inte
(génération toLow, fromHigh, rrupti on, fonction,
d'impulsion)  toLow, toHigh)  mode) 
•  pow(base, •  detachInterrupt(inte
•  analogWrite(broch exposant)  rrupt ion)
e, valeur) - PWM  •  sq(x)  Interruptions 
•  sqrt(x)  •  interrupts() 
Entrées/Sorties •  noInterrupts() 
Avancées  Pour davantage de
•  tone()  fonctions
 mathématiques,
voir aussi la librairie
math.h : log, log10,
asin, atan, acos,
•  noTone()  etc... 
•  shiftOut(broche,
BrocheHorloge, Nombres
OrdreBit, valeur)  randomisés
•  unsigned (hasard) 
long  pulseIn(broche,
valeur)  •  randomSeed(seed
) 
Communication  •  long random(max
•  Serial  ) 
•  long random(min,
max)

Variables et constantes

        Conversion des types de données

  Types des données
  • char () 
Les variables peuvent être de type • byte () 
variés qui sont décrits ci-dessous.  • int() 
• long() 
Synthèse des types de données • float() 
Arduino  • word() 
•  boolean  Portée des variables et qualificateurs
•  char 
•  byte  • Portée des variables 
•  int  • static 
•  unsigned int  • volatile 
•  long  • const 
•  unsigned long  Utilitaires
•  float (nombres à virgules) 
•  double  (nombres à virgules)  • sizeof() (opérateur sizeof ) 
 •  Les chaînes de caractères 
• objet String  NEW 
•  Les tableaux de variables  Référence 
• le mot-clé  void (fonctions)  • Code ASCII
•  word 
•  PROGMEM