Qu'est ce qu'Arduino?

Pour éviter les confusions, Arduino est une société italienne qui propose des
cartes électroniques et un logiciel de programmation/compilation/téléversement du code source.

vous avez d'un coté les cartes Arduino Uno, micro, nano, mega, duemilanive..... et de l'autre l'IDE qui
s'appelle aussi Arduino.

dans quel but?

On peut voir Arduino comme le petit-fils des automates programmables. Arduino n'a de sens que si il
agit avec le monde physique (capteurs, actionneurs) autres que l'imprimante ou la souris. On parle alors
de moteurs, de capteurs divers et variés, d'électrovannes...... qui vont être lus/pilotés via les entrées
sorties analogiques/numériques (on les verra plus loin).

je fais exprès de montrer 2 versions de la carte Arduino UNO. Elles sont techniquement identiques,
remplissent les mêmes fonctions. La seule différence est le format de la puce (à gauche, un modèle que
l'on peut enlever et placer sur un montage "maison", celle de droite et soudée et miniaturisée.
C'est comme le microprocesseur du PC, en beaucoup moins puissant, avec moins de fonctionnalités, on
l'appelle microcontrôleur.

Sur la carte, on peut voir en haut et en bas, 2 lignes noires. ce sont des connecteurs type DUPONT
femelle.

en bas de la carte:
sur la gauche, la partie "power" offre une alimentation 3.3v ainsi que 5v avec 2 masses.
en plus, vous pouvez alimenter la carte (entre 9 et 12v de mémoire) sur la pin "Vin" et une pin pour
déporter le bouton "reset" déjà présent sur la carte (poussoir rouge).

Sur la droite, plus intéressant, les "analog In" et sur la partie du haut les "digital".

pour faire simple, une valeur

analogique: est comprise entre 0 et 255, par exemple, ou entre 0 et 1024.
numérique: 0 ou 1.

ENTREES ANALOGIQUES (analog in)

pour comprendre les entrées analogiques, un bon exemple, la CTN 10Kohm (capteur de température
négative):

on a créé un pont diviseur de tension entre la résistance fixe à 10Kohm et la CTN.

Les spécifications de la CTN nous disent que la CTN vaut 10Kohm à 25°c.
Une partie des 5v sont déversés dans la masse(GND) et l'autre dans la pin A0 (ie Analog n°0).
Les specs de la carte Arduino disent que la résolution des entrées analogiques est de 10 bits.
on calcule 2^10 = 1024.
à 25°c, Rctn=10Kohm=Rfixe
donc, on doit lire la valeur 512 sur la pin A0

et la, le bout de code qui permet de lire et d'afficher la valeur du capteur

****************************************
void setup()
{
Serial.begin(9600); //on en parle un peu après
}

void loop()
{
int value=analogRead(A0);
Serial.print("on lit la valeur : ");
Serial.println(value);
}

*****************************************
et à l'exécution:
645
645
645
645
......
....

et oui, le code qui lit la pin A0 et affiche se trouve dans la fonction "loop()" qui comme son nom
l'indique est exécutée en boucle. (On verra le Serial et print plus loin)

Ici, on vient de lire une entrée analogique, on peut aussi écrire sur une sortie analogique (toutes les
cartes ne le font pas naturellement)

SORTIES ANALOGIQUES ( ~PWM)

La, il faut s'accrocher un peu....
on peut vouloir faire varier la vitesse d'un moteur (tout petit, pas gourmand), un cas classique:

on remplace notre CTN et Rfixe par un potentiomètre (ça ne change rien au fonctionnement, la valeur de
A0 changera avec le potentiomètre).
Et on a rajouté un petit moteur très peu gourmand qu'on branche entre la pin numérique 6 et la masse....
vous me direz que c'est une sortie numérique, qui vaut 0 ou 1, c'est vrai mais....
si on s'amuse à alterner très vite entre 0 et 5v, on crée un signal haché, et donc artificiellement une
tension comprise entre 0 et 5v selon le rapport de temps à 0 ou à 5v.

Comprenez que si vous envoyez 5v la moitié du temps (ie 1ms sur 2), vous émulez du 2.5v.
En tout cas, le moteur le comprend comme ça et tourne à mi régime (le voltmètre aussi :-).

Ce sont certaines des pins numériques qui, en plus, savent faire ça.
Elles sont notées PWM (Pulse Width Modulation - un type de signal numérique basé sur le même
principe l'alternance 0/5v..) et surmontées d'un '~'.
Si les entrées analogiques sont sur 10 bits, les sorties PWM sont quand à elles sur 8 bit.
On refait le calcul 2^8=256 valeurs possibles

https://www.arduino.cc/en/Main/ArduinoBoardUno
https://123d.circuits.io
http://www.pighixxx.com/test/pinoutspg/boards/

et le classique sur google "Arduino + votre capteur/actionneur"

le code sera le suivant:

void setup()
{
pinMode(6, OUTPUT);
//les pins numériques fonctionnent en entrée et en sortie, il faut spécifier
Serial.begin(9600);
}

void loop()
{
int value=analogRead(A0);
value=map(value,0,1023,0,255);
//map() fait le produit en croix de value sur 0-> 1023 pour avoir la valeur sur 0->255**
Serial.print(on lit la valeur :");
Serial.println(value);
analogWrite(6, value);
// ici, j'ai envoyé la valeur entre 0 et 1023 sur la pin 6
}

** 255 et non 256 car en informatique, on commence presque tout le temps par 0.
de 0 à 255, il y a 256 valeurs. Idem pour 1023

ATTENTION!!!!!! la carte Arduino est faite pour la partie COMMANDE du montage, JAMAIS pour la
partie puissance!!!!!
ici, on a utilisé un tout petit moteur, mais un appareil plus gourmand pourrait faire griller la carte.
ENTREES/SORTIES NUMERIQUES
Il nous reste les pin numériques ( sur la carte en haut de 0 à 13, incluant les ~PWM).
elle permettent d'envoyer/recevoir 0 ou 5v, pour commander un relais par exemple, ou de lire une valeur
0 ou 1, comme un interrupteur.

Exemple d'entrée/sortie. Un bouton contrôle un relais pour allumer/éteindre une ampoule 230v. (je viens
juste de lire votre email, vous avez toutes les pièces dans le kit).
ou dit différemment, une entrée numérique pour contrôler une autre sortie numérique.

(petite précision sur la commande du relais pour éviter de faire flamber la maison, choisir un système
dont les parties commandes et puissance sont isolées physiquement (par l'emploi d'un optocoupleur par
exemple).

BON SCHEMA

schéma du bouton poussoir:

Pourquoi a-t-on mis une résistance de 10kohm en plus sur le montage?

suivons les fils......

on part du file rouge qui alimente en 5V le bouton poussoir.
De l'autre coté du bouton poussoir, d'un coté le fil bleu qui relie la pin 2, de l'autre une résistance reliée à
la masse.
SANS APPUYER:
les 5v arrivent et s'arrêtent à l'entrée du bouton poussoir.
la pin 2 et reliée à la masse via la résistance qu'on appellera " résistance de rappel au moins" (pulldown).
la résistance vaut 10Kohm, donc assez grosse par rapport au 5v et au faible ampérage. Son rôle va être
de "plaquer" le signal à 0v en consommant l'électricité parasite que notre programme pourrait interpréter
aussi bien comme un état 0 qu'un état 1.

BBOUTON APPUYE:
A retenir: l'électricité est faignante et choisira TOUJOURS le chemin le plus court (le moins
consommateur).
L'électricité traverse l'interrupteur pour repartir via le fil bleu sur l'entrée numérique numéro 2. Elle ne
passe plus par la résistance qui devient "plus coûteuse" que le "shunt" sur la pin 2.

MAUVAIS MONTAGE

Quelques mots clés pour aller plus loin

#include <toto.h> --> permet d'inclure à notre programme les librairies correspondantes au module
branché sur la carte.
une librairie peut être vu comme une caisse à outils contenant les fonctions du module.

Exemple la librairie Servo.h contient les fonctions:

attach(pinnumber); -> pour spécifier sur quelle pin le fil de commande du servomoteur est branché.
detach(); pour libérer la pin, elle ne contrôle alors plus le servomoteur
write(angle); fait tourner le servomoteur jusqu'à l'angle désiré (généralement entre 0 et 180°)

le programme Arduino sera ainsi:

#include <Servo.h>

#define PINSERVO 2; //crée une variable fixe qui contient le numéro de pin ou est branché
//le fil de signal du servo

Servo monservo; //crée la variable servomoteur qui pourra utiliser les fonctions de la librairie Servo.h

void setup()
{
monservo.attach(PINSERVO); // le programme lira monservo.attach(2);
}
void loop()
{

for (int i=0;i<180;i++)

{
monservo.write(i); //on demande au servo de tourner jusqu'a l'angle i
//qui s'incrément à chaque tour dans la boucle for
delay(10); //on met le programme en pause le temps que le servo tourne physiquement.
}

for (int i=180;i>0;i--)

{
monservo.write(i); //on demande au servo de tourner jusqu'a l'angle i
//qui se décrémente à chaque tour dans la boucle for
delay(10); //on met le programme en pause le temps que le servo tourne physiquement.
}
}

c'est le programme qui reproduit le mouvement des essuie-glaces.

attachInterrupt
String, float int, boolean, unsigned long, byte
delay
delayMicroseconds