{"id":1633,"date":"2020-03-31T16:05:45","date_gmt":"2020-03-31T14:05:45","guid":{"rendered":"http:\/\/www.ardpylab.fr\/?page_id=1633"},"modified":"2020-05-09T17:50:38","modified_gmt":"2020-05-09T15:50:38","slug":"les-fonctions","status":"publish","type":"page","link":"https:\/\/www.ardpylab.fr\/?page_id=1633","title":{"rendered":"Les fonctions"},"content":{"rendered":"\n

Une fonction est un bloc d\u2019instructions que l\u2019on peut appeler \u00e0 tout endroit d\u2019un programme.<\/p>\n

En langage Arduino, des biblioth\u00e8ques de fonctions pr\u00e9d\u00e9finies sont disponibles afin de manipuler facilement les entr\u00e9es\/sorties, g\u00e9rer le temps, g\u00e9rer la communication s\u00e9rie\u2026<\/p>\n

On peut \u00e9galement cr\u00e9er ses propres fonctions qui seront utiles pour l’ex\u00e9cution de t\u00e2ches r\u00e9p\u00e9titives et \u00e9vitant alors la r\u00e9\u00e9criture des lignes de codes \u00e0 chaque fois que se pr\u00e9sente ces t\u00e2ches.<\/p>\n

 <\/p>\n

<\/a>1. Fonctions des <\/span>Entr\u00e9es\/Sorties num\u00e9riques<\/u><\/strong><\/h4>\n\n\n\n


. pinMode()<\/span><\/strong><\/h4>\n

Configure la broche sp\u00e9cifi\u00e9e pour qu’elle se comporte soit en entr\u00e9e, soit en sortie.<\/p>\n

– Syntaxe<\/span> :<\/p>\n

pinMode(broche, mode)<\/strong><\/p>\n

– Param\u00e8tres<\/span> :<\/p>\n

broche:<\/strong> le num\u00e9ro de la broche de la carte Arduino dont le mode de fonctionnement (entr\u00e9e ou sortie) doit \u00eatre d\u00e9fini.<\/p>\n

mode:<\/strong> soit INPUT (entr\u00e9e en anglais) ou OUTPUT (sortie en anglais)<\/p>\n

 <\/p>\n

<\/a>. digitalWrite()<\/strong><\/span><\/h4>\n

Met un niveau logique HIGH (HAUT en anglais) ou LOW (BAS en anglais) sur une broche num\u00e9rique.<\/p>\n

Si la broche a \u00e9t\u00e9 configur\u00e9e en SORTIE avec l’instruction pinMode(), sa tension est mise \u00e0 la valeur correspondante : 5V  pour le niveau HAUT, 0V (masse) pour le niveau BAS.<\/p>\n

Si la broche est configur\u00e9e en ENTREE, \u00e9crire un niveau HAUT sur cette broche a pour effet d’activer la r\u00e9sistance interne de 20K sur cette broche.<\/p>\n\n\n\n

\"\"<\/figure><\/div>\n\n\n\n

A l’inverse, mettre un niveau BAS sur cette broche configur\u00e9e en ENTREE d\u00e9sactivera la r\u00e9sistance interne.<\/p>\n\n\n\n

– Syntaxe<\/span> :<\/p>\n

digitalWrite(broche, valeur)<\/strong><\/p>\n

– Param\u00e8tres<\/span> :<\/p>\n

broche:<\/strong> le num\u00e9ro de la broche de la carte Arduino<\/p>\n

valeur:<\/strong> HIGH ou LOW (ou bien 1 ou 0)<\/p>\n

– Exemple<\/span> :<\/p>\n\n\n\n

\n\n\n\n
\n

int ledPin = 13; \/\/ LED connect\u00e9e \u00e0 la broche num\u00e9rique n\u00b0 13<\/span><\/span><\/p>\n

void setup()<\/span>
{<\/span>
pinMode(ledPin, OUTPUT); \/\/ met la broche utilis\u00e9e avec la LED en SORTIE<\/span><\/span>
}<\/span><\/p>\n

void loop()<\/span>
{<\/span>
digitalWrite(ledPin, HIGH); \/\/ allume la LED<\/span><\/span>
delay(1000); \/\/ pause 1 seconde<\/span><\/span>
digitalWrite(ledPin, LOW); \/\/ \u00e9teint la LED<\/span><\/span>
delay(1000); \/\/ pause 1 seconde<\/span><\/span>
}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n


Remarques<\/u><\/strong> :<\/p>\n

– Les broches analogiques peuvent \u00eatre utilis\u00e9es en tant que broches num\u00e9riques, repr\u00e9sent\u00e9es par les nombres 14 (entr\u00e9e analogique 0) \u00e0 19 (entr\u00e9e analogique 5).<\/p>\n

– Cette instruction met la valeur 0\/1 dans le bit de donn\u00e9e qui est associ\u00e9 \u00e0 chaque broche, ce qui explique qu’on puisse le mettre \u00e0 1, m\u00eame si la broche est en entr\u00e9e.<\/p>\n

– Ne pas oublier qu’une broche num\u00e9rique ne peut fournir que 40mA (milliamp\u00e8res) tant en entr\u00e9e qu’en sortie, et que l’ensemble des broches de la carte Arduino ne peut fournir que 200mA. Par cons\u00e9quent, limiter l’intensit\u00e9 utilis\u00e9e pour chaque broche \u00e0 une dizaine de mA par des r\u00e9sistances adapt\u00e9es : 220 Ohms pour une LED par exemple.<\/p>\n

 <\/p>\n

<\/a>. digitalRead()<\/strong><\/span><\/h4>\n

Lit l\u2019\u00e9tat (= le niveau logique) d’une broche pr\u00e9cise en entr\u00e9e num\u00e9rique, et renvoie la valeur HIGH (HAUT en anglais) ou LOW (BAS en anglais).<\/p>\n

– Syntaxe<\/span> :<\/p>\n

digitalRead(broche)<\/strong><\/p>\n

– Param\u00e8tres<\/span> :<\/p>\n

broche :<\/strong> le num\u00e9ro de la broche num\u00e9rique que vous voulez lire. (int)<\/p>\n

– Valeur retourn\u00e9e<\/span> :<\/p>\n

Renvoie la valeur HIGH<\/strong> (HAUT en anglais) ou LOW<\/strong> (BAS en anglais)<\/p>\n

– Exemple<\/span> :<\/p>\n\n\n\n

\n\n\n\n
\n

int ledPin = 13; \/\/ LED connect\u00e9e \u00e0 la broche n\u00b013<\/span> <\/span>
int inPin = 7; \/\/ un bouton poussoir connect\u00e9 \u00e0 la broche 7<\/span> <\/span>
int val = 0; \/\/ variable pour m\u00e9moriser la valeur lue<\/span><\/span><\/p>\n

void setup()<\/span>
{<\/span>
pinMode(ledPin, OUTPUT); \/\/ configure la broche 13 en SORTIE<\/span><\/span>
pinMode(inPin, INPUT); \/\/ configure la broche 7 en ENTREE<\/span> <\/span>
}<\/span>
void loop()<\/span>
{<\/span>
val = digitalRead(inPin); \/\/ lit l’\u00e9tat de la broche en entr\u00e9e et met le r\u00e9sultat dans la variable<\/span><\/span>
digitalWrite(ledPin, val); \/\/ met la LED dans l’\u00e9tat du BP (c\u00e0d allum\u00e9e si appuy\u00e9 et inversement)<\/span><\/span>
}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

Dans ce programme, la broche 13 refl\u00e8te fid\u00e8lement l’\u00e9tat de la broche 7 qui est une entr\u00e9e num\u00e9rique.<\/p>\n

Remarques<\/u><\/strong> :<\/p>\n

– Si la broche num\u00e9rique en entr\u00e9e n’est connect\u00e9e \u00e0 rien, l’instruction digitalRead() peut retourner aussi bien la valeur HIGH (HAUT en anglais) ou LOW (BAS en anglais) (et cette valeur peut changer de fa\u00e7on al\u00e9atoire)<\/p>\n

– Les broches analogiques peuvent \u00eatre utilis\u00e9es en entr\u00e9e num\u00e9riques et sont d\u00e9sign\u00e9es par les num\u00e9ros 14 (entr\u00e9e analogique 0) \u00e0 19 (entr\u00e9e analogique 5).<\/p>\n

 <\/p>\n

<\/a>2. Fonctions des <\/span>Entr\u00e9es\/Sorties analogiques

<\/u><\/strong><\/h4>\n

. analogRead()<\/strong><\/span><\/h4>\n

Lit la valeur de la tension pr\u00e9sente sur la broche sp\u00e9cifi\u00e9e.<\/p>\n

La carte Arduino comporte 6 voies connect\u00e9es \u00e0 un convertisseur analogique-num\u00e9rique 10 bits.
Cela signifie qu’il est possible de transformer la tension d’entr\u00e9e entre 0 et 5V en une valeur num\u00e9rique enti\u00e8re comprise entre 0 et 1023.<\/p>\n

Il en r\u00e9sulte une r\u00e9solution (\u00e9cart entre 2 mesures) de : 5 volts \/ 1024 intervalles, autrement dit une pr\u00e9cision de 0.0049 volts (4.9 mV) par intervalle.<\/p>\n

Une conversion analogique-num\u00e9rique dure environ 100 \u00b5s pour convertir l’entr\u00e9e analogique, et donc la fr\u00e9quence maximale de conversion est environ de 10 000 fois par seconde.<\/p>\n

– Syntaxe<\/span> :<\/p>\n

analogRead(broche_analogique)<\/strong><\/p>\n

– Param\u00e8tres<\/span> :<\/p>\n

broche_analogique<\/strong> : le num\u00e9ro de la broche analogique (et non le num\u00e9ro de la broche num\u00e9rique) sur laquelle il faut convertir la tension analogique appliqu\u00e9e (0 \u00e0 5 sur la plupart des cartes Arduino)<\/p>\n

– Valeur retourn\u00e9e<\/span> :<\/p>\n

valeur int (0 to 1023) correspondant au r\u00e9sultat de la mesure effectu\u00e9e<\/p>\n

– Exemple<\/span> :<\/p>\n\n\n\n

\n\n\n\n
\n

int analogPin = 3; \/\/ Capteur analogique reli\u00e9 \u00e0 la broche A3<\/span><\/span>
int val = 0; \/\/ variable de type int pour stocker la valeur de la mesure<\/span><\/span><\/p>\n

void setup()<\/span>
{<\/span>
Serial.begin(9600); \/\/ initialisation de la connexion s\u00e9rie<\/span><\/span>
}<\/span><\/p>\n

void loop()<\/span>
{
<\/span>\/\/ lit la valeur de la tension analogique pr\u00e9sente sur la broche<\/span>
val = analogRead(analogPin);<\/span><\/p>\n

\/\/ affiche la valeur (comprise en 0 et 1023) dans la fen\u00eatre terminal PC<\/span>
Serial.println(val);
<\/span>}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

 <\/h4>\n

<\/a>. analogWrite()<\/strong><\/span><\/h4>\n

G\u00e9n\u00e8re un signal carr\u00e9 de fr\u00e9quence 490 Hz sur une broche de la carte Arduino (onde PWM – Pulse Width Modulation en anglais ou MLI – Modulation de Largeur d’Impulsion en fran\u00e7ais).<\/p>\n

Apr\u00e8s avoir appel\u00e9 l’instruction analogWrite(), la broche g\u00e9n\u00e9rera un signal carr\u00e9 stable avec un rapport cyclique (fraction de la p\u00e9riode o\u00f9 la broche est au niveau haut) de dur\u00e9e sp\u00e9cifi\u00e9e (en %), jusqu’\u00e0 l’appel suivant de l’instruction analogWrite() (ou bien encore l’appel d’une instruction digitalRead() ou digitalWrite() sur la m\u00eame broche).<\/p>\n

– Syntaxe<\/span> :<\/p>\n

analogWrite(broche, valeur);<\/strong><\/p>\n

– Param\u00e8tres<\/span> :<\/p>\n

broche<\/strong>: la broche utilis\u00e9e pour \u00ab\u00a0\u00e9crire\u00a0\u00bb l’impulsion. Cette broche devra \u00eatre une broche ayant la fonction PWM, Par exemple, sur la UNO, ce pourra \u00eatre une des broches 3, 5 ,6 ,9 ,10 ou 11.<\/p>\n

valeur<\/strong>: la largeur du \u00ab\u00a0duty cycle\u00a0\u00bb (proportion de l’onde carr\u00e9e qui est au niveau HAUT) : entre 0 (0% HAUT donc toujours au niveau BAS) et 255 (100% HAUT donc toujours au niveau HAUT).<\/p>\n

– Exemple<\/u> :<\/p>\n

Le programme suivant fixe la luminosit\u00e9 d’une LED proportionnellement \u00e0 la valeur de la tension lue depuis un potentiom\u00e8tre :<\/p>\n\n\n\n

\n\n\n\n
\n

int ledPin = 9; \/\/ LED connect\u00e9e sur la broche 9<\/span><\/span>
int analogPin = 3; \/\/ le potentiom\u00e8tre connect\u00e9 sur la broche analogique 3<\/span> <\/span>
int val = 0; \/\/ variable pour stocker la valeur de la tension lue<\/span><\/span><\/p>\n

void setup()<\/span>
{<\/span>
pinMode(ledPin, OUTPUT); \/\/ configure la broche en sortie<\/span><\/span>
}<\/span><\/p>\n

void loop()<\/span>
{<\/span>
val = analogRead(analogPin); \/\/ lit la tension pr\u00e9sente sur la broche en entr\u00e9e<\/span><\/span>
analogWrite(ledPin, val \/ 4);
<\/span>\/\/ R\u00e9sultat d’analogRead entre 0 to 1023, <\/span><\/span>
\/\/ r\u00e9sultat d’analogWrite entre 0 to 255<\/span>
\/\/ => division par 4<\/span> <\/span>
}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

Remarques<\/u><\/strong> :<\/p>\n

– Il n’est pas n\u00e9cessaire de faire appel \u00e0 l’instruction pinMode() pour mettre la broche en sortie avant d’appeler la fonction analogWrite().<\/p>\n

– L’impulsion PWM g\u00e9n\u00e9r\u00e9e sur les broches 5 et 6 pourront avoir des rapport cyclique plus long que pr\u00e9vu en raison de l’interaction avec les instructions millis() et delay(), qui partagent le m\u00eame timer (base de temps) interne que celui utilis\u00e9 pour g\u00e9n\u00e9rer l’impulsion de sortie PWM.<\/p>\n\n\n\n

 <\/h4>\n

<\/a>3. Fonctions pr\u00e9d\u00e9finies des Entr\u00e9es\/Sorties avanc\u00e9es<\/u><\/strong><\/h4>\n


. tone()<\/span><\/strong><\/h4>\n

G\u00e9n\u00e8re une onde carr\u00e9e (onde sym\u00e9trique avec rapport cyclique (niveau haut\/p\u00e9riode) \u00e0 50%), \u00e0 la fr\u00e9quence sp\u00e9cifi\u00e9e en Hertz (Hz) sur une broche.<\/p>\n

La dur\u00e9e peut \u00eatre pr\u00e9cis\u00e9e, sinon l’impulsion continue jusqu’\u00e0 l’appel de l’instruction noTone().<\/p>\n

La broche peut \u00eatre connect\u00e9e \u00e0 un buzzer pi\u00e9zo\u00e9lectrique ou autre haut-parleur pour jouer des notes (les sons audibles s’\u00e9tendent de 20Hz \u00e0 20 000Hz).<\/p>\n

Une seule note peut \u00eatre produite \u00e0 la fois. Si une note est d\u00e9j\u00e0 jou\u00e9e sur une autre broche, l’appel de la fonction tone() n’aura aucun effet (tant qu’une instruction noTone() n’aura pas eu lieu).<\/p>\n

 Si la note est jou\u00e9e sur la m\u00eame broche, l’appel de la fonction tone() modifiera la fr\u00e9quence jou\u00e9e sur cette broche.<\/p>\n

– Syntaxe<\/u> :<\/p>\n

tone(broche, frequence)<\/strong><\/p>\n

tone(broche, frequence, dur\u00e9e)<\/strong><\/p>\n

– Param\u00e8tres<\/u> :<\/p>\n

broche<\/strong> : la broche sur laquelle la note est g\u00e9n\u00e9r\u00e9e.<\/p>\n

frequence<\/strong> : la fr\u00e9quence de la note produite en hertz (Hz)<\/p>\n

dur\u00e9e <\/strong>: la dur\u00e9e de la note en millisecondes (optionnel)<\/p>\n

 <\/p>\n

<\/a>. noTone()<\/strong><\/span><\/h4>\n

Stoppe la g\u00e9n\u00e9ration d’impulsion produite par l’instruction tone(). N’a aucun effet si aucune impulsion n’est g\u00e9n\u00e9r\u00e9e.<\/p>\n

– Syntaxe<\/u> :<\/p>\n

noTone(broche)<\/strong><\/p>\n

– Param\u00e8tres<\/u> :<\/p>\n

broche <\/strong>: la broche sur laquelle il faut stopper la note.<\/p>\n

 <\/p>\n

<\/a>. pulseIn()<\/strong><\/span><\/h4>\n

Lit la dur\u00e9e d’une impulsion (soit niveau HAUT, soit niveau BAS) appliqu\u00e9e sur une broche (configur\u00e9e en ENTREE).<\/p>\n

Par exemple, si le param\u00e8tre valeur est HAUT, l’instruction pulseIn()<\/strong> attend que la broche passe \u00e0 HAUT, commence alors le chronom\u00e9trage, attend que la broche repasse au niveau BAS et stoppe alors le chronom\u00e9trage.<\/p>\n

L’instruction renvoie la dur\u00e9e de l’impulsion en microsecondes. L’instruction s’arr\u00eate et renvoie 0 si aucune impulsion n’est survenue dans un temps sp\u00e9cifi\u00e9.<\/p>\n

Il est pr\u00e9f\u00e9rable de travailler avec des impulsions d’une dur\u00e9e de 10 microsecondes \u00e0 3 minutes.<\/p>\n

– Syntaxe<\/u> :<\/p>\n

pulseIn(broche, valeur)<\/strong><\/p>\n

pulseIn(broche, valeur, delai_sortie)<\/strong><\/p>\n

– Param\u00e8tres<\/u> :<\/p>\n

broche<\/strong> : le num\u00e9ro de la broche sur laquelle vous voulez lire la dur\u00e9e de l’impulsion.<\/p>\n

valeur<\/strong> : le type d’impulsion \u00e0 \u00ab\u00a0lire\u00a0\u00bb : soit HIGH (niveau HAUT) ou LOW (niveau BAS<\/p>\n

delai_sortie<\/strong> (optionnel): le nombre de microsecondes \u00e0 attendre pour d\u00e9but de l’impulsion. La valeur par d\u00e9faut est 1 seconde. (type unsigned long)<\/p>\n

– Valeur renvoy\u00e9e<\/u> :<\/p>\n

La dur\u00e9e de l’impulsion (en microsecondes) ou 0 si aucune impulsion n’a d\u00e9marrer avant le d\u00e9lai de sortie. (type unsigned long)<\/p>\n

– Exemple<\/u> :<\/p>\n\n\n\n

\n\n\n\n
\n

int broche = 7; \/\/ variable de broche<\/span><\/span>
unsigned long duree; \/\/ variable utilis\u00e9e pour stocker la dur\u00e9e<\/span><\/span><\/p>\n

void setup()<\/span>
{<\/span>
pinMode(broche, INPUT); \/\/ met la broche en entr\u00e9e<\/span><\/span>
}<\/span><\/p>\n

void loop()<\/span>
{<\/span>
duree = pulseIn(broche, HIGH); \/\/ met la dur\u00e9e de l’impulsion de niveau HAUT dans la variable duree<\/span><\/span>
}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

 <\/p>\n

<\/a>4. Fonctions pr\u00e9d\u00e9finies de gestion du temps<\/u><\/strong> 

<\/h4>\n

. delay(ms)<\/strong><\/span><\/h4>\n

R\u00e9alise une pause dans l’ex\u00e9cution du programme pour la dur\u00e9e (en millisecondes) indiqu\u00e9e en param\u00e8tre.<\/p>\n

– Syntaxe<\/u> :<\/p>\n

delay (ms);<\/strong><\/p>\n

– Param\u00e8tres<\/u> :<\/p>\n

ms <\/strong>(unsigned long): le nombre de millisecondes que dure la pause<\/p>\n

 <\/p>\n

<\/a>. unsigned long millis()<\/strong><\/span><\/h4>\n

Renvoie le nombre de millisecondes depuis que la carte Arduino a commenc\u00e9 \u00e0 ex\u00e9cuter le programme courant. Ce nombre d\u00e9bordera (c\u00e0d sera remis \u00e0 z\u00e9ro) apr\u00e8s 50 jours approximativement.<\/p>\n

– Syntaxe <\/u>:<\/p>\n

variable_unsigned_long = millis();<\/strong><\/p>\n

– Exemple<\/u> :<\/p>\n\n\n\n

\n\n\n\n
\n

unsigned long time;
<\/span>
void setup(){<\/span>
Serial.begin(9600);<\/span>
}

<\/span>void loop(){<\/span>
Serial.print(\u00ab\u00a0Time: \u00ab\u00a0);<\/span>
time = millis();<\/span>
\/\/affiche sur le PC le temps depuis que le programme a d\u00e9marr\u00e9<\/span>
Serial.println(time);<\/span>
\/\/ pause d’une seconde afin de ne pas envoyer trop de donn\u00e9es au PC<\/span>
delay(1000);<\/span>
}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

 <\/h4>\n

<\/a>5. Fonctions pr\u00e9d\u00e9finies de communication

<\/u><\/strong><\/h4>\n

La librairie Serial<\/strong> est utilis\u00e9e pour les communications par le port s\u00e9rie entre la carte Arduino et un ordinateur ou d’autres composants.<\/p>\n

Le port s\u00e9rie communique sur les broches 0 (RX) et 1 (TX) avec l’ordinateur via le port USB. C’est pourquoi, si on utilise cette fonctionnalit\u00e9, il n\u2019est pas possible d\u2019utiliser les broches 0 et 1 en tant qu’entr\u00e9es ou sorties num\u00e9riques.<\/p>\n

Le logiciel Arduino IDE dispose d\u2019un moniteur s\u00e9rie, qui permet de recevoir et d\u2019envoyer des informations via une liaison s\u00e9rie. Il est particuli\u00e8rement int\u00e9ressant pour les tests des programmes puisqu\u2019il permet d\u2019afficher les valeurs des variables, les \u00e9tats logiques des entr\u00e9es et des sorties de l\u2019Arduino, etc\u2026<\/p>\n

Il suffit pour cela de cliquer sur le bouton du moniteur s\u00e9rie dans la barre d’outils puis de s\u00e9lectionner le m\u00eame d\u00e9bit de communication que celui utilis\u00e9 dans l’appel de la fonction begin() pour \u00e9tablir la liaison s\u00e9rie.<\/p>\n

Les principales fonctions de la librairie Serial<\/strong> :<\/p>\n

. begin(); <\/strong>     (Configure la vitesse de transmission du port s\u00e9rie)<\/p>\n

. print();<\/strong>        (Envoie une donn\u00e9e sous forme de chaine de caract\u00e8res sur le port s\u00e9rie)<\/p>\n

. println();<\/strong>    (Envoie une donn\u00e9e sur le port s\u00e9rie et fait un saut \u00e0 la ligne)<\/p>\n

. write();<\/strong>       (Ecrit des donn\u00e9es binaires sur le port s\u00e9rie. Ces donn\u00e9es sont envoy\u00e9es comme une s\u00e9rie d\u2019octets)<\/p>\n

. read();<\/strong>        (Lis les donn\u00e9es contenues dans la m\u00e9moire tampon (buffer) du port s\u00e9rie)<\/p>\n

. flush();<\/strong>        (Vide la m\u00e9moire tampon de la liaison s\u00e9rie)<\/p>\n

. available();<\/strong> (Donne le nombre d\u2019octets (caract\u00e8res) disponible pour lecture dans la file d\u2019attente (buffer) du port s\u00e9rie)<\/p>\n

 <\/p>\n

Une fois la liaison s\u00e9rie \u00e9tablie dans la fonction setup()<\/strong> avec la fonction Serial.begin()<\/strong>, il est possible d\u2019envoyer des donn\u00e9es depuis la carte Arduino vers le moniteur s\u00e9rie avec la fonction \u201dprint()<\/strong>\u201d de la classe \u201dSerial<\/strong>\u201d.<\/p>\n

On peut envoyer diff\u00e9rents types d\u2019informations :<\/p>\n

. Envoie d\u2019une cha\u00eene de caract\u00e8res, sans saut de ligne \u00e0 la fin :<\/p>\n

Serial.print(\u201dTest\u201d);<\/strong><\/p>\n

. Envoie d\u2019une cha\u00eene de caract\u00e8res, avec saut de ligne \u00e0 la fin :<\/p>\n

Serial.println(\u201dTest\u201d);<\/strong><\/p>\n

. Envoie de la valeur d\u2019une variable, sans saut de ligne \u00e0 la fin :<\/p>\n

int a = 3;
<\/strong>Serial.print(a);<\/strong><\/p>\n

– Exemple<\/u> :<\/p>\n\n\n\n

\n\n\n\n
\n

int analogValue = 0; \/\/ variable pour stocker la valeur analogique sur la broche A0<\/span><\/span>

void setup() { <\/span>
\/\/ initialise le port s\u00e9rie \u00e0 9600 bauds<\/span> <\/span>
Serial.begin(9600); <\/span>
} <\/span>

void loop() { <\/span>
\/\/ lit la valeur analogique sur la broche A0<\/span> <\/span>
analogValue = analogRead(0);<\/span><\/p>\n

\/\/ affiche cette valeur<\/span> <\/span>
Serial.println(analogValue); <\/span>
}<\/span> <\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

 <\/p>\n

<\/a>6. Fonctions propres au progamme

<\/u><\/strong><\/h4>\n

Pour pouvoir utiliser une fonction propre \u00e0 un programme, il faut au pr\u00e9alable la d\u00e9clarer et comme son appel doit \u00eatre possible \u00e0 tout moment du d\u00e9roulement du programme, il faut qu’elle soit d\u00e9clar\u00e9e de fa\u00e7on globale. C’est-\u00e0-dire que cela se fera en dehors des fonctions setup()<\/strong> et loop()<\/strong>.<\/p>\n

Une fonction poss\u00e8de un nom, des param\u00e8tres d’entr\u00e9e et des param\u00e8tres de sortie. On appelle prototype d’une fonction<\/strong>, la sp\u00e9cification de ces trois donn\u00e9es :<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Et tout ce que fait la fonction doit \u00eatre plac\u00e9 entre deux accolades.<\/p>\n

 <\/p>\n

Il existe deux types de fonctions :<\/p>\n

– Les fonctions qui ne renvoie aucune donn\u00e9e,<\/p>\n

– Les fonctions qui renvoie une donn\u00e9e.<\/p>\n

 <\/p>\n

. Si la fonction ne renvoie aucune donn\u00e9e, son type de retour sera void<\/strong>.<\/p>\n

Exemple<\/u> :<\/p>\n

Ce programme affiche le r\u00e9sultat de la division de 10 par 3 avec 1 \u00e0 5 chiffres apr\u00e8s la virgule, dans le moniteur s\u00e9rie.<\/p>\n

Pour cela, on d\u00e9clare une fonction appel\u00e9e affichfloat<\/strong>() dont le type de retour est void<\/strong> (vide) et les param\u00e8tres d\u2019entr\u00e9es sont le nombre \u00e0 virgule, (float<\/strong>) a, <\/strong>\u00e0 afficher et un entier, b, <\/strong>repr\u00e9sentant le nombre de chiffres apr\u00e8s la virgule du nombre a<\/strong> qui seront affich\u00e9s.<\/p>\n

La fonction est appel\u00e9e dans une boucle for() <\/strong>de la fonction setup() et le r\u00e9sultat de la division est affich\u00e9 dans le moniteur s\u00e9rie.<\/p>\n\n\n\n

\n\n\n\n
\n

void affichfloat(float a, int b) { \/\/ D\u00e9claration de la fonction \u00ab affichfloat \u00bb<\/span><\/span>
Serial.println(a,b); \/\/ Affichage de la variable a avec b chiffres apr\u00e8s la virgule<\/span><\/span>
}<\/span><\/p>\n

void setup() {<\/span>
Serial.begin(9600);<\/span>
float result = 10.0\/3.0;<\/span>
for(int i = 1 ; i < 6 ; i++){ <\/span>
affichfloat(result,i); \/\/ Appel de la fonction \u00ab affichfloat \u00bb<\/span><\/span>
}<\/span>
}<\/span><\/p>\n

void loop() {<\/span>
}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n


. Si la fonction renvoie une donn\u00e9e, elle devra le faire avec le mot-clef return<\/strong>.<\/p>\n

Exemple<\/u> :<\/p>\n

Le programme suivant affiche la table de multiplication de 2 dans le moniteur s\u00e9rie. Pour cela, une fonction appel\u00e9e multiplication() <\/strong>dont le type de retour est un entier c<\/strong> et les param\u00e8tres d\u2019entr\u00e9es sont 2 entiers a <\/strong>et b <\/strong>est d\u00e9clar\u00e9e.<\/p>\n

La fonction est appel\u00e9e dans une boucle for() <\/strong>de la fonction setup() et le r\u00e9sultat de la multiplication est affich\u00e9 dans le moniteur s\u00e9rie.<\/p>\n\n\n\n

\n\n\n\n
\n

int multiplication (int a, int b) { \/\/ D\u00e9claration de la fonction \u00ab multiplication \u00bb<\/span><\/span>
int c ;<\/span>
c = a * b ;<\/span>
return c ;<\/span>
}
<\/span>
void setup() {<\/span>
Serial.begin(9600);<\/span>
for(int i = 1 ; i < 10 ; i++){ <\/span>
int result = multiplication(2,i); \/\/ Appel de la fonction \u00ab multiplication \u00bb<\/span><\/span>
Serial.println(result); \/\/ Affichage de la donn\u00e9e de retour de la fonction \u00ab multiplication \u00bb<\/span><\/span>
} <\/span>
}
<\/span>
void loop() {<\/span>
}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

\u00a0<\/p>\n


Apr\u00e8s avoir vu les bases de la programmation en langage Arduino, nous allons maintenant \u00e9crire notre premier programme bas\u00e9 sur \u00ab Blink \u00bb, qui comme vous l\u2019avez compris, met en application le principe de fonctionnement d\u2019une sortie num\u00e9rique, en faisant intervenir des variables.<\/p>\n

\u00a0<\/p>\n\n\n

\n
\n\n
\"\"<\/a><\/figure><\/div>\n\n<\/div>\n\n
\n\n
\"\"<\/a><\/figure><\/div>\n\n<\/div>\n<\/div><\/div>\n\n\n\n","protected":false},"excerpt":{"rendered":"

Une fonction est un bloc d\u2019instructions que l\u2019on peut appeler \u00e0 tout endroit d\u2019un programme. En langage Arduino, des biblioth\u00e8ques de fonctions pr\u00e9d\u00e9finies sont disponibles afin de manipuler facilement les entr\u00e9es\/sorties, g\u00e9rer le temps, g\u00e9rer la communication s\u00e9rie\u2026 On peut \u00e9galement cr\u00e9er ses propres fonctions qui seront utiles pour l’ex\u00e9cution de t\u00e2ches r\u00e9p\u00e9titives et \u00e9vitant […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-1633","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/pages\/1633","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1633"}],"version-history":[{"count":0,"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/pages\/1633\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1633"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}