Arduino
Grâce à son expérience utilisateur simple et accessible, Arduino a été utilisé dans des milliers de projets et d'applications différents. Le logiciel Arduino est facile à utiliser pour les débutants, mais suffisamment flexible pour les utilisateurs avancés. Il fonctionne sur Mac, Windows et Linux. Les enseignants et les étudiants l'utilisent pour construire des instruments scientifiques à faible coût, pour prouver les principes de chimie et de physique, ou pour se lancer dans la programmation et la robotique. Les designers et architectes construisent des prototypes interactifs, les musiciens et les artistes l'utilisent pour des installations et pour expérimenter de nouveaux instruments de musique. Les décideurs, bien sûr, l'utilisent pour construire de nombreux projets exposés à la Maker Faire, par exemple. Arduino est un outil clé pour apprendre de nouvelles choses.
Arduino simplifie également le processus de travail avec des microcontrôleurs, mais il offre un certain avantage aux enseignants, aux étudiants et aux amateurs intéressés par rapport aux autres systèmes:
Bon marché - Les cartes Arduino sont relativement peu coûteuses par rapport aux autres plates-formes de microcontrôleurs. La version la moins chère du module Arduino peut être assemblée à la main, et même les modules Arduino pré-assemblés coûtent moins de 50 $
Multiplateforme - Le logiciel Arduino (IDE) fonctionne sur les systèmes d'exploitation Windows, Macintosh OSX et Linux. La plupart des systèmes de microcontrôleur sont limités à Windows.
Environnement de programmation simple et clair - Le logiciel Arduino (IDE) est facile à utiliser pour les débutants, mais suffisamment flexible pour que les utilisateurs avancés puissent également en profiter. Pour les enseignants, il est idéalement basé sur l'environnement de programmation de traitement, de sorte que les étudiants qui apprennent à programmer dans cet environnement seront familiarisés avec le fonctionnement de l'IDE Arduino.
Logiciel open source et extensible - Le logiciel Arduino est publié sous forme d'outils open source, disponibles pour extension par des programmeurs expérimentés. Le langage peut être étendu via des bibliothèques C ++, et les personnes souhaitant comprendre les détails techniques peuvent passer d'Arduino au langage de programmation AVR C sur lequel il est basé. De même, vous pouvez ajouter du code AVR-C directement dans vos programmes Arduino si vous le souhaitez.
Open source et matériel extensible sont.
2. Microcontrôleur
Le microcontrôleur peut être décrit comme un ordinateur embarqué sur une carte de circuit imprimé plutôt petite . Pour décrire plusprécisément la fonction d'un
microcontrôleur , il s'agit d'une seule puce qui peut effectuer divers calculs et tâches, et envoyer / recevoir des signaux d'autres appareils via les broches disponibles. Ce sont précisément les tâches et la communication avec le monde qu'il effectue, qui sont régies par les instructions que nous donnons au microcontrôleur. C'est ce travail de dire à la puce quoi faire , c'est ce que nous appelons la programmation dessus. H outefois , le uC par lui - même, ne peut pas accomplir beaucoup; il a besoin de plusieurs entrées externes: alimentation, pour une; un signal d'horloge fixe, pour un autre. En outre, le travail de programmation doit être accompli par un circuit externe. Donc typiquement, un uC est utilisé avec un circuit qui lui fournit ces choses; cette combinaison est appelée une carte microcontrôleur. L'Arduino Uno que vous avez reçu est l'une de ces cartes microcontrôleurs. Le microcontrôleur réel en son cœur est la puce appelée Atmega328 . Les avantages qu'offre Arduino par rapport aux autres cartes microcontrôleurs sont en grande partie en termes de fiabilité du matériel du circuit ainsi que de facilité de programmation et d'utilisation.
3.
Matériel
3.1 ) Disposition de la carte Arduino
3.2 ) Schéma des broches Arduino
Flash RAM (1K pris par le chargeur de démarrage)
1 Ko de RAM (par exemple pour les variables auto / locales et la pile)
14 d igital entrée / sortie Ports
3.3 ) FTDI
USB à puce unique vers asynchrone . Interface de transfert de données série
Future Technology Devices International , communément connu sous son abréviation FTDI , est une société privée écossaise de dispositifs à semi-conducteurs , spécialisée dans latechnologie Universal Serial Bus (USB).
Il développe, fabrique et prend en charge des périphériques et leurs pilotes logiciels associés pour convertir les transmissions série RS-232 ou TTL en signaux USB, afin de permettre la prise en charge des périphériques hérités avec les ordinateurs modernes.
FTDI fournit des services de conception de circuits intégrés
spécifiques aux applications (ASIC). Ils fournissent également des services de conseil pour la conception de produits, en particulier dans le domaine des appareils électroniques.
Compatible USB 2.0
Transmettre et recevoir des signaux LED frive
256 octets de réception, 128 octets de mémoire tampon de transmission
Taux de transfert de données de 300bits / sec à 2 Mb / sec
3.4 ) externe puissance
L'alimentation externe peut être fournie soit par l'adaptateur CA / CC, soit par le câble série / connecteur USB comme indiqué ci-dessous.
Remarque : pour les applications à courant plus élevé (> 30 mA), n'utilisez jamais le port com !!
La puissance requise pour ARDUINO est de 9 à 12 V CC, 250 mA ou plus, prise de 2,1 mm, broche centrale positive.
L'adaptateur sur étagère
devrait être entre 9V et 12V DC
doit être évalué pour un minimum de sortie de courant de 250 mA, bien que vous souhaitiez probablement quelque chose de plus comme une sortie de 500 mA ou 1 A, car cela vous donne le courant nécessaire pour alimenter un servo ou vingt LED si vous le souhaitez.
doit avoir une prise d'alimentation de 2,1 mm à l'extrémité Arduino, et
la fiche doit être "centre positif", c'est-à-dire que la broche centrale de la fiche doit être la connexion +.
Note actuelle: Puisque vous allez probablement connecter d'autres choses à l'Arduino ( LED , LCD , servos), vous devriez obtenir un adaptateur qui peut fournir au moins 500 mA, voire 1000 mA (1 ampère). De cette façon, vous pouvez être sûr d'avoir suffisamment de jus pour que chaque composant du circuit fonctionne de manière fiable.
Le régulateur embarqué de l'Arduino peut en fait gérer jusqu'à 20 V ou plus, vous pouvez donc utiliser un adaptateur qui émet 20 V CC. Les raisons pour lesquelles vous ne voulez pas faire cela sont doubles: vous perdrez la majeure partie de cette tension en chaleur, ce qui est terriblement inefficace. Deuxièmement,
la belle broche 9V sur la carte Arduino émettra en fait environ 20V, ce qui pourrait entraîner un désastre potentiel lorsque vous connectez quelque chose de cher à ce que vous pensiez être la broche 9V. Notre conseil est de s'en tenir à l'adaptateur 9V ou 12V DC.
Exemple : Arduino Uno alimenté par une batterie 9V
4.
Saveurs d' Arduino
Il y a eu de nombreuses révisions de l'USB Arduino. Certains d'entre eux sont
4.1 ) Arduino UNO:
Il s'agit de la dernière révision de la carte USB Arduino de base. Il se connecte à l'ordinateur avec un câble USB standard et contient tout ce dont vous avez besoin pour programmer et utiliser la carte. Il peut être étendu avec une variété de boucliers: des cartes filles personnalisées avec des caractéristiques spécifiques. Il est similaire au Duemilanove , mais
possède une puce
USB-série différente , l' ATMega8U2 , et un étiquetage nouvellement conçu pour faciliter l'identification des entrées et des sorties.
4.2 ) Arduino Mega 2560:
Une carte Arduino plus grande et plus puissante. Formé supplémentaires sur les repères numériques, les repères de PWM, entrées analogiques, ports série, etc . La version du Mega sorti avec Uno, cette version dispose de la ATmega2560, qui a deux fois la mémoire, et
utilise leATMega 8U2 pour la communication USB-série.
Le Duemilanove sélectionne automatiquement l'alimentation appropriée (USB ou alimentation externe), éliminant ainsi le besoin du cavalier de sélection d'alimentation trouvé sur les cartes précédentes. Il ajoute également une trace la plus facile à couper pour désactiver la réinitialisation automatique, ainsi qu'un cavalier à souder pour la réactiver.
4.4 ) Arduino Fio :
Un Arduino destiné à être utilisé comme nœud sans fil. Dispose d'un en-tête pour une radio XBee , d'un connecteur pour une batterie LiPo et d'un circuit de charge de batterie .
4.5 ) LilyPad Arduino:
Une carte Arduino circulaire épurée conçue pour la couture dans des vêtements et d'autres applications de tissu / flexibles. Nécessite un adaptateur supplémentaire pour communiquer avec un ordinateur .
4.6) Arduino Diecimila
:
Le principal changement dans l' Arduino Diecimila est qu'il peut être réinitialisé à partir de l'ordinateur, sans qu'il soit nécessaire d'appuyer physiquement sur le bouton de réinitialisation de la carte. Le Diecimila utilise un régulateur de tension à faible chute qui réduit la consommation d'énergie de la carte lorsqu'il est alimenté par une alimentation externe (adaptateur AC / DC ou batterie). Un réinitialisable polyfuse protège les ports USB de votre ordinateur de courts métrages et les surtensions. Il fournit également des en-têtes de broches pour la ligne de réinitialisation et pour 3,3 V. Il y a une LED intégrée sur la broche 13. Certaines cartes Diecimila bleues disent "Prototype - Limited Edition" mais sont en fait des cartes de production entièrement testées (les prototypes réels sont rouges).
4.7 ) Lilypad Arduino 03
Cette révision a un en-tête de programmation à 6 broches compatible avec les câbles USB FTDI et le Sparkfun FTDI Basic Breakout. Il ajoute la prise en charge de la réinitialisation automatique, permettant de télécharger des croquis sans appuyer sur le bouton de
réinitialisation du tableau. L'en-tête est monté en surface, ce qui signifie que la carte n'a pas de pokey bits qui sortent à l'arrière.
4.8 ) Arduino Nano
Arduino Nano est une petite carte à puce complète basée sur ATmega 328 (v3.0) ou Atmega 168 (v2.0). Chaque Arduino a la même fonctionnalité et les mêmes caractéristiques à l'exception du nombre de broches et de la taille. L'un des principaux défauts de cette carte est qu'elle n'a pas de prise d'alimentation. Ainsi, vous ne pouvez pas fournir d'alimentation à partir d'une source d'alimentation externe telle que la batterie. En dehors de cela, cette carte est plus ou moins similaire à n'importe quelle carte Arduino.
Les avantages de cette carte sont : La taille minuscule (ou, compacte) est l'un des principaux avantages de cette carte de lecture bo ard et b .
Mais les inconvénients sont les suivants: il n'y a pas de prise d'alimentation directe. Donc, vous utilisez n'importe quelle source d'alimentation, mais la déclaration précédente n'est pas tout à fait vraie. Depuis, il s'agit d'une carte basse tension, vous pouvez utiliser une source d'alimentation utilisant le Pin Vin, mais vous devez prendre quelques précautions. Sinon, il brûlera la carte, plus ou moins équivalent à un Arduino UNO.
4.9) Arduino Pro mini
Plus petit membre de la famille Arduino. Cette carte est disponible en deux variantes 3.3v / 8MHz et 5v / 16MHz , fonctionnant sur ATmega 328 .
La seule différence entre pro mini et Nano est qu'il ne dispose pas d'une interface USB vers série et d'un régulateur de tension ( 3.3v en version 5v).
Il est essentiellement conçu pour être utilisé dans les endroits où la taille est la priorité absolue et une installation permanente.
Dimensions: 0,7 x 1,3 "(18 x 33 mm) Fonctionnalités:
PCB mince de 0,8 mm
Connexion USB hors carte
Pèse moins de 2 grammes!
Prend en charge la réinitialisation automatique
Régulateur 3.3V
Sortie max 150mA
Plus de courant protégé
Entrée CC 3,3 V jusqu'à 12 V
LED d'alimentation et d'état intégrées
Broches analogiques: 8
E / S numériques: 14
5.
Terminologies de base
5.1 ) Analogique à numérique ( ADC)
Le processus de conversion analogique-numérique est illustré dans la figure. L'Arduino a 10 bits de résolution lors de la lecture de signaux analogiques. 2 10 = 1024 incréments .Influencez également la vitesse à laquelle vous échantillonnez .Ici ,
F ig.1 montre un graphique analogique, qui peut être des lectures de n'importe quel capteur, par exemple: LDR, POT, capteur à ultrasons.
Ces lectures sont alimentées dans les broches ADC de la carte Arduino, nommée Axe, où x est un nombre, par exemple: A0, A1, A2, etc.
Sur la figure 2, les valeurs analogiques changent en résolution de 2 10 sous forme numérique.
Maintenant, ces valeurs peuvent être utilisées pour contrôler n'importe quel module numérique, par exemple: servo à l'aide d'un potentiomètre à l'aide de PWM (expliqué ci-dessous).
ADC est la couleur la plus utilisée d' Arduino .
5.2 ) Modulation de largeur d'impulsion (PWM)
L' Arduino a une résolution de 8 bits, lors de la sortie d'un signal en utilisant PWM. La plage de tension de sortie va de 0 à 5 volts par incréments de 2 8 = 255 i . Moyenne de marche / arrêt (signaux numériques pour faire une tension moyenne), Cycle de service à 100% de 5Volts.
REMARQUE: les broches PWM sont des broches de sortie.
6 broches PWM dans un Arduino UNO sont situées comme
Les signaux PWM peuvent être utilisés pour contrôler les moteurs à courant continu, les servos, les moteurs pas à pas, la luminosité de toute LED, etc.
5.3 ) Croquis
C'est le terme utilisé pour un programme.
5.4 ) Bouclier
Il s'agit d'un circuit imprimé qui peut être branché sur un Arduino. Les boucliers ont une variété d' applications. Par exemple, les écrans de commande de moteur, les écrans LCD, etc.
C'est l'environnement de programmation le plus souvent utilisé avec Arduino. Il peut être téléchargé (gratuitement) sur arduino.cc . C'est une version quelque peu simplifiée du langage de programmation C.
5.6 ) IDE (environnement de développement intégré)
Il s'agit de l'application logicielle exécutéepour fournir les outils vous permettant de développer des logiciels pour l'Arduino. Il comprend l'éditeur de code source, l'automatisation de la construction et le débogueur .
Ceci est la capture d'écran de la dernière version 1.8.0 de l'ide Arduino.
La création d'une nouvelle esquisse la renomme automatiquement à la date du jour en cours. Dans cette figure, la date est le 27 février.
Les parties fondamentales d'une esquisse sont
void setup () - une fonction exécutée une fois au début d'un programme qui peut initialiser les paramètres. Toutes les broches numériques à utiliser dans l'esquisse sont d'abord définies dans cette fonction.
void loop () - une fonction appelée à plusieurs reprises jusqu'à ce que la carte s'éteigne. C'est sous une boucle infinie continue.
L'écran noir sous l'esquisse est le compilateur, qui prend vie une fois que le programme est exécuté en appuyant sur le bouton à cocher dans le côté gauche.
Le bouton à côté du bouton de compilation est le bouton de téléchargement qui est une flèche dirigée vers la droite. Cela brûle le programme sur la carte connectée au port USB. La carte connectée peut être changée en allant dans l'option 'Outils' de la barre de menu.
5 Concepts de base de la programmation
L'Arduino fonctionne sur l'environnement C de base. Mais les fichiers d'en-tête sont pré-inclus dans l'écriture d'un programme. L'esquisse ne contient que la partie la plus pertinente du programme / code.6.1 ) Fonctions
Une fonction est un bloc de code qui a un nom et un bloc d'instructions qui sont exécutées lorsque la fonction est appelée. Les fonctions void setup () et void loop () ont déjà été discutées et d'autres fonctions intégrées le seront plus tard. Des fonctions personnalisées peuvent être écrites pour effectuer des tâches répétitives et réduire l'encombrement d'un programme. Les fonctions sont déclarées en déclarant d'abord le type de fonction. Il s'agit du type de valeur à renvoyer par la fonction, comme « int » pour une fonction de type entier. Si aucune valeur ne doit être renvoyée, le type de fonction sera considéré comme nul.
t ype functionName (paramètres)
{déclarations; }
6.2 ) {} accolades
Les accolades définissent le début et la fin du bloc fonctionnel et des blocs d'instructions tels que la fonction void loop () et les instructions for et if.
fonction de type ()
{déclarations; }
Un point-virgule doit être utilisé pour terminer une instruction et séparer les éléments du programme. Un point-virgule est également utilisé pour séparer les éléments dans une boucle for.
int x = 13; // déclare la variable 'x' comme entier 13
Oublier ce point-virgule entraînera une erreur de compilation.
6.4 ) Variables
Une variable est un moyen de nommer et de stocker une valeur numérique pour une utilisation ultérieure par le programme. Comme leur homonyme le suggère, les variables sont des nombres qui peuvent être continuellement modifiés par opposition aux constantes dont la valeur ne change jamais. Une variable doit être déclarée et éventuellement affectée à la valeur à stocker. Le code suivant déclare une variable appeléeinputVariable , puis lui attribue la valeur obtenue sur la broche d'entrée analogique 2:
i ntinputVariable = 0; // déclare une variable et lui affecte une valeur 0
inputVariable = analogRead (2); // définit la variable sur la valeur de la broche analogique 2
6.5 ) octet
Byte stocke une valeur numérique de 8 bits sans points décimaux. Ils ont une plage de 0 à 255.
byte someVariable = 180;
Les entiers sont le type de données principal pour le stockage des nombres sans points décimaux et stockent une valeur 16 bits avec une plage de 32 767 à -32 768.
intsomeVariable = 1500;
6.7 ) longue
Type de données de taille étendue pour les entiers longs, sans virgule décimale, stockés dans une valeur 32 bits avec une plage de 2 147 483 647 à -2 147 483 648.
long someVariable = 90000;
6.8 ) flotter
Un type de données pour les nombres à virgule flottante ou les nombres qui ont une virgule décimale . Les nombres à virgule flottante ont une résolution plus élevée que les entiers et sont stockés sous la forme d'une valeur 32 bits avec une plage de 3,4028235E + 38 à -3,4028235E + 38.
float someVariable = 3,14;
6.9 ) tableaux
Un tableau est une collection de valeurs auxquelles on accède avec un numéro d'index. Toute valeur du tableau peut être appelée en appelant le nom du tableau et le numéro d'index de la valeur. Les tableaux sont indexés à zéro, la première valeur du tableau commençant au numéro d'index 0. Un tableau doit être déclaré et éventuellement assigné des valeurs avant de pouvoir être utilisé.
De même, il est possible de déclarer un tableau en déclarant le type et la taille du tableau et en attribuant ultérieurement des valeurs à une position d'index.
intmyArray [5];
myArray [3] = 10;
Pour récupérer une valeur d'un tableau, affectez une variable au tableau et la position d'index:
x = myArray [3];
Les tableaux sont souvent utilisés dans les boucles for, où le compteur d'incrémentation est également utilisé comme position d'index pour chaque valeur de tableau. L'exemple suivant utilise un tableau pour faire clignoter une LED. En utilisant une boucle for, le compteur commence à 0, écrit la valeur contenue à la position d'index 0 dans le scintillement du tableau [], dans ce cas 180, sur la broche PWM 10, fait une pause de 200 ms, puis passe à la position d'index suivante:
intledPin = 10; // led sur la broche 10
scintillement d'octet [] = {180,30,255,200,10,90,150,60}; // tableau de 8 valeurs différentes
void setup()
{
pinMode ( ledPin , OUTPUT); // définition de la broche de sortie
}
boucle vide ()
{
pour ( inti = 0; i <7; i ++)
{
analogWrite ( ledPin , scintillement [ i ]); // écrire la valeur d'index
retard (200); // pause pendant 200 millisecondes
}
6.10 ) arithmétique
Les opérateurs arithmétiques incluent l'addition, la soustraction, la multiplication et la division. Ils renvoient la somme, la différence, le produit ou le quotient (respectivement) de deux opérandes.
y = y + 3; // une addition
x = x - 7; // soustraction
i = j * 6; // multiplication
r = r / 5; // division
L'opération est effectuée en utilisant le type de données des opérandes, ainsi, par exemple, 9/4 donne 2 au lieu de 2,25 puisque 9 et 4 sont des entiers et sont incapables d'utiliser des points décimaux. Cela signifie également que l'opération peut déborder si le résultat est plus grand que ce qui peut être stocké dans le type de données.
Si les opérandes sont de type de données différent, le type le plus grand est utilisé pour le calcul. Par exemple, si l'un des nombres (opérandes) est de type float et l'autre de type integer, des calculs en virgule flottante seront utilisés pour le calcul.
Choisissez des tailles de variables suffisamment grandes pour contenir les plus gros résultats de vos calculs. Sachez à quel point votre variable va basculer et aussi ce qui se passe dans l'autre sens par exemple (0 - 1) OU (0 - - 32768). Pour les mathématiques qui nécessitent des fractions, utilisez des variables flottantes, mais soyez conscient de leurs inconvénients: grande taille et vitesses de calcul lentes.
Remarque: utilisez l'opérateur de conversion, par exemple ( int ) myFloat, pour convertir un type de variable en un autre à la volée. Par exemple, i = ( int ) 3.6 mettra i égal à 3.
Les affectations composées combinent une opération arithmétique avec une affectation de variable. Ceux-ci se trouvent généralement dans les boucles for, comme décrit plus loin. Les affectations composées les plus courantes comprennent:
x ++ // identique à x = x + 1, ou incrémente x de 1
x-- // identique à x = x-1, ou décrémente x de 1
x + = y // identique à x = x + y, ou incrémente x de + y
x - = y // identique à x = xy, ou décrémente x par -y
x * = y // identique à x = x * y, ou multiplie x par y
x / = y // identique à x = x / y, ou divise x par y
Remarque: Par exemple, x * = 3 triplerait l'ancienne valeur de x et réaffecterait la valeur résultante à x.
6.12) Opérateurs de comparaison
Les comparaisons d'une variable ou constante par rapport à une autre sont souvent utilisées dans les instructions if pour tester si une condition spécifiée est vraie. Dans les exemples des pages suivantes, ?? est utilisé pour indiquer l'une des conditions suivantes:
x == y // x est égal à y
x! = y // x n'est pas égal à y
x <y // x est inférieur à y
x> y // x est supérieur à y
x <= y // x est inférieur ou égal à y
x> = y // x est supérieur ou égal à y
6.13 ) Opérateurs logiques
Les opérateurs logiques sont généralement un moyen de comparer deux expressions et de renvoyer un VRAI ou FAUX selon l'opérateur. Il existe trois opérateurs logiques, AND, OR et NOT, qui sont souvent utilisés dans les instructions if:
ET logique:
if (x> 0 && x <5) // vrai seulement si les deux expressions sont vraies
OU logique:
if (x> 0 || x <5) // vrai seulement si l'une ou l'autre des expressions est vraie
NON logique:
if (! x> 0) // vrai seulement si l'expression est fausse
6.14 ) Constantes
Le langage Arduino a quelques valeurs prédéfinies, appelées constantes. Ils sont utilisés pour faciliter la lecture des programmes. Les constantes sont classées en groupes.
6.15 ) vrai / faux
Ce sont des constantes booléennes qui définissent les niveaux logiques. FALSE est facilement défini comme 0 (zéro) tandis que TRUE est souvent défini comme 1, mais peut également être n'importe quoi d'autre sauf zéro.Donc, dans un sens booléen, -1,2 et -200 sont tous également définis comme TRUE.
6.16 ) HAUT / BAS
Ces constantes définissent les niveaux de broches comme HAUT ou BAS et sont utilisées lors de la lecture ou de l'écriture sur des broches numériques. HIGH est défini comme le niveau logique 1, ON ou 5 volts tandis que LOW est le niveau logique 0, OFF ou 0 volt.
digitalWrite (13, HAUT); // la broche 13 est donnée comme 5 volts
6.17 ) ENTRÉE / SORTIE
Constantes utilisées avec la fonction pinMode () pour définir le mode d'une broche numérique comme INPUT ou OUTPUT .
pinMode (13, SORTIE); // broche affectée pour la sortie
6.18 ) si…. autre
si… autrement permet de prendre des décisions «soit - soit». Par exemple, si vous vouliez tester une entrée numérique et faire une chose si l'entrée est passée à HIGH ou à la place faire une autre chose si l'entrée était LOW, vous écririez cela de cette façon:
if ( inputPin == HIGH)
{ doThingA ; }
autre
{ doThingB ; }
else peut également précéder un autre test if, de sorte que plusieurs tests mutuellement exclusifs puissent être exécutés en même temps. Il est même possible d'avoir un nombre illimité de ces autres branches. Rappelez-vous cependant qu'un seul ensemble d'instructions sera exécuté en fonction des tests de condition:
{ doThingA ; }
sinon si ( inputPin > = 1000)
{ doThingB ; }
autre
{ doThingC ; }
Remarque: Une instruction if teste simplement si la condition entre parenthèses est vraie ou fausse. Cette instruction peut être n'importe quelle instruction C valide comme dans le premier exemple, if ( inputPin == HIGH) .Dans cet exemple, l'instruction if vérifie uniquement si l'entrée spécifiée est au niveau logique haut, ou + 5v.
6.19 ) pour la boucle
L'instruction for est utilisée pour répéter un bloc d'instructions entre accolades un nombre spécifié de fois. Un compteur d'incrémentation est souvent utilisé pour incrémenter et terminer la boucle. Ce sont trois parties, séparées par un point-virgule (;) de l'en-tête de la boucle for:
for (initialisation; condition; expression)
{faire quelque chose ; }
L'initialisation d'une variable locale, ou compteur d'incrément, se produit en premier et une seule fois. À chaque fois dans la boucle, la condition suivante est testée. Si la condition reste vraie, les instructions et l'expression suivantes sont exécutées et la condition est à nouveau testée. Lorsque la condition devient fausse, la boucle se termine.
L'exemple suivant démarre l'entier i à 0, teste pour voir si i est toujours inférieur à 20 et s'il est vrai, incrémente i de 1 et exécute les instructions incluses:
for ( inti = 0; i <20; i ++) // déclare i , teste s'il est inférieur à 20, incrémente i de 1
digitalWrite (13, HAUT); // active la broche 13
retard (250); // fait une pause pendant ¼ de seconde
digitalWrite (13, FAIBLE); // désactive la broche 13
retard (250); // fait une pause pendant ¼ de seconde
}
6.20 ) pinMode (broche, mode)
Utilisé dans void setup () pour configurer une broche spécifiée pour qu'elle se comporte comme une entrée ou une sortie.
pinMode (broche, SORTIE); // définit 'pin' en sortie
Les broches numériques Arduino sont par défaut les entrées, elles n'ont donc pas besoin d'être explicitement déclarées comme entrées avec pinMode (). On dit que les broches configurées comme INPUT sont dans un état d'impédance élevée.
Il existe également des résistances pull-up pratiques de 20Kohm intégrées à la puce atmega, accessibles à partir du logiciel. Ces résistances de tirage intégrées sont accessibles de la manière suivante:
pinMode (broche, INPUT); // définit 'pin' comme entrée
digitalWrite (broche, HIGH) ; // active les résistances pullup
Les résistances Pullup seraient normalement utilisées pour connecter des entrées telles que des interrupteurs. Notez dans l'exemple ci-dessus qu'il ne convertit pas la broche en sortie, c'est simplement une méthode pour activer les pull-ups internes.
On dit que les broches configurées comme SORTIE sont dans un état de faible impédance et peuvent fournir 40 mA (milliampères) de courant à d'autres appareils / circuits. C'est assez de courant pour allumer une LED (n'oubliez pas la résistance série), mais pas assez de courant pour faire fonctionner la plupart des relais, solénoïdes ou moteurs.
Les courts-circuits sur les broches A rduino et un courant excessif peuvent endommager ou détruire la broche de sortie, ou endommager l'ensemble de la puce Atmega . Il est souvent judicieux de connecter une broche OUTPUT à un appareil externe en série avec une résistance de 470ohm ou 1kohm.
6.21 ) digitalRead (broche)
Lit la valeur à partir d'une broche numérique spécifiée avec le résultat HIGH ou LOW. La broche peut être spécifiée comme une variable ou une constante (0-13).
valeur = digitalRead (broche); // définit la 'valeur' égale à la broche d'entrée
6.22 ) digitalWrite (broche, valeur)
Sort le niveau logique HIGH ou LOW à (allume ou éteint) une broche numérique spécifiée. La broche peut être spécifiée comme une variable ou une constante (0 - 13).
digitalWrite (broche, HIGH);
6.23 ) lecture analogique (broche)
Lit la valeur d'une broche analogique spécifiée avec une résolution de 10 bits. Cette fonction ne fonctionne que sur l'analogique dans les broches (0-5). Les valeurs entières résultantes vont de 0 à 1023.
Remarque: les broches analogiques comme les broches numériques, n'ont pas besoin d'être d'abord déclarées comme INPUT ou OUTPUT.
6.24 ) analogWrite (broche, valeur)
Écrit une valeur pseudo- analogique à l'aide de la modulation de largeur d'impulsion (PWM) activée par le matériel sur une broche de sortie marquée PWM. Sur les Arduinos plus récents avec la puce ATmega168, cette fonction fonctionne sur les broches 3, 5, 6, 9 , 10 et 11. Les Arduinos plus anciens avec un ATmega8 ne prennent en charge que les broches 9, 10 et 11. Les valeurs peuvent être spécifiées comme une variable ou constante avec une valeur de 0 à 225.
analogWrite (broche, valeur);
Une valeur de 0 génère une sortie stable de 0 volts à la broche spécifiée; une valeur de 255 génère une sortie constante de 5 volts à la broche spécifiée. Pour des valeurs comprises entre 0 et 255, la broche alterne rapidement entre 0 et 5 volts - plus la valeur est élevée, plus la broche est souvent HAUTE ( 5 volts) . Par exemple, une valeur de 64 sera de 0 volts trois quarts du temps et de 5 volts un quart du temps; une valeur de 128 sera à 0 la moitié du temps et à 255 la moitié du temps; et une valeur de 192 sera de 0 volts, un quart du temps et de 5 volts trois quarts du temps.
Comme il s'agit d'une fonction matérielle, la broche générera une onde constante après un appel à analogWrite en arrière-plan jusqu'au prochain appel à analogWrite (ou un appel à digitalRead ou digitalWrite sur la même broche).
Remarque: les broches analogiques contrairement aux broches numériques, n'ont pas besoin d'être d'abord déclarées comme INPUT ni OUTPUT.
Suspend votre programme pendant la durée spécifiée en millisecondes, où 1000 équivaut à 1 seconde.
retard (1000); // attend une seconde
6.26 ) millis ()
Renvoie le nombre de millisecondes depuis que la carte Arduino a commencé à exécuter le programme actuel en tant que valeur longue non signée.
valeur = millis (); // définit 'value' égale à millis ()
Remarque: ce nombre débordera (remis à zéro), après environ 9 heures.
7. Premier programme
7.1 ) Objet :
Clignotant la broche LED jusqu'à ce que l'interrupteur soit enfoncé
7.2 ) Schéma:
7.3 ) Croquis :
void setup() {i ntSw = 2; // Commutateur connecté sur la broche d' entrée numérique 2
intLedPin = 13; // led connecté à la broche 13
pinMode ( Sw, INPUT ); // déclaration de la broche d'entrée
digitalWrite ( Sw, LOW ); // écriture de la condition initiale sur // la broche 2
}
boucle vide ()
{
if ( digitalRead ( Sw ) == HIGH)
{ DigitalWrite ( ledPin, HIGH ); //CONDUIT SUR
retard (1000); // donnant un délai de 1 seconde
retard (1000); // donnant un délai de 1 seconde
}}
8. Communication série
La communication série consiste en l'envoi de données bit par bit via le port série. Ceci est essentiellement fait par les broches Tx et Rx sur la carte. Ce mode de communication est utilisé pour envoyer ou recevoir des données ou pour entrer dans les entrées et l' affichage ouputs sur l'écran via le moniteur de série dans l'IDE.
8.1 ) Serial.begin ( taux)
Ouvre le port série et définit le débit en bauds pour la transmission de données série. Le débit en bauds typique pour communiquer avec l'ordinateur est de 9600 bien que d'autres vitesses soient prises en charge.
void setup()
{ Serial.begin (9600); }
Remarque: lors de l'utilisation d'une communication série, les broches numériques 0 (Rx) et 1 ( Tx ) ne peuvent pas être utilisées en même temps
8.2 ) Serial.println ( données)
Imprime les données sur le port série, suivi d'un retour chariot automatique et d'un saut de ligne. Cette commande prend la même forme que Serial.print (), mais est plus facile pour lire les données sur le moniteur série.
Serial.println ( analogValue ); // envoie la valeur de analogValue
8.3 ) Série disponible ()
C'est la fonction qui récupère les données sur le bus série au niveau du port de communication. Ceci est utilisé pour lire les données provenant de l'Arduino via le port série.
if ( Serial.available () == '1') // vérifie si les données sur le bus sont logiquement égales à 1.
{ int a = 100; } // affectation de la valeur 100 à la variable a
8.
Système domotique
9.1 ) Objet:
C ontrolling un appareil AC avec un appareil Android.
9.2 ) Exigences:
Arduino carte , HC-05 Bluetooth module, fils cavalier, planche à pain, module de relais (5vdc, 220vAC, 7A), batterie et téléphone Android.
9.3) Schéma :
9.4 ) Procédure:
Téléchargez l'application Bluetooth Terminal à partir du Google Play Store sur Android.
Connectez le matériel comme indiqué sur la figure.
Suivez le code
#define commutateur 3;
void setup()
{
pinMode ( commutateur, SORTIE ); // broche connectée au signal de relais
S erial.begin (9600); // initialisation du COM série avec une vitesse de transmission de 9600
digitalWrite ( commutateur, LOW );
}
boucle vide ()
{
if ( Serial.available () == '1') // quand 1 est entré dans le terminal Bluetooth
{
digitalWrite ( commutateur, HIGH ); // commutation de la broche 3 en haut
Serial.println («Relais activé»);
}
if ( Serial.available () == '0') // quand 0 est entré dans le terminal Bluetooth
{
digitalWrite ( commutateur, LOW ); // commutation de la broche 3 au niveau bas
Serial.println («Relais OFF»);
}
autre
Serial.println («Entrée non valide»);
}
Gravez ce programme dans l'IDE Arduino
Déconnectez maintenant le câble de communication série de l'USB de l'ordinateur
Donner l'alimentation via l'adaptateur externe de la carte Arduino
Recherchez maintenant de nouveaux appareils Bluetooth dans le téléphone Android et connectez-vous au
Nom «HC-05».
Allez dans l'application de terminal Bluetooth téléchargée à l'étape 1.
Sélectionnez le nom de l'appareil dans l'application et le terminal s'ouvre.
Entrez maintenant les valeurs 1 pour activer le relais et 0 pour le désactiver.
9.5 ) Observations :
Dans l'application du terminal Bluetooth, les valeurs 1 et 0 permettent d'activer et de désactiver le relais.
9.6 ) Résultat :
Le téléphone Android peut être utilisé pour contrôler encore plus de relais de la même manière. Cela aidera à contrôler les appareils sans fil .
10. Conclusion
Arduino est une plate-forme open source pour intégrer, innover, construire, inventer et atteindre des objectifs d'automatisation. Il s'agit d'un rapport qui n'a que les bases pour commencer. Bien que la portée s'étend à l'infini.
Actuellement, les gens sur une base industrielle utilisent Arduino pour contrôler les machines CNC, l'impression 3D, la domotique, la détection radio, les stations météorologiques, les commandes robotiques, la biométrie, les sciences médicales et la liste est longue.
Et avec l'ajout de l' IoT (Internet des objets), Arduino atteint un tout nouveau niveau de terrain.
