Académique Documents
Professionnel Documents
Culture Documents
« Arduino »
1
Systèmes à base de microprocesseurs
Architecture d’un système à base de microprocesseur
Un système à base de microprocesseur est formé des trois éléments :
Les trois modules sont interconnectés comme le montre la figure suivante autour de trois bus : bus de données, bus
d'adresses et bus de contrôles et commandes
2
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
Un microprocesseur est un circuit intégré complexe caractérisé par une très grande intégration et doté des facultés
d'interprétation et d'exécution des instructions d'un programme. Il est chargé d’organiser les tâches précisées par le programme et
d’assurer leur exécution. Il doit aussi prendre en compte les informations extérieures au système et assurer leur traitement. C’est
le cerveau du système.
3
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
L’unité de commande:
Elle permet de séquencer le déroulement des instructions. Elle effectue la recherche en mémoire de l'instruction. Comme
chaque instruction est codée sous forme binaire, elle en assure le décodage pour enfin réaliser son exécution puis effectue la
préparation de l'instruction suivante. Pour cela, elle est composée par :
le compteur de programme : (en anglais Program Counter PC) appelé aussi compteur ordinal (CO). Le CO est constitué par un
registre dont le contenu représente l’adresse de la prochaine instruction à exécuter. Il est donc initialisé avec l'adresse de la
première instruction du programme. Puis il sera incrémenté automatiquement pour pointer vers la prochaine instruction à
exécuter;
le registre d'instruction : Contient l’instruction en cours de traitement;
le décodeur d'instruction: Permet d’interpréter l’instruction à exécuter;
Le séquenceur : Permet d'ordonnancer les diverses opérations élémentaires du processeur, nécessaires pour exécuter
l'instruction, grâce à un microprogramme;
L'horloge : Est un dispositif qui détermine le rythme dans lequel sont exécutées les instructions. Elle fournit un signal régulier
au processeur;
Le registre d'état : Est un registre particulier. Il représente à tout moment l'état du processeur. En effet, divers évènements
peuvent créer des situations « exceptionnelles ». Par exemple, l'addition de deux valeurs peut dépasser les capacités de
représentation du processeur. Dans ce cas, un bit du registre d'état signale que le processeur est dans l'état « overflow ».
4
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
L’unité de traitement:
C’est le cœur du microprocesseur. Elle regroupe les circuits qui assurent les traitements nécessaires à l'exécution des instructions.
5
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
Unité de décodage :
Elle décompose et analyse l’instruction se trouvant dans le registre d’instructions, selon le code opération, elle envoie la nature
des opérations à effectuer à l’unité de commande et précisément le séquenceur qui va ensuite générer les microcommandes
nécessaires aux différents composants participant à l’exécution de l’instruction en cours.
Exemple :
6
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
Les registres du microprocesseur
Un registre est une zone mémoire à l’intérieur du microprocesseur de faible taille, qui permet de mémoriser des mot mémoires
ou des adresses d’une façon temporaire lors de l’exécution des instructions.
Les registres généraux :
Ce sont des mémoires rapides, à l'intérieur du microprocesseur, qui permettent à l'unité d'exécution de manipuler des données à
vitesse élevée. Ils sont connectés au bus données interne au microprocesseur. L'adresse d'un registre est associée à son nom (on
donne généralement comme nom une lettre A,B,C...) Ces registres permettent de sauvegarder des informations utilisées dans les
programmes ou des résultats intermédiaires, cela évite des accès à la mémoire, accélérant ainsi l’exécution des programmes.
Les registres généraux sont à la disposition du programmeur qui a normalement un choix d’instructions permettant de les
manipuler comme:
(PC)=10000H ; il pointe la mémoire qui contient l'instruction MOV C,B qui est codée sur deux octets (89D9H) ; l'unité de
commande incrémentera de deux le contenu du PC : (PC) = 10002H (la mémoire sera supposée être organisée en octets).
8
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
Les registres du microprocesseur
Le registre d’instruction :
Il contient l’instruction qui doit être traitée par le microprocesseur, cette instruction est recherchée en mémoire puis placée
dans ce registre pour être décodée par le décodeur et préparée pour l’exécution.
Exemple:
ADD A,B cette instruction correspond à un ordre donné à l’ordinateur en langage assembleur qui permet de faire l’addition
entre les données A et B.
Toute instruction présente en fait deux types d’informations :
Ce qu’il faut faire comme action (addition, division …)
Avec quelles données réaliser cette action.
Zone opération : Cette zone permet de déterminer la nature de l’opération à effectuer par le microprocesseur.
Zone adresse : Contient les adresses en mémoire des opérandes qui participent dans une opération, dans certains cas elle
contient l’opérande même. Il existe plusieurs modes d’adressages pour accéder aux données. 9
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
Les registres du microprocesseur
Le registre d’adresse :
C’est un registre qui contient l’adresse du mot à accéder en mémoire centrale. A chaque accès mémoire, l’adresse recherchée est
stockée dans ce registre. Il a la taille d’une adresse qui est la même que celle du bus d’adresses ce qui permet de déterminer le
nombre de mots mémoires adressables et l’espace mémoire adressable.
Le registre mot mémoire ou registre de données
Il contient le mot mémoire faisant objet d’une opération de lecture ou d’écriture dans la mémoire centrale. Ce registre a la taille
d’un mot mémoire qui est la même que celle des registres de travail et l’accumulateur qui est égale à la taille du bus de données.
12
Systèmes à base de microprocesseurs
Microcontrôleurs
Plusieurs Constructeurs se partagent le marché des microcontrôleurs, citons INTEL, MOTOROLA, SEAGATE-THOMSON,
AMTEL, ZILOG, PHILIPS et enfin MICROCHIP
Les µC sont basés sur 2 architectures possibles, Von Neuman (INTEL80XX, motorolaHC05, HC08 et HC11, ou ZILOG Z80) ou
Harvard (PIC).
13
Arduino
Arduino
Arduino est la marque d'une plateforme de prototypage open-source qui permet aux utilisateurs de créer des objets électroniques
interactifs à partir de cartes électroniques matériellement libres sur lesquelles se trouve un microcontrôleur (d'architecture Atmel
AVR comme l'Atmega328p, et d'architecture ARM comme le Cortex-M3 pour l'Arduino Due).
Le microcontrôleur peut être programmé pour analyser et produire des signaux électriques, de manière à effectuer des tâches très
diverses comme la domotique (le contrôle des appareils domestiques : éclairage, chauffage…), le pilotage d'un robot,
de l'informatique embarquée, etc.
14
Arduino
Types de cartes Arduino
Les cartes Arduino sont conçues pour réaliser des prototypes et des maquettes de cartes électroniques pour l’informatique
embarquée. Ces cartes permettent un accès simple et peu couteux à l’informatique embarquée. De plus, elles sont entièrement
libres de droit, autant sur l’aspect du code source (Open Source) que sur l’aspect matériel (Open Hardware). Ainsi, il est possible à
tout utilisateur de refaire sa propre carte Arduino dans le but de l’améliorer ou d’enlever des fonctionnalités inutiles à son projet.
Le langage Arduino se distingue des langages utilisés dans l’industrie de l’informatique embarquée par sa simplicité. En effet,
beaucoup de librairies et de fonctionnalités de base sont disponibles ce qui permet de faciliter la réalisation des prototypes ou des
petites applications.
Les cartes Arduino font partie de la famille des microcontrôleurs. Un microcontrôleur est une petite unité de calcul accompagné
de mémoire, de ports d’entrée/sortie et de périphériques permettant d’interagir avec son environnement. Parmi les périphériques,
on trouve généralement des Timers, des convertisseurs analogique-numérique, des liaisons Séries, etc. Les microcontrôleurs sont
inévitables dans les domaines de l’informatique embarquée, de l’automatique et de l’informatique industrielle. Ils permettent de
réduire le nombre de composants et de simplifier la création de cartes électroniques dédiées à la commande de processus
industriels.
Il existe plusieurs types de cartes arduino qui se distingue l’une de l’autre principalement par le type du microcontrôleur utilisé,
le nombre d’entrées/sorties, la capacité de la mémoire et la vitesse de fonctionnement. On peut citer à titre indicatif l’arduino
UNO, Mega, Leonardo, Due, Pro mini, micro, Nano, …
15
Arduino
Types de cartes Arduino
Les cartes arduino les plus répandues pour les applications courantes sont la carte UNO et la carte Mega dont les principales
caractéristiques sont données au tableau suivant :
17
Arduino
Brochage externe de la carte Arduino UNO
18
Arduino
Brochage interne de la carte Arduino UNO
19
Arduino
Schéma simplifié de la carte Arduino UNO
20
Arduino
Vue du dessus, la carte fournit les informations suivantes:
Plusieurs broches multi-fonctions : Certaines broches peuvent avoir plusieurs fonctions différentes, choisies par programmation.
Elles ont alors plusieurs noms sur le brochage.
22
Arduino
Microcontrôleur ATMEL ATMega328
Exemples de fonctions des broches:
PWM(Pulse Width Modulation): 6 broches OC0A(PD6), OC0B(PD5), 0C1A(PB1),
OC1B(PB2), OC2A(PB3), OC2B(PD3)
Gestion bus I2C (TWI Two Wire Interface) : le bus est exploité via les broches
SCL(PC5)/SDA(PC4).
Gestion d'interruptions:
– 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 – Interruption liée au comparateur analogique – Interruption de fin de conversion ADC
– Interruptions du port série USART – Interruption du bus TWI (I2C)
23
Arduino
Présentation du logiciel
IDE Arduino
Un IDE (environnement de développement) libre et gratuit est
distribué sur le site d’Arduino (compatible Windows, Linux et Mac).
1 : Editeur de code.
2 : Barre d’outils rapide.
3 : Barre de menus.
4 : Console d’affichage.
Langage Arduino
Le langage Arduino est inspiré de plusieurs langages. On retrouve
notamment des similarités avec le C, le C++, le Java et le Processing. Le
langage impose une structure particulière typique de l’informatique
embarquée. La fonction setup contiendra toutes les opérations nécessaires à
la configuration de la carte (directions des entrées sorties, débits de
communications série, etc.). La fonction loop elle, est exécutée en boucle
après l’exécution de la fonction setup. Elle continuera de boucler tant que la
carte n’est pas mise hors tension ou redémarrée (par le bouton reset).
24
Arduino
Applications (Arduino Uno)
Gestion des entrées/sorties
pinMode(broche, mode)
Configure la broche spécifiée pour qu'elle se comporte soit en entrée, soit en sortie.
Paramètres:
broche: le numéro de la broche de la carte Arduino dont le mode de fonctionnement (entrée ou sortie) doit être défini.
mode: soit INPUT (entrée en anglais) (=0) ou OUTPUT (sortie en anglais) (=1)
digitalWrite(broche, valeur)
Met un niveau logique HIGH (HAUT en anglais) ou LOW (BAS en anglais) sur une broche numérique. Si la broche a été
configurée en SORTIE avec l'instruction pinMode().
Paramètres:
broche: le numéro de la broche de la carte Arduino
valeur : HIGH ou LOW (ou bien 1 ou 0)
digitalRead(broche)
Lit l"état (= le niveau logique) d'une broche précise en entrée numérique, et renvoie la valeur HIGH ou LOW.
Paramètres:
broche : le numéro de la broche numérique que vous voulez lire. 25
Arduino
Applications (Arduino Uno)
Gestion des entrées/sorties
Autre méthode de configuration:
Les broches de la carte arduino UNO sont divisées en 3 groupes (ports) de la façon suivante :
Pour définir la direction d’un port (entrée ou sortie) on utilise un registre de direction pour chaque port (DDRB, DDRC ou
DDRD) :
Exemple:
DDRD = 0B00001111 : Permet de configurer les 4 pins (0 à 3) du port D en sortie et les 4 pins (4 à 7) du même port en entrée.
C’est-à-dire les broches de 0 à 3 de la carte Arduino sont configurées en sortie et les broches de 4 à 7 en entrée
Autres syntaxes:
DDRD = 0X0F ; (en hexadécimal)
DDRD = 15 . (en décimal)
26
Arduino
Applications (Arduino Uno)
Gestion des entrées/sorties
Exemple: Clignotement d’une Led par appui sur un bouton
27
Arduino
Applications (Arduino Uno)
Gestion du temps
Le langage Arduino fournis quelques fonctions permettant de gérer le temps. Il est possible donc d’insérer une pause dans le
programme pendant une certaine durée. Pour cela, on utilise les fonctions delay et delayMicroseconds qui insère une pause
suivant le paramètre passé (en milliseconde pour l’un, en microseconde pour l’autre). Cependant ces fonctions bloquent le
microcontrôleur, on ne peut alors plus effectuer aucune action.
En plus d’insérer une pause, il est possible de mesurer le temps. De la même manière que les fonctions de délai, on utilise les
fonctions millis et micros qui donnent le nombre de millisecondes (respectivement microsecondes) depuis le lancement de la
carte. Attention, ces fonctions incrémente une variable (interne sur 32 bits). Ces variables se remettent à zéro une fois le maximum
atteint (overflow). La variable utilisée pour les millisecondes atteint sont maximum au bout de 49 jours et 17 heures et la variable
utilisée pour les microsecondes au bout de 71 minutes et 34 secondes environ. Il faut donc faire attention lors de l’utilisation de
ces fonctions pour des utilisations longues durées.
delay(ms)
Réalise une pause dans l'exécution du programme pour la durée (en millisecondes) indiquée en paramètre.
delayMicroseconds(us)
Stoppe le programme pendant la durée (en microsecondes) spécifiées en paramètres.
Exemple: voir programme précédent (clignotement d’une Led) 28
Arduino
Applications (Arduino Uno)
Gestion du temps
variable_unsigned_long=millis();
Renvoie le nombre de millisecondes depuis que la carte Arduino a commencé à exécuter le programme courant. Ce nombre
débordera (càd sera remis à zéro) après 50 jours approximativement.
variable_unsigned_long=micros();
Renvoie le nombre de microsecondes depuis que la carte Arduino a démarré le programme en cours. Ce nombre déborde (repasse
à 0) après approximativement 70 minutes.
Exemple:
29
Arduino
Applications (Arduino Uno)
Gestion du temps
Exemple:
30
Arduino
Applications (Arduino Uno)
Affichage
Afficheur 7 segments
Exemple: Compteur décimal
31
Arduino
Applications (Arduino Uno)
Affichage
Afficheur 7 segments
Exemple: Affichage multiplexé
32
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
Les afficheurs de caractères à cristaux liquides LCD sont des modules préfabriqués qui contiennent des pilotes inclus. Ces
écrans disposent d'un bus de données et un bus de commande pour la manipulation de ces composants. Le logiciel Arduino
dispose d'une bibliothèque prédéfinie pour contrôler les LCD.
33
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
Les LCD sont fabriqués dans différentes formes et couleurs, ils sont disponibles avec des écrans verts, bleu et jaune, avec des
distributions de caractères sous forme de matrice comme les LCD 2 lignes, 16 colonnes. Ceux-ci sont connus comme 2x16, de la
même manière on peut trouver des 1x16, 2x16, 2x8, 2x20, 4x20,… .
34
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
Brochage:
35
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
L'implémentation de l'afficheur LCD, requiert l'utilisation des instructions et des commandes séquentielles pour la
configuration et l’utilisation de l’afficheur, cependant, la bibliothèque de LiquidCrystal minimise ce travail, car elle se charge de
faire tous ces réglages.
La librairie fonctionne aussi bien en mode 4 bits qu'en mode 8 bits (càd utilisant 4 ou 8 broches numériques en plus des
broches de contrôle RS, Enable et RW (optionnel)). Ainsi, en mode 4 bits, 6 broches numériques de la carte Arduino suffisent
pour contrôler un afficheur LCD alphanumérique.
LiquidCrystal
Crée une variable de type LiquidCrystal en définissant les broches utilisées avec le LCD et son mode de fonctionnement.
L'afficheur LCD peut être contrôlé avec 4 ou 8 lignes de données. La broche RW peut-être connectée à la masse (0V) au lieu
d'être connectée à une broche de la carte Arduino.
Syntaxe:
Plusieurs formes sont possibles : les broches omises déterminent le mode de fonctionnement utilisé:
LiquidCrystal lcd(rs, enable, d4, d5, d6, d7); // mode 4 bits - RW non connectée
LiquidCrystal lcd(rs, rw, enable, d4, d5, d6, d7); // mode 4 bits - RW utilisée
LiquidCrystal lcd(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7); // mode 8 bits - RW non connectée
LiquidCrystal lcd(rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7); //mode 8 bits - RW utilisée 36
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal
Paramètres:
lcd: le nom de la variable LiquidCrystal déclarée;
rs: le numéro de la broche de l'Arduino qui est connecté à la broche RS de l'afficheur LCD;
rw: le numéro de la broche de l'Arduino qui est connecté à la broche RW de l'afficheur LCD (optionnel);
enable: le numéro de la broche de l'Arduino qui est connecté à la broche E(Enable) de l'afficheur LCD;
d0, d1, d2, d3, d4, d5, d6, d7: le numéro de la broche de l'Arduino qui est connecté aux broches correspondantes des broches
de données de l'afficheur LCD. Les broches de données d0, d1, d2 et d3 sont optionnelles; si
elles sont omises, le LCD pourra être contrôlé en utilisant seulement les quatre broches de
données d4, d5, d6 et d7 (mode 4 bits).
Quelques instructions
Initialisation
lcd.begin(colonnes, lignes);
Paramètres:
lcd: une variable de type LiquidCrystal
colonnes: le nombre de colonnes de l'afficheur LCD utilisé.
lignes: le nombre de lignes de l'afficheur LCD utilisé.
lcd.print("texte");
lcd.print(data); Affiche texte et nombre sur l'afficheur LCD.
lcd.print(data, BASE);
lcd : une variable de type LiquidCrystal;
"texte" : une chaîne de caractères;
Paramètres: data : la donnée à afficher (char, byte, int, long, float);
BASE (optionel): la base dans laquelle vous voulez afficher les nombres : BIN pour binaire (base 2),
DEC pour décimal (base 10 - base par défaut), OCT pour octal (base 8) et HEX pour
hexadécimal (base 16). 38
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal
Quelques instructions
lcd.setCursor(colonne, ligne);
Positionne le curseur de l'afficheur LCD à la localisation voulue (colonne,ligne), et donc définit la position à laquelle le texte
sera dorénavant affiché à l'écran.
Paramètres:
colonne: la colonne à laquelle positionner le curseur (0 est la 1ère colonne, 1 la 2ème, etc..);
ligne: la ligne à laquelle positionner le curseur ( 0 est la 1ère ligne, 1 la 2ème, etc..).
39
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal
Quelques instructions
Exemple:
40
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal
Quelques instructions
lcd.write(data);
Ecrit un caractère sur l'afficheur LCD.
Paramètres:
lcd: une variable de type LiquidCrystal;
data: le caractère à écrire sur l'écran.
lcd.clear();
Efface l'écran et positionne le curseur dans le coin supérieur gauche de l'écran.
Paramètres:
lcd: une variable de type LiquidCrystal
41
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal
Quelques instructions
lcd.write(data);
Exemple:
42
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal
Quelques instructions
lcd.clear();
Exemple:
43
Arduino
Applications (Arduino Uno)
Interruptions
Une interruption est un événement qui provoque l’arrêt d’un programme en cours d’exécution pour aller exécuter un
autre programme appelé programme d’interruption ou routine d’interruption encore une ISR pour Interrupt Service
Routine en anglais. A la fin du programme d’interruption, le microcontrôleur reprend le programme principal à
l’endroit où il s’est arrêté.
On distingue deux types d’interruptions :
Les interruptions externes, qui sont déclenchées lorsqu’un événement extérieur se produit tels que le changement
d’état d’une entrée destinée à l’interruption.
Les interruptions internes, qui sont déclenchées par le déroulement du programme tel que le débordement d’un
Timer.
Atmega328 qui équipe l’Arduino Uno possède 26 interruptions différentes. Chaque interruption possède un niveau de priorité au
sein du microcontrôleur.
44
Arduino
Applications (Arduino Uno)
Interruptions
Interruptions externes INT0 et INT1
Paramètres:
interruption: le numéro de l'interruption externe à désactiver.
noInterrupts();
interrupts();
Réactive les interruptions (après qu'elles aient été désactivée par l'instruction noInterrupts().
46
Arduino
Applications (Arduino Uno)
Interruptions
Interruptions externes INT0 et INT1
Exemple: L’allumage d’une Led à l’arrivé d’une interruption sur la broche 3
47
Arduino
Applications (Arduino Uno)
Convertisseur analogique numérique(CAN ou ADC)
Principes et caractéristiques
Un convertisseur CAN permet de convertir une tension analogique, comprise entre deux tension de référence Vref- et Vref+, en
une valeur numérique N sur n bits
Le blocage:
Temps de conversion non nul
Maintien de la valeur pendant ce temps
49
Arduino
Applications (Arduino Uno)
Convertisseur analogique numérique(CAN ou ADC)
Principes et caractéristiques
Les étapes de conversion:
Les différents signaux d’un CAN
51
Arduino
Applications (Arduino Uno)
Convertisseur analogique numérique(CAN ou ADC)
Instructions
analogRead(broche_analogique);
Lit la valeur de la tension présente sur la broche spécifiée. La carte Arduino Uno comporte 6 voies (8 voies sur la Mini et la Nano)
connectées à un convertisseur analogique-numérique 10 bits. Cela signifie qu'il est possible de transformer la tension d'entrée entre
0 et 5V en une valeur numérique entière comprise entre 0 et 1023. Il en résulte une résolution (écart entre 2 mesures) de : 5 volts /
1024 intervalles, autrement dit une précision de 0.0049 volts (4.9 mV) par intervalle.
Paramètres
broche_analogique : le nom de la broche sur laquelle il faut convertir la tension analogique appliquée
Exemple:
52
Arduino
Applications (Arduino Uno)
Convertisseur analogique numérique(CAN ou ADC)
Instructions
analogRead(broche_analogique);
Exemple: Voltmètre
53
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
La librairie Serial est utilisée pour les communications par le port série entre la carte Arduino et un ordinateur ou d'autres
composants. Toutes les cartes Arduino ont au moins un port Série ( également désigné sous le nom de UART ou USART). Ce port
série communique sur les broches 0 (RX) et 1 (TX) avec l'ordinateur via le port USB.
La carte Arduino Mega dispose de trois port série supplémentaires : Serial1 sur les broches 19 (RX) et 18 (TX), Serial2 sur les
broches 17 (RX) et 16 (TX), Serial3 sur les broches 15 (RX) et 14 (TX).
Les fonctions de la librairie
Serial.begin(debit);
Fixe le débit de communication en nombre de caractères par seconde (l'unité est le baud) pour la communication série.
Pour communiquer avec l'ordinateur, utiliser l'un de ces débits : 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400,
57600, or 115200. On peut, également, spécifier d'autres débits - par exemple, pour communiquer sur les broches 0 et 1 avec
un composant qui nécessite un débit particulier.
Paramètres
int debit: debit de communication en caractères par seconde (ou baud).
54
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Les fonctions de la librairie
Serial.available();
Donne le nombre d'octets (caractères) disponible pour lecture dans la file d'attente (buffer) du port série.
Valeur renvoyée
Le nombre d'octet disponible pour lecture dans la file d'attente (buffer) du port série, ou 0 si aucun caractère n'est disponible. Si
une donnée est arrivée, Serial.available() sera supérieur à 0. La file d'attente du buffer peut recevoir jusqu'à 128 octets.
Serial.read();
L'octet lu est « enlevé » de la file d'attente. Le prochain appel de la fonction read() lira l'octet suivant, etc...
55
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Les fonctions de la librairie
Serial.print(val);
Serial.print(val, format);
Affiche les données sous le port série sous forme lisible (texte ASCII). Cette instruction peut prendre plusieurs formes.
Les nombres entiers sont affichés en utilisant les caractères ASCII pour chaque chiffre.
Les nombres à virgules (float) sont affichés de la même façon sous forme de caractères ASCII pour chaque chiffre, par défaut
avec 2 décimales derrière la virgule.
Les valeurs de type byte sont affichés sous la forme d'un caractère ASCII.
Les caractères et les chaînes sont affichés tels que.
Exemples:
Paramètres:
val: la valeur à afficher. N'importe quel type de données;
format : spécifie la base utilisée(pour les nombres entiers) ou le nombre de décimales (pour les nombres de type float).
serial.write(val);
serial.write(str);
serial.write(buf, len);
Ecrit des données binaires sur le port série. Ces données sont envoyées comme une série d'octet;
Paramètres:
val: une valeur à envoyer sous forme d'octet simple
str: une chaîne à envoyer sous forme d'une série d'octets
buf: un tableau pour envoyer une série d'octets
len: la largeur du tableau
57
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Les fonctions de la librairie
Serial.flush();
Vide le buffer de réception de données du port série. Par conséquent, tout appel de la fonction Serial.read() ou Serial.avalaible()
renverra seulement les données reçues après le plus récent appel de la fonction Serial.flush().
Exemple: Communication avec le terminal virtuel
58
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Exemple: Communication entre deux cartes
59
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Exemple: Communication entre deux cartes
Carte (2)
Carte (1)
60
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Exemple: Communication entre carte et PC
61
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Exemple: Communication entre carte et PC
62
Arduino
Applications (Arduino Uno)
Sorties analogiques (PWM)
PWM signifie « Pulse Width Modulation », ce qu’on pourrait traduire par modulation de largeur d’impulsion. Son objectif est de changer une
valeur moyenne en jouant sur le rapport cyclique.
analogWrite(broche, valeur);
Génère une impulsion de largeur / période voulue sur une broche de la carte Arduino
Après avoir appelé l'instruction analogWrite(), la broche générera une onde carrée stable avec un "duty cycle"
Paramètres:
broche: la broche utilisée pour "écrire" l'impulsion. Cette broche devra être une broche ayant la fonction PWM, Par exemple,
sur la UNO, ce pourra être une des broches 3, 5 ,6 ,9 ,10 ou 11.
valeur: la largeur du "duty cycle" (proportion de l'onde carrée qui est au niveau HAUT) : entre 0 (0% HAUT donc toujours
au niveau BAS) et 255 (100% HAUT donc toujours au niveau HAUT).
63
Arduino
Applications (Arduino Uno)
Sorties analogiques (PWM)
analogWrite(broche, valeur);
64
Arduino
Applications (Arduino Uno)
Sorties analogiques (PWM)
analogWrite(broche, valeur);
Exemple: Variation de la vitesse d’un moteur à courant continu
65