Ce programme est initialisé à la mise sous tension de la carte arduino ou lorsqu'on actionne le bouton poussoir "reset" sur la carte








télécharger 83.36 Kb.
titreCe programme est initialisé à la mise sous tension de la carte arduino ou lorsqu'on actionne le bouton poussoir "reset" sur la carte
date de publication30.03.2018
taille83.36 Kb.
typeProgramme
p.21-bal.com > comptabilité > Programme
La carte ARDUINO


  1. Qu'est-ce que la carte ARDUINO ?


C'est un circuit imprimé comportant tous les composants électroniques nécessaires pour faire fonctionner un microcontrôleur (Atmega 328) associé à une interface USB lui permettant de communiquer avec un ordinateur.


Un microcontrôleur est l'équivalent d'un petit ordinateur.

Il contient un microprocesseur (unité centrale) associé à

différentes mémoires et des interfaces lui permettant de

communiquer avec l'extérieur, et bien sûr une horloge

pour cadencer l'ensemble.
L'alimentation électrique peut être fournie par le port USB

ou une alimentation externe qui délivre 5V.
Attention! les tensions appliquées sur les entrées ne doivent

pas dépasser la tension d'alimentation sous peine de destruction du circuit.
Le microcontrôleur exécute en permanence un programme qui a été copié dans sa mémoire flash (EEPROM de 32 kO) depuis un ordinateur via le port USB (interface série).

Ce programme est initialisé à la mise sous tension de la carte ARDUINO ou lorsqu'on actionne le bouton poussoir "reset" sur la carte.
La carte "ARDUNO uno" que nous allons utiliser dispose de 14 broches ("pin" en anglais, numérotées de 0 à 13) qui peuvent être configurées en "entrées digitales" ou en "sorties digitales" susceptibles de délivrer une intensité maximale de 40mA sous une tension égale à 0V ou 5V.

Certaines de ces broches peuvent être configurées en "sorties PWM" (Pulse Width Modulation ou modulation de largeur d'impulsion).

Elle possède également 6 entrées analogiques (notées A0 à A5) permettant de mesurer des tensions comprises entre 0V et 5V grâce à un convertisseur A/N à 10 bits.
Les broches pin0 et pin1 ne sont pas disponibles pour l'utilisateur de la carte car elles sont utilisées pour communiquer avec l'ordinateur via le port USB, et sont notées RX (réception) et TX (transmission) sur la carte.
L
1
e port USB de la carte ARDUINO est géré par l'ordinateur comme un port série virtuel (COMx) et il est nécessaire d'installer les drivers correspondants avant d'établir la liaison ordinateur-Arduino.

  1. Installation de l'environnement de développement (IDE):




  • Télécharger le programme de l'environnement de développement correspondant au système d'exploitation utilisé sur le site du fabricant www.arduino.cc onglet "download".

Par exemple sous windows télécharger le fichier compressé "arduino-1.0.1-windows.zip" (ou une version plus récente).


  • Décompresser le fichier ZIP téléchargé, puis copier le répertoire obtenu "arduino-1.0.1" à l'emplacement de votre choix, par exemple dans C://Program Files.




  • Ouvrir le répertoire puis créer sur le bureau un raccourci pour ouvrir "arduino.exe".




  • Brancher la carte ARDUINO sur un port USB de l'ordinateur.


Si la fenêtre "Nouveau matériel détecté" s'ouvre, ne laissez pas Windows update s'en mêler et cochez la case "Non, pas pour cette fois", puis cliquez sur "Suivant".
Dans la fenêtre qui s'affiche, cochez la case "Installer à partir d'un emplacement spécifié", puis "Suivant".
Dans la nouvelle fenêtre, sélectionner "Parcourir" puis indiquer le chemin du sous-répertoire "drivers" dans le répertoire "arduino" créé précédemment.

Autoriser Windows à installer le pilote.
Après avoir terminé l'installation de l' USB Sérial Converter, une séquence de "nouveau matériel détecté" peut s'ouvrir à nouveau pour installer l' USB Sérial Port, et il faut refaire la même procédure mais en indiquant le chemin de FTDI USB Drivers.
Sinon, il faut aller dans le Panneau de configuration / Système / Gestionnaire de Périphériques / Autres Périphériques / Arduino Uno Général / Mettre à jour le pilote / Rechercher un pilote sur mon ordinateur / Parcourir

puis indiquer le chemin du sous-répertoire "drivers" dans le répertoire "Arduino" créé précédemment.
Autoriser Windows à installer le pilote.
Dans le Panneau de configuration / Système / Gestionnaire de Périphériques une nouvelle ligne apparait
correspondant à la création d'un convertisseur USB-Série.

noter le numéro affecté au port COM créé (ici le COM6).
A partir de maintenant, la carte ARDUINO sera reconnue comme n'importe quel périphérique USB dès sa connexion au PC.


  • Cliquer sur le raccourci "arduino.exe" créé précédemment pour lancer l'environnement de développement.


Dans le menu "Fichier" puis "Préférences", choisir la langue "français" si ce n'est déjà fait.
Puis dans "Outils" vérifier le type de carte utilisé (Arduino UNO) puis indiquer le numéro du port affecté par l'ordinateur (ici le COM6).
Remarque: On peut vérifier rapidement le numéro de port COM affecté par

l'ordinateur à l'Arduino en cliquant sur "Démarrer" puis "Périphériques et

Imprimantes".
Attention! si d'autres ports COM virtuels ont été créés précédemment sur le

PC, la carte Arduino ne pourra pas fonctionner sur un numéro de port partagé,

même si l'autre périphérique n'est pas branché.
On peut éventuellement modifier le numéro du port affecté à la carte Arduino

en allant dans Panneau de configuration / Système / Gestionnaire de Périph. /

Ports (COM et LPT)/ Communications Port/ Paramètres du port/ Avancé/

numéro de port.
Il faut également veiller à brancher la carte Arduino toujours sur le même

p
2
ort USB de l'ordinateur.

  1. Testons notre premier programme:


2.1. Le protocole de transfert:


  • Ouvrir l'environnement de développement (I.D.E.) en cliquant sur l'icône qui est sur le bureau.




  • Aller sur le site d'ISN (physiquepovo.com) en utilisant Mozilla Firefox et télécharger le fichier "Blink" qui se trouve page 12.

Ce programme a simplement comme objectif de faire clignoter une DEL déjà connectée entre la borne 5 de l'Arduino et la masse du montage (via une résistance de protection).


  • Copier le script du programme dans la fenêtre principale de l'I.D.E.




  • Cliquer sur l'icône "vérifier" de façon à déceler d'éventuels bugs dans la structure du programme (cela sera surtout nécessaire pour tester nos propres programmes).

La taille du programme apparait dans la fenêtre d'édition en bas.


  • Sélectionne dans "Outils" puis "Port Série" le n° du port série attribué à l'Arduino.




  • Cliquer sur l'icône "transférer (téléverser)" afin d'enregistrer ce programme dans la mémoire flash de l'Arduino qui va ensuite l'exécuter en boucle.


2.2. Structure d'un programme Arduino:
Le langage de programmation Arduino dérive du langage C++ et il en respecte les règles de syntaxe:

* Une ligne qui commence par "//" est considérée comme un commentaire

* Un paragraphe qui commence par "/*" et qui se termine par "*/" est considéré comme un commentaire

* Toute ligne d'instruction de code doit se terminer par un point virgule ";"

* Un bloc d'instructions (définition d'une fonction, boucle "while" ou "if"/"else"...) doit être délimité par

des accolades ouvrantes "{" puis fermantes "}".

* Toutes les variables doivent être déclarées, ainsi que leur type (int,float,...) avant d'être utilisées.
Un programme (ou "sketch") Arduino est constitué de 2 fonctions distinctes:
* La fonction de configuration "void setup" exécutée une seule fois au lancement du programme.
* La fonction "void loop" qui est ensuite exécutée indéfiniment en boucle.
Remarque: On peut relancer le programme en actionnant le bouton poussoir "reset" sur la carte.
2.3. Etude d'un exemple: le programme "Blink":
int DEL = 5; ou #define DEL 5;

On donne un nom à la broche 5 de façon à la repérer plus facilement dans le script: c'est celle qui est reliée à la DEL que l'on souhaite faire clignoter.

On crée ainsi une nouvelle variable nommée "DEL" de type "nombre entier (int)".
void setup()

{

pinMode(DEL, OUTPUT); On initialise la borne 5 de l'Arduino (nommée "DEL") comme une sortie.

}
void loop()

{

digitalWrite(DEL, HIGH); On met la borne 5 au niveau logique haut (+5V): la diode s'allume.

delay(1000); On attend un délai de 1000ms (soit 1s).

digitalWrite(DEL, LOW); On met la borne 5 au niveau logique bas (0V): la diode s'éteint.

delay(1000); On attend un délai de 1000ms (soit 1s).

}

Et ainsi de suite tant que le circuit est alimenté.
Modifier ce script de façon à ce que ce soit la DEL reliée à la sortie numérique 6 de l'Arduino qui clignote, en restant 1,5s éteinte et 0,5s allumée.
P
3
uis faire clignoter les deux DELs de façon à ce que lorsque l'une est allumée, l'autre soit éteinte.

  1. Améliorons notre premier programme:


3.1. Affichage d'un texte dans le moniteur série:(Blink1)
Pour afficher "la DEL clignote avec une période de 2s" dans le moniteur série que l'on peut ouvrir en cliquant sur l'icône située en haut à droite de l'environnement de développement, il faut:
* ouvrir la liaison série entre l'Arduino et l'ordinateur via le câble USB en intégrant le script Serial.begin(9600); dans la fonction "setup" (9600 définit en baud le nombre de bits échangés par seconde).
* introduire dans la fonction "loop" le script associé au texte à écrire à l'écran (en évitant les caractères accentués: é, è, ê, à, ...) suivi d'un saut à la ligne:

Serial.println("la DEL clignote avec une periode de 2s");


  • Teste ce nouveau programme et ouvre le moniteur série. Que constates-tu ?



  • Modifie le script de façon à éviter ces répétitions. Détaille ton algorithme.

3.2. Clignotement conditionnel:(Blink2)
On souhaite maintenant provoquer le clignotement ou l'allumage continu de la DEL selon que la borne 10 de la carte Arduino est portée au niveau logique haut (+5V) ou au niveau bas (0V).
Pour cela, on va utiliser le bouton poussoir situé en bas à gauche de la carte: lorsqu'il est enfoncé, la borne 10 est au niveau bas, sinon elle est au niveau haut.


  • La borne 10 de l'Arduino doit-elle être configurée en entrée ou en sortie ?


  • Ecris et teste le script correspondant, après avoir conçu l'algorithme adapté à ces consignes, sachant que:


* Le script pinMode(10, INPUT); initialise la borne 10 de l'Arduino comme une entrée numérique.
* Le script etat=digitalRead(10); permet de lire l'état "haut" ou "bas" de la borne 10 de l'Arduino et de le

mémoriser dans une variable nommée "etat" (qui doit être définie au préalable!).


  • Complète ce script de façon à afficher dans l'environnement de développement "la DEL est allumée" ou "la DEL clignote" une seule fois à chaque changement d'état.



3.3. Commande via le moniteur série:(Blink3)
Le moniteur série permet d'afficher des informations (textes, valeurs des variables,...) en provenance de l'Arduino, mais il permet aussi d'envoyer des informations tapées au clavier de l'ordinateur vers l'Arduino.
L'objectif à atteindre est de provoquer l'allumage de la DEL en envoyant le caractère "A", son extinction en

envoyant le caractère "E" et son clignotement en envoyant le caractère "C".


  • Ecris et teste le script correspondant, après avoir conçu l'algorithme adapté à ces consignes, sachant que:


if (Serial.available() > 0) // lit l'octet entrant s'il y a des données disponibles sur le port série

{

lettreLue = Serial.read(); // la lettre correspondant à l'octet reçu est mémorisée dans la variable "lettreLue"

if ((lettreLue = = 'A') || (lettreLue = = 'E') || (lettreLue = = 'C')) // le "ou" logique correspond à || (ALT GR + touche 6)

{

lettre = lettreLue; // la variable "lettre" ne peut contenir que les caractères "A","E" ou "C" en excluant

} tout autre caractère reçu.

}


4



  1. Le typage des variables:


En javascript, il suffisait de déclarer une variable « var bidule ; » avant de l’utiliser sans préciser son type qui peut être : nombre entier, nombre décimal, chaine de caractère,…

Cela peut paraître plus simple mais gaspille de l’espace mémoire (pour pouvoir caser n’importe quoi dans un tiroir il faut forcément prévoir au départ un grand tiroir !) et n’est pas sans poser de problème.

Par exemple : var bidule = 3 ; var machin = 5 ; Quel est le contenu de : var somme = bidule+machin ;
En langage Arduino, il faut indiquer le type de variable que l’on souhaite créer lorsqu’on la crée.
int variable1 est codée sur 16 bits et peut donc contenir un nombre entier compris entre 32768 et +32768.
float variable2 est codée sur 32 bits et peut contenir un nombre décimal (presque) quelconque.
boolean variable3 est une donnée logique qui ne peut prendre que 2 valeurs : « true » ou « false » ou encore « high » et « low » ou même 1 ou 0.

Codée sur seulement 8 bits, elle convient pour les entrées ou sorties numériques (ou digitales).
char variable4 = 'A' ; peut contenir n’importe quel caractère alphanumérique (lettre, chiffre)
les tableaux (array) peuvent contenir n’importe quel type de variable défini précédemment.

Le nom de la variable est terminé par des crochets[] mais le type « array » n’est pas indiqué… il est remplacé par le type de variable qu’il contient.
Exemples: int variable5[ ] = {2,0,1,3} ; ou char variable6[ ] = « bonjour » ;
On peut accéder à n’importe quel élément d’un tableau, sachant que les indices commencent par 0 à gauche.

Ainsi : variable5[2] = = 1 et variable6[3] = = 'j'
Les chaines de caractère (string) sont en fait considérées comme des tableaux contenant des caractères.
Les notations suivantes sont donc équivalentes :

char variable6[ ] = « bonjour » ; ou char variable6[ ] = { 'b' , 'o' , 'n' , 'j' , 'o' , 'u' , 'r' , '\0' } ;
Remarque: une chaine de caractère doit toujours être terminée par un caractère nul '\0' qui est pris en compte dans le calcul de la longueur de la chaine. Si on oublie de le mettre, il est rajouté automatiquement !
char* variable7[ ] = { « message1 », « message2 », « message3 »} ; définit un tableau de chaines.
On obtient ainsi par exemple : variable7[0] = =  message1


  1. Entrées analogiques et sorties PWM:


5.1. Les entrées analogiques:
La carte Arduino Uno dispose de 6 entrées analogiques notées A0, A1,…A5 mais d’un seul convertisseur analogique/numérique sur 10 bits. La durée d’une conversion est de l’ordre de 100µs.

La donnée numérique qu’il fournit après conversion est donc comprise entre 0 et …….
Il n’est pas nécessaire d’initialiser ces entrées analogiques qui n’ont que cette seule fonction.
int valeur4 = map(analogRead(4),0,1023,0,255) ; permet de lire la valeur numérique de la tension analogique présente sur l’entrée A4 et de la transformer en une valeur comprise entre 0 et 255.
5.2. Les sorties analogiques (ou plutôt PWM):
La carte Arduino Uno dispose de 6 sorties (3,5,6,9,10 et 11) qui peuvent être utilisées en mode PWM, c'est-à-dire en modulation de largeur d’impulsion.

Ce sont des signaux logiques binaires de fréquence constante (500Hz)

mais de rapport cyclique variable.
Lorsqu’un moteur ou une lampe est alimenté par ce type de tension,

tout se passe comme si il était alimenté par une tension continue

ajustable entre 0V (rapport cyclique= 0) et 5V (rapport cyclique=255).
Ces sorties doivent être initialisées comme des sorties digitales.
a
5
nalogWrite ( 5 , 200 ) ;
permet d’envoyer un rapport cyclique 200 sur la sortie digitale 5.

5.3. Commande d’une sortie PWM par un potentiomètre:
int Potar = 2; int Del = 5;
void setup()

{

pinMode(Del,OUTPUT);

}
void loop()

{

int tension = analogRead(Potar);

int luminosite = map(tension,0,1023,255,0);

analogWrite(Del,luminosite);

}


  • Tester puis modifier ce script de façon à ce que l’une des Dels voie sa luminosité augmenter tandis que la luminosité de l’autre Del diminue lorsqu’on modifie la position du curseur du potentiomètre.




  1. Un shield complet pour communiquer: "danger shield" de Sparkfun


Il existe sur le marché une multitude de cartes d'interfaces (appelées "shields") enfichables sur la carte Arduino, et qui permettent de relier des entrées ou sorties de l'Arduino à des composants divers: capteurs de température, de lumière, potentiomètres, relais, moteurs, GPS, port Ethernet, wifi, afficheurs, écran LCD...
La carte nommée "Danger shield" va nous permettre de nous familiariser avec un certain nombre d'entre-eux.
6.1. Le buzzer :
C’est un petit haut-parleur relié à la patte n°3 de l’arduino. Pour lui faire émettre un son, il faut générer sur cette sortie une tension rectangulaire à la fréquence du son que l’on souhaite émettre.


  • Analyser le script suivant et appeler le prof pour lui expliquer :


int Buzzer = 3 ;

int La=1136; int Si=1012; int Do=955; int Re=851; int Mi=757; int Fa=714; int Sol=637;

int musique[ ] = {Mi,Do,Re,Sol,Sol,Sol,Re,Mi,Do,Do}; //notes correspondant à une mélodie connue"

for (int n = 0; n < 10; n++)

{

for(int x = 0; x < 400; x++)

{

digitalWrite(Buzzer, HIGH); delayMicroseconds(musique[n]);

digitalWrite(Buzzer, LOW); delayMicroseconds(musique[n]);

}

}


  • Tester ce script après l’avoir complété, pour qu’il soit exécuté par la carte Arduino lorsqu’on appuie sur un bouton.




  • Modifier ce script de façon à ce que la mélodie soit jouée plus rapidement.




  • Modifier la mélodie de façon à jouer « au clair de la lune » : Do, Do, Do, Re, Mi, Re, Do, Mi, Re, Re, Do




  • Concevoir un programme de façon à ce que, en déplaçant le curseur d’un potentiomètre, on puisse jouer les 7 notes programmées ci-dessus.


Complément : La structure switch/case permet de comparer la valeur d’une variable avec plusieurs valeurs de référence possibles et de choisir en conséquence les instructions qui seront exécutées dans chaque cas.
switch (variable)

{

case valeur1 : instructions à exécuter ; break ;

case valeur2 : instructions à exécuter ; break ;

default : instructions à exécuter ;


6
}

6.2. Comment afficher la température du capteur ?
Le circuit intégré TMP36 est relié à la patte n°4 de l’Arduino.

Il est alimenté directement sous une tension Vs=5V délivrée par la carte Arduino

et délivre entre la masse (GND) et la sortie Vout une tension U (en mV) qui varie en

f
U = 500 + 10 x 

onction de la température (en °C):


  • Cette relation est-elle en accord avec les indications données par le data sheet ?


  • Quelles sont les valeurs maximales et minimales envisageables pour U ?



  • Les variations de U et de  sont-elles proportionnelles ?



  • Trace la courbe représentant les variations de U en fonction de la température .




  • Sachant que le convertisseur analogique/numérique de l'Arduino travaille sur 10 bits et que la tension maximale qu'il peut mesurer est de 5,0V , quel calcul faut-il effectuer à partir de l'information donnée par le script " valeur = analogRead(4); " pour afficher la température du capteur ?



  • Le script suivant est-il en accord avec tes calculs ?

Qu'affiche-t-il dans le moniteur série si la tension délivrée par le capteur de température est égale à 700mV ?

int Valeur = analogRead(4);

float Tension = map(tension,0,1023,0,5000);

float Temperature = (Tension-500)/10;
Serial.print ("valeur lue sur l'entree A4 de l'Arduino: ");

Serial.println (Valeur);
Serial.print ("tension mesuree sur l'entree A4 de l'Arduino: ");

Serial.print (Tension);

Serial.println("mV");
Serial.print("temperature: ");

Serial.print(Temperature);

Serial.println(" Celsius");
delay(5000);

Remarque:

La variable "Valeur" (qui correspond au résultat de la conversion A/D de la tension présente entre la masse et l'entrée analogique A4 de l'Arduino) ne peut prendre que des valeurs entières comprises entre 0 et 1023.

Elle doit donc être déclarée de type "int".
Les variables "Tension" et "Température" sont des nombres décimaux à déclarer comme "float".
Application :
Créer un programme qui simule le fonctionnement d’un réfrigérateur :

* un potentiomètre permet de choisir la température voulue à l’intérieur du réfrigérateur.

* lorsque la température du capteur est supérieure à la température choisie, le compresseur du circuit de refroidissement, modélisé sur notre maquette par une diode, se met en marche pendant 10s.

*
7
lorsqu’on appuie sur un bouton, le moniteur série affiche la température choisie et la température mesurée à l’intérieur du réfrigérateur.

6.3. Comment commander un afficheur 7 segments ?
Le circuit intégré 74HC595 est un registre à décalage (ou convertisseur

série  parallèle).

Il transforme les 8 données reçues les unes après les autres sur son

entrée série "DATA" en 8 tensions présentes simultanément sur les

sorties Q0 à Q7 qui peuvent alimenter les 8 DELs qui composent un

afficheur 7 segments.
Ainsi, pour afficher le chiffre 5, il faut alimenter les segments a,c,d,f,g

ce qui peut se représenter par l'octet suivant: 01101101 envoyé sur

l
1 0 1 1 0 1 1 0
'entrée DATA (données).


temps

L
DATA
'entrée CLOCK (horloge) reçoit une tension en créneaux de période

é
CLOCK

^

^

^

^

^

^

^

^
gale à la durée d'un bit envoyé sur l'entrée DATA.

A
LATCH

^
chaque front montant sur l'entrée CLOCK, la valeur du bit présent

sur l'entrée DATA est lue et mémorisée.




Remarque: cette liaison série est de type "synchrone" car elle nécessite une ligne d'horloge

pour synchroniser les données reçues. Elle n'est pas présente dans le cas d'un port USB.
Lorsque les 8 bits de l'octet ont été lus et mémorisés par le circuit intégré, un front montant

envoyé sur l'entrée LATCH (verrou) les transfère simultanément à l'afficheur 7 segments.
Le script suivant permet d'afficher successivement les 10 chiffres (de 0 à 9):
int DEL[10] = {B00111111, B00000110, B01011011, B01001111, B01100110, B01101101, B01111101, B00000111, B01111111, B01101111};

// ce tableau à 10 cases contient les 10 octets (en binaire) correspondant chacun à un chiffre à afficher, par exemple B01101101 pour le chiffre 5
int LATCH = 7 ; // affectation d'un nom à chaque sortie de l'Arduino utilisée

int CLOCK = 8; int DATA = 4;
for (i=0; i<10; i++)

{

digitalWrite(LATCH,LOW); // blocage des sorties du registre à décalage utilisé (74HC595) pendant la réception des nouvelles données

shiftOut(DATA,CLOCK,MSBFIRST,~(DEL[i]));

// shiftOut(sortie donnée, sortie horloge, ordre des bits, donnée)= sortie de type série synchrone qui génère les données et l'horloge

// Attention: ~ permet d'inverser les 0 et les 1 dans le contenu du tableau DEL car l'afficheur est à anode commune (allumé si 0)

digitalWrite(LATCH,HIGH); // transfert de l'octet reçu sur les sorties

delay(1000); // chaque chiffre reste affiché pendant 1000ms, soit 1s.

}


  • Construis un programme permettant de compter le nombre de fois où on appuie sur le bouton de droite, de décompter (compter à l'envers) le nombre de fois où on appuie sur le bouton de gauche, tandis que le bouton central permet de remettre le compteur à 0.




  • Transfère ton programme dans l'Arduino et teste-le... (compteurDecompteur0)




  • Construis un chronomètre comptant les secondes. Le bouton de gauche doit permettre de déclencher ou d'arrêter le comptage, tandis que le bouton central assure la remise à zéro. On utilisera les 2 DELs pour compter les dizaines et on fera sonner le buzzer lorsque la limite du comptage sera atteinte (30s).




  1. Une interface homme-machine (IHM) pour Arduino:


Voir le site du concepteur (Loïc Beaufils): http://www.pobot.org/Une-interface-IHM-pour-Arduino.html


  • Transférer le programme IHM.ino dans la

mémoire interne de l'Arduino


  • Exécuter le programme ArduinoIHM.exe




  • Sélectionner le port COM de l'arduino puis

cliquer sur "connectez-vous"


  • Cliquer sur "OFF5" pour commuter la sorties 5 de l'Arduino sur "ON" (la Del 5 correspondante s'allume).




  • Cliquer sur l'onglet "ANALOGIQUE" puis sur "ACQ A0" pour afficher la tension aux bornes du

potentiomètre situé à droite de la carte "Danger Shield".


  • Il est possible d’enregistrer une séquence de commandes en cliquant sur RECORD.



  • Cliquer sur l'onglet "DIGITAL" puis sur la sortie 5 "OUTPUT" pour


8

Le bouton "Sauver" permet d’enregistrer la séquence en fichier texte (.txt) et le bouton "Ouvrir" permet de la récupérer ensuite.

similaire:

Ce programme est initialisé à la mise sous tension de la carte arduino ou lorsqu\Conditions Générales de mise à disposition et d’utilisation de la...
«Accepteur(s)» désigne(nt) le(s) commerçant(s) du Centre commercial ainsi que le Centre commercial lui-même acceptant la Carte en...

Ce programme est initialisé à la mise sous tension de la carte arduino ou lorsqu\A carte: Sur votre carte, (à l'aide de votre manuel) situez

Ce programme est initialisé à la mise sous tension de la carte arduino ou lorsqu\1 Le système de paiement interbancaire off line est solide et sécurisé
«payer» un achat. Le seul contrôle est donc l’identification du compte carte sur lequel sera prélevé le paiement

Ce programme est initialisé à la mise sous tension de la carte arduino ou lorsqu\Introduction : voir ce n’est pas un reflexe
«go/no go» (si animal on appuie sur le bouton : si IL se trompe : distracteur : appuie sur le bouton alors qu’il n’y a pas d’animal...

Ce programme est initialisé à la mise sous tension de la carte arduino ou lorsqu\Cependant, comment fait-on pour obtenir une image nette avec un appareil...
...

Ce programme est initialisé à la mise sous tension de la carte arduino ou lorsqu\Carte des territoires présomptifs de l’embryon de xénope

Ce programme est initialisé à la mise sous tension de la carte arduino ou lorsqu\Exercice 1 : Le rôle du concentrateur et de la carte réseau
«décisions» prises par les différents matériels. IL est préférable d’utiliser ce mode dans un second temps et de montrer d’abord...

Ce programme est initialisé à la mise sous tension de la carte arduino ou lorsqu\De montrer ce que l’on sait (un mot de passe ou code). de montrer...

Ce programme est initialisé à la mise sous tension de la carte arduino ou lorsqu\But : utilisation du logiciel Synchronie et de la carte d’acquisition...
«haché» régulièrement dans le temps, l’intervalle de temps entre deux valeurs numérisées est la durée d’échantillonnage dt. On prélève...

Ce programme est initialisé à la mise sous tension de la carte arduino ou lorsqu\Rapport sur la mise en œuvre du programme sur








Tous droits réservés. Copyright © 2016
contacts
p.21-bal.com