Licence CC BY

Arduino (documentation et exemples)

Trucs et astuces

Pense-bête

Voici un petit schéma reprenant les entrées et sorties de l'Arduino UNO. Ça peut être bien pratique :

Arduino Uno

Arrêtez : je veux descendre !

La structure d'un Sketch ou programme pour l'Arduino est une procédure setup() appelée une fois après l'initialisation (reset) de l'Arduino, puis une loop() , c'est-à-dire une boucle, qui est appelée à l'infini…

Parfois il est utile de pouvoir arrêter le programme : à cause d'une erreur, par exemple. Comment faire ?

L'Arduino est infatigable : il ne s'arrête jamais. Mais on peut faire en sorte que notre Sketch s'arrête, en le bloquant. Une sorte de clef à mollette coincée dans l'engrenage…

Pour ce faire, on fait appel à une boucle qui ne se termine jamais. Comme ceci :

1
do { } while (true);  // arrêter le programme

Il n'y a rien entre les accolades {} : donc rien ne se passe, et la valeur true est toujours vraie (synonyme de la valeur 1).

L'Arduino va donc se mettre à ne rien faire de nouveau (toutes les sorties restent en l'état), jusqu'à ce qu'on appuie sur la touche "Reset" qui relance setup() puis loop().

Voici un exemple d'utilisation :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
void loop() {
  val = analogRead(ma_broche_analogique);
  if ( val != 0 ) {  // Si valeur = 0 un problème s'est produit
    faire_quelquechose();
  }
  else { // valeur = 0
    Serial.println("Erreur. J'en ai marre.");
    do { } while (true);  // grève générale
  }
}

Commandes compilateur

Si vous regardez le Sketch "ArduinomtreWeb", que j'ai publié semaine 10, vous verrez plusieurs lignes qui commencent par # (comme pour #include) mais qui ne sont pas des #define que j'utilise habituellement. Ce sont des compiler directives, ou des commandes pour diriger le compilateur.

Il y à deux formes dans ce sketch :

1
2
#define ARDUINO_UNO  
#define TRACES 1  

La première forme est utilisée pour définir un nom. Pour le compilateur, le nom existe, ou il n'existe pas. On peut faire, donc :

1
2
3
4
5
#if defined ARDUINO_UNO
  #define Ether_CS 8 // Broche sur laquelle nous avons branché CS (UNO)
#else
  #define Ether_CS 48 // Broche sur laquelle nous avons branché CS (MEGA)
#endif  

et aussi

1
2
3
4
5
#if defined ARDUINO_UNO
  analogReference(INTERNAL);  // UNO
#else
  analogReference(INTERNAL1V1);  // Mega
#endif  

Notez bien que ce sont des directives pour le compilateur : ce ne sont pas des instructions en C proprement dit. Par la déclaration de #define ARDUINO_UNO ou #define ARDUINO_MEGA au début de mon sketch je peux faire compiler le même sketch correctement pour un Arduino Uno ou un Arduino Mega.

L'autre forme #define TRACES 1, elle, attribue une valeur binaire au nom déclaré. C'est très pratique pour supprimer des morceaux de code (les Serial.print, par exemple) sans pour autant les perdre pour toujours. Parfois une fonction est difficile à mettre au point : on passe du temps à écrire des commandes pour nous afficher des résultats sur le serial monitor, on pense que c'est corrigé, mais pas complètement sûr … Avec les commandes suivantes on peux recompiler le Sketch sans les traces, mais si on a à nouveau besoin on ne change qu'une ligne en haut du sketch ! Comme ici :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
void loop() {
  word len = ether.packetReceive();
  word pos = ether.packetLoop(len);

#if TRACES
  if (len && pos) {
    Serial.print("|");
    for (count = pos; count<len; count++) {
      Serial.print(char(Ethernet::buffer[count]));
    }
  Serial.println("|");
  Serial.print("Longueur message : ");
  Serial.println(len);
  }

  if (pos) {
    Serial.print("Pos :");
    Serial.println(pos); 
  }
#endif
}  

Si #define TRACES 0 est déclaré dans le Sketch, le compilateur va compiler ceci :

1
2
3
4
void loop() {
  word len = ether.packetReceive();
  word pos = ether.packetLoop(len);
}  

Tout ce qui se trouve entre le #if et le #endif est traité comme si nous l'avions mis en commentaire et donc n'est pas compilé.

Mise en forme du texte

Les fonctions standards lcd.print et Serial.print n'ont pas beaucoup de moyens pour gérer la mise en forme d'un texte. Il existe une bibliothèque stdio.h qui nous offre des fonctions très puissantes, comme sprintf() - mais cette bibliothèque est très gourmande en ressources - et souvent nous mange presque toute la mémoire RAM de notre Arduino.

Vous avez vu avec le montage "Arduinoweb" qu'il est utile de pouvoir formater du texte sans pour autant faire appel à la grosse cavalerie de stdio.h.

C'est pour cela que j'ai déniché une autre bibliothèque, plus petite et un peu moins performant - mais aussi moins gourmande : stdarg.h. Avec cette bibliothèque nous avons accès à une fonction vsnprintf() qui sert à la mise en forme d'un message avant son impression, affichage ou, comme dans l'exemple "Ardruinoweb" inclusion dans une page html ou php.

Voici comment s'en servir :

Déclaration

Toute au début du sketch il faut déclarer la bibliothèque avec

1
#include <stdarg.h>  

Variables

Pour fonctionner, vsnprintf() à besoin d'une zone tampon en mémoire. Il faut dimensionner cette zone (on l'appel "buffer" en anglais) avec soin : trop grande et nous n'aurions plus de place pour nos variables; trop petite et la fonction va se mettre à écraser des données… Essayez de calculer le nombre maximum de symboles que nous avons besoin de formater - avec un minimum de texte statique (qui ne change pas). N'oubliez pas la règle : il faut toujours ajouter un octet de plus que le nombre de symboles, pour stocker la fin de chaîne '\0'.

Calculs faits, nous pouvons créer notre zone tampon :

1
char formatString[33];  

Le nom n'est pas important mais comme toujours il faut mieux lui donner un nom qui nous explique ce qu'il fait! D'habitude on déclare cette variable en tant que globale (c'est à dire avant setup()) pour qu'elle soit accessible par tout le monde.

La fonction vsnprintf()

Je trouve que la meilleure façon de déclarer cette fonction est de "l'encapsuler" dans une fonction complète. Voici comment je fais :

1
2
3
4
5
6
void format(char *fmt, ... ){
  va_list args;
  va_start (args, fmt );  // allocation d'espace en mémoire
  vsnprintf(formatString, 32, fmt, args);  // formatage du message
  va_end (args);  // libération des ressources.
}  

Pour comprendre comment ça marche, regardons toute de suite comment s'en servir, avec un appel à notre fonction :

1
format("Valeur : %04d, environ %02d°C", v1, v2);  

L'idée ici c'est de 'formater' les deux valeurs v1 et v2 et de les inclure dans le message. Je vais expliquer les hiéroglyphes après les % un peu plus loin.

La première chose bizarre est que, dans la déclaration de notre fonction format() nous n'avons pas un nombre fixe d'arguments. C'est un peu normal car on ne sait pas d'avance combien de valeurs on va vouloir formater. Le premier argument char *fmt nous fait passer un pointeur vers notre texte de départ, au lieu de passer le texte entier. Les points de suspension fait réserver de la place pour 1 ou plus d'arguments additionnels.
La ligne suivante, va_list args déclare une variable args de type va_list (va_list est déclaré dans la bibliothèque) : c'est cette variable qui va contenir les arguments que nous passerons à la fonction.

va_start (args, fmt ); initialise l'environnement pour vsnprintf(), récupère nos arguments pour les stocker dans args et prépare le boulot pour la suite.

vsnprintf(formatString, 32, fmt, args); Pour terminer le boulot. Le "32" c'est le nombre de symboles maximum à écrire dans notre zone tampon. Si le message résultant est plus long, il est 'tronqué' : les symboles de trop sont jetés. Il ne nous reste qu'à faire le ménage (libérer les ressources attribués avec va_start) : va_end (args); Voilà.

Si la valeur de v1 était 1023 et celle de v2 était 26, le message résultant serait

1
Valeur : 1023, environ 26°C

Les hiéroglyphes

C'est la partie la plus intéressante !

Chaque fois que vsnprintf() trouve un % dans le message, il cherche à décoder des commandes de formatage, lui indiquant la forme que nous voulions. D'abord on lui indique le nombre d'emplacements à réserver, et optionnellement le nombre de places décimales pour les nombres de type float.

Exemples :

1
2
3
2       2 caractères  
02      2 caractères, "0"s de remplissage  
3.02    3 digits dont deux digits après la virgule  

Et après vient la type de résultat. Il faut que les types du format demandé et l'argument correspondent (on ne peut pas formater une variable de type int en %2.03f, par exemple). Voici quelques exemples :

1
2
3
4
5
6
%i ou %d    int  
%x ou %X    int exprimé en hexadécimal (minuscule/majuscule)
%c          char  
%f          float  
%e ou %E    float en format SCI (1.42e34)  
%s          string  

Et quelques exemples plus concrets:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
{  
  int a,b;  
  float c,d;  
  a = 15;  
  b = a / 2;  
  format("%d",b); 
  Serial.println(formatString); 
  format("%3d",b);  
  Serial.println(formatString); 
  format("%03d",b);  
  Serial.println(formatString); 
  c = 15.3;  
  d = c / 3;  
  format("%3.2f",d);  
  Serial.println(formatString); 
}  

Donnera :

1
2
3
4
7  
  7  
007  
5.10  

Pour plus d'exemples et pour plus d'informations il faut se référer à un livre, un cours, un tutoriel de programmation en C.

Le bouton rotatif

Le Bouton Dompté

Voici le bouton rotatif, Parfois appelé Encodeur rotatif. Quelques images :

L'encodeur vue de profil

L'encodeur vue de dos

et une forme de symbole

Un symbole électronique de l'encodeur

Objet d'apparence simple, pas très cher ( moins de 3€ pour un modèle simple avec contacteur ), sa simplicité est rapidement oubliée quand il s'agit de faire quelque chose avec. Voici le problème :

Chronogramme de l'encodeur

(image : merci Arduino Playground. Article avec beaucoup d'infos ici )

Les deux broches A et B font contact de temps en temps avec la connexion commune. Leur séquence est décalée d'un quart de cycle. Le "challenge" est de décoder le sens de rotation et le nombre de cycles parcourus chaque fois qu'on tourne le bouton. C'est un défi car les impulsions peuvent êtres rapides si on tourne le bouton avec un peu de d'énergie !

Le deuxième problème avec certains boutons c'est qu'ils sont très bruyants. Non, ils ne chantent pas - ils génèrent beaucoup de parasites dus à leur conception mécanique (effet de rebonds). Nous avons déjà vu que les condensateurs nous aident à diminuer les effets des rebonds de contacts, regardons ensemble comment résoudre le problème informatique.

Une solution, parmi des dizaines, relativement simple est abordée dans l'article d'Arduino Playground, solution que je vais tenter d'expliquer ici.

Sens de rotation

Si on regarde l'image, et qu'on ne se soucie que de la broche A, et que les flancs montants (endroit où le signal va de 0V vers 5V) : en tournant le bouton vers la droite, on peut remarquer qu'à chaque flanc montant de A, le signal B est stable et à 5V. Si on tourne dans l'autre sens (de droite à gauche), à chaque flanc montant de A, le signal B est stable et à 0V. Pour compter le nombre de cycles, il faut compter le nombre de flancs montants.

Cette solution est simple et peut déjà faire l'affaire pour nous. Reste le problème de comment détecter les mouvements pendant le déroulement de notre Sketch Arduino.

Désolé de vous interrompre

Si vous avez suivi le module sur les interruptions (semaine 9) vous avez sûrement deviné comment faire. Si on raccorde la broches A à une entrée INT sur l'Arduino, on peut détecter les flancs montants avec la déclaration :

1
attachInterrupt(0, doSomething, RISING);

Le 0 veut dire qu'on veux utiliser INT0 (c'est la broche 2 de l'Arduino) ; doSomething est le nom de notre fonction de traitement d'interruption ; RISING veut dire interruption sur flancs montants.

La broche B est connectée à n'importe quelle entrée numérique : pas besoin d'interruption car on va juste vérifier son état au moment où détecte le flanc montant A.

Voici à quoi peut ressembler notre fonction ISR (Interrupt Service Routine) :

1
2
3
4
5
6
void doSomething() {
  if (digitalRead(boutonPinB) == 1)
    bouton++;
  else
    bouton--;
}

La déclaration et la fonction font en sorte que, peu importe ce que fait notre programme à nous, les flancs montants de la broche A du bouton sont détectés automatiquement (invisiblement) - le sens de rotation est calculé (on lit l'état de la broche B) - et la valeur d'une variable "bouton" est augmentée ou diminuée pour chaque impulsion d'A.

Il nous reste à vérifier si la valeur de bouton a changé et de faire le nécessaire. L'ajout d'une deuxième variable, de type boolean (valeurs "vrai" ou "faux"), peut nous aider.

Montage

Voici le montage sur platine avec Fritzing. Le bouton poussoir sur la droite simule le bouton de contact (broches 4 et 5) qui se déclenche quand on appuie sur le bouton rotatif. L'encodeur dans Fritzing n'est pas équipé avec ce bouton.

Montage de l'encodeur

Et le schéma. Notez bien les condensateurs. Aussi vous notez que, pour le contact d'appui, j'ai ajouté une résistance de pull-up à la place de la résistance interne : c'est parce que le bouton que j'ai générait beaucoup de parasites et il fallait réduire la résistance de pull-up pour réduire les effets de rebond. Essayez chez vous sans la résistance d'abord (en changant la déclaration pour la broche d'entrée de INPUT à INPUT_PULLUP), mais si vous remarquez des réactions aléatoires, câblez les contacts du bouton comme dessiné ici.

Branchement de l'encodeur

Sketch

Voici le sketch en entier :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
/*
  Gestion d'un bouton/encodeur rotatif avec interruptions
  La broche commun, et un des deux broches du bouton de contact
  sont branchées sur GND.
  Des condensateurs de 100nF sont conseillés en // avec les trois
  broches de contact (A, B, et bouton)
  La broche "A" est branchée sur l'entrée 2 sur Arduino (INT0)
  Bouton est branché sur l'entrée 3 sur Arduino (INT1)
  La broche "B" est branchée sur n'importe entrée numérique

  Le sens de l'encodeur (broche A / B) n'est pas important :
  il est facile de changer le "sens de rotation" dans le code

  Les entrées sont déclarées avec les résistances de pullup activées

  Varier la luminosité d'un LED

  Glenn Smith  MOOC Fabrication Numérique  Mai 2014
*/ 

#define boutonPinA  2  // C'est l'entrée INT0
#define boutonPinB  4  // Pas d'interruption
#define boutonPinC  3  // (contact pression) C'est  l'entrée INT1

#define GreenLed 9  // ou n'importe sortie numérique

volatile byte valeur_encodeur = 0;  // volatile changé en cachette par l'ISR
volatile boolean encodeur_changed = false;
volatile boolean contact = false;

byte  brightness;

// Les deux fonctions ISR

void doContact() {
  // Nous arrivons ici sur flanc descendant sur broche 3
  contact = true;
}

void doEncoder() {
//  Nous arrivons ici sur flanc montant sur broche 2
if (digitalRead(boutonPinB) == 1) // Lire broche "B" de l'encodeur
  valeur_encodeur++;  // Direction +ve : augmenter la valeur
else 
  valeur_encodeur--;  // Direction -ve : diminuer la valeur
}

void setup() { 
  pinMode(boutonPinA, INPUT_PULLUP); 
  pinMode(boutonPinB, INPUT_PULLUP); 
  pinMode(boutonPinC, INPUT_PULLUP);

  pinMode(GreenLed, OUTPUT);

  // encoder pin "A" on interrupt 0 - (pin 2)
  attachInterrupt(0, doEncoder, RISING);
  // encoder pin "C" on interrupt 1 - (pin 3)
  attachInterrupt(1, doContact, FALLING);

  Serial.begin (115200);
  Serial.println("Hello");
}

void loop(){
  if ( contact ) {  // est ce que le bouton à été appuyé ?
    Serial.print ("Varier l'intensite, appuyer pour sauvegarder : ");
    contact = false;  // sinon on ne s'arrête jamais !
    do {
      // utilise la valeur pour gérer une LED
      brightness = constrain((valeur_encodeur * 4), 0, 255);
      analogWrite(GreenLed, brightness);
    // rester dans cette boucle tant que le bouton n'a pas été appuyé
    }  while (not contact);
  contact = false;   // sinon on s'arrête jamais !
  Serial.print("New value= ");
  Serial.println(valeur_encodeur, DEC);
  delay(500);
  }
}  

Simulation du bouton rotatif

Si vous n'avez pas l'encodeur rotatif dans vos pièces, ce montage avec 3 boutons classiques sert à démontrer comment utiliser deux interruptions pour gérer plusieurs boutons.

Le montage

Platine

Montage avec 3 boutons

Schéma

Schéma électronique avec 3 boutons

Le boutons "A" et "B" font l'office des contactes A et B du bouton rotatif. Le troisième bouton est notre bouton d'appel / validation.

Vous pouvez utiliser le même Sketch que pour le vrai bouton rotatif, vérifier simplement que l'entrée "C" (pin 2) soit déclarée en INPUT-PULLUP pour activer la résistance pull-up.

Utilisation

On peut considérer le bouton "C" comme un bouton d'appel : pour dire qu'on veut changer un paramètre, par exemple. Si on clic sur "A" cela fait incrémenter notre variable. Si on maintient "B" appuyé et on clic sur "A" la variable est décrémentée.

Il est possible de construire des menus avec juste ces trois entrées. Essayer avec l'afficheur LCD

N.B. : Si vous voulez ajouter l'afficheur LCD il faut changer un peu le câblage par rapport à l'exemple Aduinomètre, mais les commentaires dans le sketch devraient suffire pour vous guider.

Quelques liens et autres documents utiles

Zeste de Savoir

Il y a un tutoriel très complet sur Zeste de Savoir : https://zestedesavoir.com/tutoriels/537/arduino-premiers-pas-en-informatique-embarquee/

Ainsi qu'une catégorie regroupant différents tutoriels sur ce thème : https://zestedesavoir.com/tutoriels/?tag=arduino

Le site mon-club-elec (à voir vraiment)

Le site www.mon-club-elec.fr est avant tout un site perso amateur sur lequel sont mis en ligne des développements en électronique numérique programmée, dans une optique ludique et expérimentale, "just for fun" ! www.mon-club-elec.fr... voudrait aussi être un site fait pour tous ceux qui veulent s'y mettre et qui cherchent de l'info !

Lien vers l'accueil du site "mon-club-elec partie électronique numérique programmée"

Plus spécifiquement sur Arduino, cette partie est la traduction en français et commentée de la référence officielle (en anglais) du langage Arduino. Il constitue en quelque sorte un site miroir en français du site Arduino officiel.

Lien vers la partie "Référence Arduino français"

Le site flossmanuals (les livres FabLabs et Arduino)

Flossmanuals est une plateforme de partage de livres électroniques sur les logiciels et matériels libres.

Lien vers le livre FabLabs

Lien vers le livre Arduino

Logiciels autour d'Arduino

Une des particularités des cartes Arduino est leur capacité à communiquer facilement avec d’autres logiciels, également libres, pour piloter des environnements multimédia en fonction de grandeurs physiques détectées par des capteurs, ou à l'inverse de piloter des actionneurs reliés à la carte à partir d’éléments multimédia et/ou d’un PC).

Processing

Processing est tout particulièrement adapté à la création plastique et graphique interactive, il s'adresse aux artistes en « arts numériques » et aux graphistes. (http://fr.wikipedia.org/wiki/Processing)

Documentation et exemples sur flossmanuals

MANUEL d’utilisation de Processing

Pure Data

Pure Data (en abrégé pd) est un logiciel de programmation graphique pour la création musicale et multimédia en temps réel. Il permet également de gérer des signaux entrants dans l'ordinateur (signaux de capteurs ou événements réseau par exemple) et de gérer des signaux sortants (par des protocoles de réseau ou protocoles électroniques pour le pilotage de matériels divers). (http://fr.wikipedia.org/wiki/Pure_Data)

Documentation et exemples sur flossmanuals


Pour la réalisation d’un circuit imprimé à partir d’un montage sur plaque d’essais, il existe de nombreux logiciels existant (image du montage, schéma, typon pour gravure …)

Fritzing

Fritzing est un projet de logiciel libre, destiné aux non-professionnels de l'électronique. Il a notamment pour vocation de favoriser l'échange de circuits électroniques libres et d'accompagner l'apprentissage de la conception de circuits. C’est un logiciel d'édition de circuit imprimé, disponible dans 16 langues dont le français. Il est adapté aux débutants ou confirmés en électronique pour faire rapidement des circuits simples, et est également un bon outil didactique pour apprendre à bidouiller en électronique par la pratique. (http://fr.wikipedia.org/wiki/Fritzing)

Téléchargement de Fritzing

Lexique électronique et informatique anglais → français

A

  • ADC (Analog to Digital Converter) : Convertisseur Analogique Numérique. Ce circuit électronique convertit une valeur analogique par échantillonnage et quantification en une valeur numérique.
  • Aliasing, anti-aliasing : crénelage, anti-crénelage, c'est-à-dire lissage, en parlant d'un flux de données.
  • API (Application Programming Interface) : Interface par laquelle une application peut contrôler une couche plus basse (par exemple : des pilotes de périphériques, une bibliothèque de manipulation de chaînes de caractères, etc.).

B

  • binary : binaire. Seulement Vrai / Faux, ou 0 / 1.
  • BJT (Bipolar Junction Transistor) : transistor à jonction bipolaire.
  • boolean : booléen, se dit d'un système qui ne peut avoir que deux états : vrai ou faux. Type de variable binaire.
  • bounce : rebond.
  • breadboard : plaque d'expérimentation.
  • breakdown : claquage.
  • bridge : pont.
  • bug : dysfonctionnement logiciel (bug signifie insecte, cafard, bestiole, et au début de l'informatique on imputait facilement toute erreur aux insectes qui venaient se coller sur les lampes à vide très chaudes et perturbaient le fonctionnement). Le premier bug était dû à un véritable cafard qui avait fait "planter" le premier ordinateur américain, dans les années 40.

C

  • calibration, to calibrate : étalonnage, étalonner.
  • capacitor : condensateur.
  • chip : puce électronique.
  • CMOS (Complementary Metal–Oxide–Semiconductor) : technologie de fabrication de circuit intégré.
  • CNC (Computer Numerical Control) : machine à commande numérique.
  • CPU (Central Processing Unit) : micro-processeur. Fait les calculs dans un ordinateur.
  • current : courant.

D

  • DAC (Digital to Analog Converter) : convertit une grandeur numérique en une grandeur analogique.
  • Darlington : montage en série de deux transistors ayant pour effet d'obtenir un gain global, en régime linéaire, égal au produit du gain de chaque transistor.
  • deadlock : étreinte fatale, se produit quand l'arbitrage de l'attribution d'une même ressource entre deux ou plusieurs sous-systèmes s'avère impossible car ils s'attendent mutuellement.
  • DEMUX (DEMUltipleXer) : démultiplexeur. Sépare des signaux disjoints ayant été transmis par un même canal.
  • DFA (Deterministic Finite Automaton) : automate déterministe à états finis. Technique logicielle qui permet de résoudre un problème en le décomposant en une série d'états et de transitions.
  • digit : chiffre.
  • digital : numérique. 0,1,2,3, …
  • DIY (Do It Yourself) : faites le par vous-même, fabriqué maison, se dit d'une réalisation amateur sans connotation péjorative. Règle d'or aux Fablabs et à l'utilisation d'Arduino.
  • download : action de télécharger un fichier depuis un serveur ou un périphérique.

E

  • earth : terre, point supposé être au potentiel commun de 0V (ne pas confondre avec la masse (ground)).
  • edge : segment de droite joignant deux sommets.

F

  • fan : ventilateur.
  • feedback : boucle de contre-réaction, rétro-action, retour d'information.
  • feet : pied, unité de mesure impériale correspondant à 0,3048 mètre dans le système international.
  • FET (Field-Effect Transistor) : transistor à effet de champ.
  • fetch (to) : aller chercher (des valeurs…)
  • firmware : logiciel chargé dans un système autonome ou un microcontrôleur (on parle plus rarement de magiciel).
  • flag : drapeau de signalement.
  • float : variable ou nombre à virgule flottante.
  • FPU (Floating Point Unit) : coprocesseur chargé d'effectuer des opérations mathématiques sur des nombres à virgule.
  • frequency : fréquence.

G

  • gain : facteur d'amplification.
  • GPIO (General-Purpose Input/Ouput) : bloc fonctionnel d'un micro-contrôleur gérant les entrées-sorties.
  • ground : masse, point arbitraire considéré comme étant au potentiel de référence de 0V (ne pas confondre avec la terre (earth)).

H

  • H-bridge : circuit permettant de commander des moteurs pas-à-pas au moyen de transistors de puissance.

I

  • I/O (Input / Output) : entrées / sorties.
  • I²C (Inter Integrated Circuit) : norme de communication série synchrone très utilisée en électronique pour faire communiquer des équipements entre eux (on parle aussi d'interface à deux fils). Inventée par Philipps.
  • IC (Integrated Circuit) : circuit intégré.
  • inch : pouce, unité de mesure impériale correspondant à 25,4 mm dans le système international.
  • Inductor : inductance ou, paradoxalement, en français self (terme qui n'est pas employé en anglais).

J

  • Jumper : cavalier, sur un circuit imprimé, ou fil éléctrique permettant de relier une broche à un composant, un capteur, une plaque d'essais, etc.

K

L

  • LDR (Light-Dependant Resistor) : photorésistance. Capteur de lumière.
  • LED (Light-Emitting Diode) : Diode ÉlectroLuminescente (DEL).
  • library : bibliothèque. Fonctions 'toutes prêtes' pour une utilisation dans son propre programme.
  • lock : verrou.
  • loop : boucle. Un des deux éléments nécéssaires aux programmes Arduino.
  • LSB (Least Significant Bit) : bit de poids faible dans un mot.

M

  • MCU (Micro Controller Unit) : microcontrôleur disposant d'entrées sorties analogiques et numériques et de fonctions permettant de manipuler des capteurs et des effecteurs.
  • mesh : maillage. (modélisation 3D)
  • mil (ou thou) : unité de mesure impériale correspondant à un millième de pouce (inch) soit dans le système international 25,40 µm ou encore 0,0254 mm.
  • MOSFET (Metal Oxyde Semiconductor Field-Effect Transistor) : transistor à effet de champ à grille métal-oxyde.
  • MSB (Most Significant Bit) : bit de poids fort dans un mot.
  • MUX (MUltipleXer) : multiplexeur. Joint des signaux distincts de façon à les transmettre par un même canal.

N

O

  • offset : décalage.
  • Op-Amp (Operational Amplifier) : amplificateur opérationnel ou (par abus de langage) amplificateur différentiel.

P

  • parsing, to parse : analyse lexicale et sémantique.
  • PCB (Printed Circuit Board) : circuit imprimé.
  • pin : broche. Entrée ou sortie.
  • polling : scrutation. Technique logicielle qui consiste à vérifier très souvent si un état a changé en vue d'une action sans utiliser des mécanismes asynchrones.
  • power : puissance.
  • power rail : bus d'alimentation.
  • power supply : alimentation.
  • PWM (Pulse Width Modulation) : modulation de largeur d'impulsion. Technique de modulation qui consiste à faire varier le rapport de cycle, pour une fréquence fixe donnée, entre un état haut et un état bas.

Q

R

  • resistor : résistance.
  • RTC (real time clock) : composant chargé de garder l'heure en mémoire grâce à sa propre pile électrique.

S

  • short circuit : court-circuit.
  • side effect : effet de bord.
  • sink current : courant de fuite.
  • SMD (Surface Mounted Device) : composant monté en surface (CMS en français).
  • spectrum analyzer : équipement de mesure indiquant l'intensité d'un signal dans le domaine des fréquences.
  • SPI (Serial Protocol Interface) : bus de données série synchrone utilisant quatre signaux pour communiquer avec des périphériques.
  • strap : câble court utilisé pour réaliser une connexion électrique entre deux broches ou deux composants, pour les circuits à montage en surface on utilise des résistances de 0 Ω.
  • sweep : balayage.

T

  • thermistor : thermistance.
  • TTL (Transistor-Transistor Logic) : circuits logiques à base de transistors bipolaires. Se dit aussi de la tension utilisée dans de tels circuits (5 volts, par exemple).

U

  • UJT (UniJonction Transistor) : transistor unijonction.
  • upload : action de télécharger un fichier en direction d'un serveur, on utilise aussi le mot téléverser. Utilisée dans le logiciel Arduino mais aussi dans les serveurs Web.
  • USB (Universal Serial Bus) : bus de donnée série très utilisé pour communiquer avec des périphériques informatiques. L'Arduino l'utilise pour se connecter à l'ordinateur afin d'être programmé. Voir ports COM.

V

  • valve : tube à vide.
  • Vcc : tension positive d'alimentation d'un circuit.
  • Vdd : autre dénomination pour Vcc.
  • Vee : tension négative d'alimentation (ou souvent le 0V) d'un circuit.
  • vertex (pluriel : vertices) : sommet.
  • voltage : tension.
  • voltage divisor : diviseur potentiométrique (ou aussi diviseur de tension).
  • Vss : autre dénomination pour Vee.

W

  • waveform : caractérise la nature d'un signal alternatif régulier ; trois grandes familles existent : carré, triangulaire et sinusoïdal.

X

Y

Z