I.3. caractéristiques de la carte Arduino Mega
2560
1/Microcontrôleur ATMEL ATMega328
Le microcontrôleur utilise sur la carte Arduino Mega est un
microcontrôleur ATMega2560. C'est un microcontrôleur ATMEL de la
famille AVR 8bits.
|
Manufacturer:
|
Amel
|
|
Product Catégorie:
|
8-bit Microcontrôleurs - MCU
|
|
RoHS:
|
|
|
Core:
|
AVR
|
|
|
Data Bus Width:
|
8 bit
|
|
Maximum Clock Fréquence:
|
16 MHz
|
|
Program Memory Size:
|
256 kB
|
|
Data RAM Size:
|
8 kB
|
|
Brand:
|
Atmel
|
|
ADC Resolution:
|
10 bit
|
CHAPITRE I CARTE ARDUINO MIGA 2560
6
|
Operating Supply Voltage:
|
4.5 V to 5.5 V
|
|
Maximum Operating Temperature:
|
+ 85 C
|
|
Mounting Style:
|
SMD/SMT
|
|
Package / Case:
|
TQFP-100
|
|
Data RAM Type:
|
SRAM
|
|
Data ROM Size:
|
4 kB
|
|
Data ROM Type:
|
EEPROM
|
|
Interface Type:
|
2-Wire, SPI, USART
|
|
Minimum Operating Température:
|
- 40 C
|
|
Number of ADC Channels:
|
16
|
|
Number of I/Os:
|
86 I/O
|
|
Processor Series:
|
megaAVR
|
|
Product:
|
MCU
|
|
Program Memory Type:
|
Flash
|
|
Series:
|
ATMEGA 2560
|
|
|
Factory Pack Quantity:
|
90
|
|
|
Supply Voltage - Max:
|
5.5 V
|
|
Supply Voltage - Min:
|
4.5 V
|
|
Tradename:
|
ATMEGA
|
|
CHAPITRE I CARTE ARDUINO MIGA 2560
Figure 3 : microcontrôleur ATMEL Mega 2560
I.4.STRUCTURE INTERNE DE LA CARTE
Microcontrôleur ATmega2560
Tension de fonctionnement 5V
Tension d'entrée (recommandé) 7-12 V
Tension d'entrée (limites) 6-20V
Digital I / O Pins 54 (dont 15 fournissent sortie PWM)
Broches d'entrée analogiques 16
DC Courant par I O Pin / 40 mA
Courant DC pour 3,3 Pin 50 mA
Mémoire Flash 256 KB dont 8 Ko utilisé par
bootloader
SRAM 8 KB
EEPROM 4 KB
Vitesse d'horloge 16 MHz
7
CHAPITRE I CARTE ARDUINO MIGA 2560
8
I.5. Le langage de programmation
Un langage de programmation est un langage permettant
à un être humain d'écrire un ensemble d'instructions (code
source) qui seront directement converties en langage machine grâce
à un compilateur (c'est la compilation). L'exécution d'un
programme Arduino s'effectue de manière
séquentielle, c'est-à-dire que les instructions
sont exécutées les unes à la suite des autres. Voyons plus
en détail la structure d'un programme écrit en
Arduino.
I.6. La structure d'un programme :
Un programme Arduino comporte trois parties :
1. la partie déclaration des variables
(optionnelle)
2. la partie initialisation et configuration des
entrées/sorties : la fonction setup ()
3. la partie principale qui s'exécute en boucle
: la fonction loop ()
CHAPITRE I CARTE ARDUINO MIGA 2560
9
Dans chaque partie d'un programme sont utilisées
différentes instructions issues de la syntaxe du langage Arduino.
Les variables
Une variable est un espace réservé dans la
mémoire de l'ordinateur. C'est comme un compartiment dont la taille
n'est adéquate que pour un seul type d'information. Elle est
caractérisée par un nom qui permet d'y accéder
facilement.
Il existe différents types de variables identifiés
par un mot-clé dont les principaux sont :
· nombres entiers (int)
· nombres à virgule flottante (float)
· texte (String)
· valeurs vrai/faux (boolean).
Un nombre à décimales, par exemple 3.14159,
peut se stocker dans une variable de type float. Notez que l'on utilise un
point et non une virgule pour les nombres à décimales. Dans
Arduino, il est nécessaire de déclarer les variables pour leurs
réserver un espace mémoire adéquat. On déclare une
variable en spécifiant son type, son nom puis en lui assignant une
valeur initiale (optionnel). Exemple :
int ma_variable = 45;
// int est le type, ma_variable le nom et = 45 assigne une
valeur. Les fonctions
Une fonction (également désignée sous le
nom de procédure ou de sous-routine) est un bloc d'instructions que l'on
peut appeler à tout endroit du programme.
Le langage Arduino est constitué d'un certain nombre
de fonctions, par exemple analogRead(), digitalWrite() ou delay().
Il est possible de déclarer ses propres fonctions par
exemple :
void clignote(){
digitalWrite (brocheLED, HIGH) ; delay (1000) ; digitalWrite
(brocheLED, LOW) ; delay (1000) ;
}
Pour exécuter cette fonction, il suffit de taper la
commande : clignote();
CHAPITRE I CARTE ARDUINO MIGA 2560
10
On peut faire intervenir un ou des paramètres dans une
fonction :
void clignote(int broche,int vitesse){ digitalWrite (broche,
HIGH) ; delay (1000/vitesse) ;
digitalWrite (broche, LOW) ; delay (1000/vitesse) ;
}
Dans ce cas, l'on peut moduler leurs valeurs depuis la commande
qui l'appelle :
clignote(5,1000); //la sortie 5 clignotera vite
clignote(3,250); //la sortie 3 clignotera lentement
Les structures de contrôle
Les structures de contrôle sont des blocs d'instructions
qui s'exécutent en fonction du respect d'un certain nombre de
conditions.
Il existe quatre types de structure :
if...else : exécute un code si certaines conditions sont
remplies et éventuellement exécutera un autre code avec sinon.
exemple :
//si la valeur du capteur depasse le seuil
if(valeurCapteur>seuil){
//appel de la fonction clignote
clignote();
}
while : exécute un code tant que certaines conditions sont
remplies.
exemple :
//tant que la valeur du capteur est supérieure à
250
while(valeurCapteur>250){
//allume la sortie 5
digitalWrite(5,HIGH);
//envoi le message "0" au port serie
Serial.println(1);
//en boucle tant que valeurCapteur est supérieue à
250
}
Serial.println(0);
digitalWrite(5,LOW);
for : exécute un code pour un certain nombre de fois.
exemple :
//pour i de 0 à 255, par pas de 1 for (int i=0; i <=
255; i++){
analogWrite(PWMpin, i);
delay(10);
CHAPITRE I CARTE ARDUINO MIGA 2560
11
}
Switch/case : fait un choix entre plusieurs codes parmi une
liste de possibilités
| 
