Apprentissage de la programmation Arduino de base - Tutoriel pour les nouveaux arrivants

Dans ce didacticiel, nous apprenons à effectuer la programmation de base Arduino à travers des exemples de codes et des exemples de programmes. Ce tutoriel peut être un cours extrêmement précieux pour tous les nouveaux arrivants qui souhaitent saisir les bases dans un langage simple et compréhensible.

introduction

Selon Wikipédia un microcontrôleur équivaut à un mini-ordinateur construit à l'intérieur d'une seule puce IC, ayant son propre processeur central, des entrées programmables, une mémoire et des périphériques de sortie.

Un microcontrôleur devient si utile pour un utilisateur car il offre un processeur intégré, une mémoire et des ports d'entrée / sortie (également appelés GPIO ou broches d'entrée / sortie à usage général) que nous pouvons être contrôlés par l'utilisateur selon les spécifications souhaitées.

Dans ce tutoriel, nous travaillerons avec une carte Arduino Uno pour apprendre et tester les programmes. Pour tester et intégrer l'assemblage du matériel, nous utiliserons une maquette.

Passons maintenant rapidement et apprenons à démarrer avec une programmation Arduino.

1.2 Installation du logiciel (Windows)

Pour cela, vous aurez besoin d'un accès à Internet, ce que vous auriez évidemment sur votre ordinateur. Veuillez aller sur le lien suivant et télécharger le logiciel IDE:

Fichier ZIP Windows pour une installation non administrateur

Après le téléchargement, vous trouverez l'icône de configuration Arduino dans le dossier de téléchargement, qui ressemblerait à ceci:

Une fois que vous avez obtenu cela, vous pouvez simplement double-cliquer dessus et installer Arduino, l'environnement de développement intégré (IDE) sur votre ordinateur. Le processus complet peut être visualisé dans la vidéo suivante:

1.4 À partir de notre premier circuit

Avant de commencer à apprendre les techniques de programmation réelles, pour tout débutant, il serait utile de commencer par un composant de base tel qu'une LED, et de comprendre comment le connecter à un Arduino.

Comme nous le savons, une LED est une diode électroluminescente qui a une polarité et ne s'allumera pas si elle n'est pas connectée aux bons pôles d'alimentation.

Un autre aspect des LED est que ces appareils fonctionnent avec un courant faible et peuvent être endommagés instantanément si une résistance correctement calculée n'est pas incluse en série avec l'une de ses broches.

En règle générale, un 1/4 watt de 330 ohms est tout à fait idéal pour chaque augmentation de 5 V de l'entrée d'alimentation afin de limiter le courant à un niveau de sécurité requis. Par conséquent, pour 5V, cela peut être de 330 ohms, pour 10V, cela peut être de 680 ohms et ainsi de suite.

Utilisation de la planche à pain pour l'assemblage

Veuillez vous assurer que vous savez comment utiliser un planche à pain avant d'essayer le didacticiel expliqué dans ce chapitre, car nous utiliserions une maquette pour toutes les expériences ici.

La configuration de base de la connexion LED peut être observée ci-dessous:

Vous pouvez voir 3 composants de base ci-dessus:

1. Une LED de 5 mm, 20 mA
2. une résistance de 330 ohms 1/4 watt
3. Une Carte Arduino

Assemblez simplement le système selon le schéma.

Ensuite, branchez le 5V de l'ordinateur USB à l'Arduino. Dès que vous faites cela, vous verrez la LED s'allumer.

Je sais que c'est assez basique, mais il est toujours bon de partir de zéro. Soyez assuré que les choses commenceront à devenir de plus en plus intéressantes à mesure que nous avancerons.

1.5 Contrôle de la LED avec Arduino

Nous allons maintenant apprendre à contrôler une LED avec un programme Arduino.

Pour écrire un programme, nous devons avoir au moins 2 fonctions dans chaque programme.

Une fonction peut être comprise comme une série d'instructions de programmation qui peuvent être affectées d'un nom, comme indiqué ci-dessous:

1. installer() ceci est appelé ou exécuté pendant le démarrage du programme.
2. boucle() ceci est appelé ou exécuté de manière répétitive pendant toute la période de fonctionnement de l'Arduino.

Par conséquent, bien qu'il puisse n'avoir aucune fonctionnalité pratique, techniquement, un programme Arduino légitime le plus court peut être écrit comme suit:

Programme le plus simple

void setup()
{
}
void loop()
{
}

Vous avez peut-être remarqué que dans de nombreux langages de programmation, le système commence par afficher une simple impression, `` Hello, World '' sur l'écran d'affichage

L'équivalent électronique de cette phrase dans l'interprétation du microcontrôleur est de faire clignoter une LED ON et OFF.

C'est le programme le plus basique que l'on puisse écrire et implémenter pour indiquer un fonctionnement correct du système.

Nous essaierons d'implémenter et de comprendre la procédure à travers le morceau de code suivant:

Liste 1.2: led1 / led1.pde

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

OK, comprenons maintenant ce que signifie chaque ligne du code et comment cela fonctionne pour exécuter la fonction:

const int kPinLed = 13

Cela fonctionne comme une constante qui nous permet de l'utiliser pendant le cours de programmation complet, sans avoir besoin d'utiliser la valeur réelle qui lui est opposée.

Selon les règles standard, ces constantes sont reconnues avec la lettre de départ à . Bien que ce ne soit pas obligatoire, cela rend les choses plus claires et facilement compréhensibles chaque fois que vous avez envie de parcourir les détails du code.

void setup()
{
pinMode(kPinLed, OUTPUT)
}

Ce code configure la broche spécifique à laquelle notre LED est connectée. En d'autres termes, le code indique à l'Arduino de contrôler l'aspect «écriture» sur cette broche, au lieu de la «lire».

void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

Les lignes ci-dessus indiquent l'exécution réelle de l'application. Le code commence par écrire et rendre une sortie HIGH sur la connexion LED correspondante, allumant la LED.

Ici, le terme HIGH signifie simplement obtenir + 5V sur la broche concernée de l'Arduino. Le terme complémentaire LOW indique simplement un zéro ou un 0V sur la broche désignée.

Ensuite, nous appelons delay() dont la fonction est de créer un délai de quelques millisecondes (1 / 1000e de seconde). Puisque le chiffre 500 est entré, le délai mis en œuvre va être d'une 1/2 seconde.

Dès que cette 1/2 seconde est écoulée, la ligne suivante est exécutée qui éteint la LED avec le terme LOW sur la même broche.

La ligne suivante génère à nouveau le retard de 1/2 seconde, afin de permettre à la LED de rester éteinte pendant 1/2 seconde.

Et le processus se poursuit indéfiniment par l'exécution des lignes de code, tant que l'Arduino reste alimenté.

Avant de passer au niveau suivant, je vous recommande de programmer le code ci-dessus et de vérifier si vous êtes en mesure d'implémenter la séquence LED ON / OF correctement ou non.

Étant donné que la LED par défaut dans Arduino est connectée à la broche # 13, elle doit immédiatement répondre au programme ci-dessus et commencer à clignoter. Cependant, si vous trouvez que votre LED externe ne clignote pas, il pourrait y avoir un problème de connexion avec votre LED, vous pouvez essayer d'inverser la polarité de votre LED et, espérons-le, la voir clignoter aussi.

Vous pouvez jouer avec le temps de retard en modifiant le chiffre «500» sur une autre valeur et trouver la LED «écoutant» les commandes et en la faisant clignoter selon les valeurs de retard spécifiées.

Mais rappelez-vous que si vous voyez que la LED ne clignote pas avec une fréquence constante de 1 seconde, quelle que soit la modification de votre temps de retard, cela peut indiquer que le code ne fonctionne pas en raison d'une erreur. Parce que par défaut, l'Arduino sera programmé avec une fréquence de clignotement de 1 seconde. Par conséquent, ce taux doit être varié par votre code pour confirmer son bon fonctionnement.

1.7 Commentaires

Les lignes de codes que nous avons comprises ci-dessus ont été spécifiquement écrites pour le logiciel informatique.

Cependant, afin de s'assurer que l'utilisateur est capable de se référer à la signification des lignes et de les comprendre, il peut souvent être utile et judicieux d'écrire l'explication à côté des lignes de codes souhaitées.

Ceux-ci sont appelés commentaires qui sont écrits pour référence humaine ou utilisateur uniquement, et sont codés pour permettre aux ordinateurs de l'ignorer en toute sécurité.

La langue de ces commentaires est écrite avec quelques formats:

1. Le style de bloc du commentaire, dans lequel la description du commentaire est placée sous le symbole de début / * et le symbole de fin * /
2. Cela ne doit pas nécessairement être limité à une ligne, mais peut être étendu aux lignes suivantes suivantes en fonction de la longueur du commentaire ou de la description, comme indiqué dans l'exemple suivant:

/ * Ceci est un commentaire * /

/ * Ainsi est-ce * /

/* Et
* ce
* comme
* bien */

Pour écrire une description rapide sur une seule ligne d'un commentaire, deux barres obliques // au début suffisent. Cela indique à l'ordinateur que cette ligne n'a rien à voir avec le code réel et doit être ignorée. Par exemple:

// Ceci est un commentaire que les ordinateurs ignoreront.

Voici un exemple de référence:

/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/

/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

1.8 Dépannage

Si vous trouvez que votre programme affiche une `` erreur '' lors de la compilation, ou un autre problème, les conseils suivants vous aideront probablement à revérifier votre code pour vous débarrasser de l'obstacle.

1. La langue de votre programme sera sensible à la casse. Par exemple l'expression myVar ne peut pas être écrit comme MyVar.
2. Tous les types d'espaces blancs qui peuvent être exécutés par la saisie de votre clavier, sont finalement rendus comme un seul espace, et il n'est visible ou compris que par vous, l'ordinateur ne prendra pas cela en compte. En termes simples, les espaces libres de toute nature n'auront aucun effet sur les résultats du code.
3. Chaque bloc de code doit être entouré d'accolades gauche et droite, '{' et '}'
4. Les chiffres des nombres ne doivent pas être séparés par des virgules. Par exemple, 1000 ne peut pas être écrit comme 1000.
5. Chaque ligne de code entre les accolades doit se terminer par un point-virgule

Création d'une séquence lumineuse LED intéressante avec Arduino

Dans notre chapitre précédent, nous avons appris comment faire clignoter une LED ON / OFF en continu avec un taux de retard constant.

Nous allons maintenant apprendre comment différents modèles de retard peuvent être exécutés sur la même LED en mettant à jour le code du programme.

Nous n'utiliserons pas de LED externe, mais plutôt la LED par défaut intégrée à la carte Arduino à la broche # 13. Vous pouvez trouver cette minuscule LED SMD juste derrière le connecteur USB.

2.2 Comprendre les instructions IF

Dans cette section, nous allons apprendre comment les structures de contrôle nous permettent d'exécuter des codes individuels, et parfois même de manière répétitive, selon les besoins.

La déclaration si devient la 1ère structure de contrôle. L'implémentation suivante montre comment elle est utilisée:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Nous allons essayer de comprendre le code ci-dessus étape par étape et apprendre comment cela peut être utilisé pour d'autres exécutions similaires.

Les codes entre la 1ère et la 7ème ligne sont exactement similaires à notre programme initial.

La première modification se produit en fait sur la 8ème ligne.

int delayTime = 1000

Vous pouvez trouver que cela est similaire au code de la 1ère ligne, sauf s'il manque le terme const.

C'est simplement parce que ce code n'est pas une constante. Au lieu de cela, cela est défini comme un variable , qui a la propriété d'une valeur variable au cours de la programmation.

Dans l'exemple ci-dessus, vous pouvez voir que cette variable est attribuée avec une valeur de 1000. N'oubliez pas que les variables entre parenthèses doivent être strictement écrites entre des paires de parenthèses et sont appelées variables «locales».

Alternativement, les variables qui sont supposées être en dehors des accolades, comme celle dont nous discutons maintenant, sont reconnues comme «globales» et pourraient être exécutées à peu près n'importe où dans un code de programme.

En allant de l'avant, vous pouvez voir que les codes entre les lignes 9 et 11 sont également similaires au premier programme, néanmoins les choses commencent à devenir intéressantes après la ligne 11. Voyons comment!

delayTime = delayTime - 100

Dans ce code, nous voyons que la valeur par défaut du temporisation est en cours de modification en en soustrayant 100.

Ce qui signifie 100 est déduit de sa valeur initiale de 1000, ce qui lui donne une nouvelle valeur de 900.

À travers l'image suivante, nous allons essayer de comprendre quelques-uns des opérateurs mathématiques utilisés dans le langage Arduino.

Évaluons maintenant les codes entre les lignes 13 et 15.

if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}

L'objectif principal du morceau de code ci-dessus est de s'assurer que la LED continue de clignoter sans aucune interruption.

En raison du fait que 100 est déduit de l'original temporisation , il empêche le clignotement de la LED d'atteindre zéro et permet au clignotement de continuer en continu.

L'image suivante montre quelques opérateurs de comparaison que nous utiliserions dans nos codes:

Dans notre code ci-dessus, nous aurions pu tester le code comme étant if(delayTime == 0).

Cependant, comme être un chiffre négatif peut être tout aussi mauvais, nous ne l'avons pas choisi, et c'est une pratique recommandée.

Pensez à ce qui aurait pu être le résultat si nous avions essayé de déduire 300 au lieu de 100 de delayTime?

Alors maintenant, vous avez peut-être réalisé que si le delayTime est écrit comme inférieur ou égal à zéro, le temps de retard serait alors remis au chiffre original 1000.

digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)

Les 4 dernières lignes du code comme indiqué ci-dessus deviennent responsables de l'allumage / extinction, de l'allumage / extinction continu de la LED.

Ici, vous pouvez clairement remarquer qu'au lieu d'utiliser un certain nombre de chiffres, nous avons utilisé une variable pour attribuer le temps de retard afin que nous puissions l'ajuster comme nous le souhaitons pendant la période opérationnelle du code. C'est cool, non?

2.3 Déclarations ELSE

Ici, nous allons apprendre pourquoi et comment un si le terme peut avoir une clause autre afin qu'il décide de la situation au cas où si la déclaration est fausse.

Je suis désolé si cela semble trop déroutant, ne vous inquiétez pas, nous essaierons de le comprendre avec l'exemple suivant:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Dans ce qui précède, vous pouvez bien voir que dans la 10e ligne, le code n'est exécuté que lorsque le delayTime est inférieur ou égal à 100, sinon le code de la 13e ligne est exécuté, mais les deux ensemble ne peuvent jamais se produire, soit la 10e ligne ou le code de 13e ligne sera implémenté, jamais les deux.

Vous avez peut-être remarqué que contrairement à ce que nous avons fait dans notre section 2.2 précédente, ici nous n'avons pas comparé avec 0, plutôt comparé à 100. C'est parce que dans cet exemple comparé AVANT nous avons soustrait 100, contrairement à la section 2.2, nous avons comparé APRÈS que nous soustrait. Pouvez-vous dire ce qui aurait pu arriver si nous avions comparé 0 au lieu de 100?

2.4 Instructions WHILE

À tandis que déclaration est assez similaire à si , à l'exception du fait qu'il provoque une exécution répétée d'un bloc de code (qui peut être entre accolades) tant que les conditions sont applicables, et cela fonctionne sans autre déclaration.

L'exemple suivant vous aidera à mieux comprendre cela

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}

Pouvez-vous deviner ce que le code ci-dessus est programmé pour faire? Eh bien, il est conçu pour faire clignoter la LED plus rapidement, puis plus lentement.

2.5 Qu'est-ce qui est vrai et faux?

En langage de programmation, faux fait référence à zéro (0). En fait, «vrai» n'est pas utilisé, à la place, on suppose que lorsque rien n'est faux, alors tout ce qui est inclus est vrai.

Cela a l'air un peu étrange, mais il fait assez bien le travail.

Nous allons essayer de saisir la situation à travers l'exemple suivant.

Vous pouvez parfois rencontrer un code comme indiqué ci-dessous:

while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}

Ceci est codé comme si l'exécution de la LED continuera à tourner pour toujours, tant que la puissance est disponible.

Cependant, un inconvénient de ce type de code pourrait survenir lorsque l'utilisateur applique accidentellement un = au lieu de ==.

Je suis sûr que vous savez déjà que = signifie une affectation, ce qui signifie qu'il est utilisé pour désigner une valeur sélectionnée à une variable, tandis qu'un == est utilisé pour appliquer un test si la valeur était la même.

Par exemple, supposons que vous ayez besoin d'une LED pour clignoter avec un motif de vitesse séquentielle et répétitif, mais que vous avez mal utilisé un = au lieu de ==.

Le code apparaîtrait alors comme ceci:

int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}

L'erreur attribuera 0 à delayTime, et conduira au si instruction pour vérifier si 0 était vrai ou non. Puisque 0 fait référence à faux, il pensera que ce n'est pas vrai et arrêtera l'application de delayTime = 1000, mais à la place la fonction delayTime est maintenu à 0 au cours de la boucle ().

Cela semble très indésirable !!

Alors, vérifiez toujours votre programme pour vous assurer que vous n'avez pas commis d'erreurs aussi stupides.

2.6 Combinaisons

Parfois, vous ressentez le besoin de tester plusieurs choses ensemble. Par exemple, vous voudrez peut-être examiner si une variable était entre deux nombres. Bien que cela puisse être implémenté à l'aide de l'instruction if plusieurs fois, il peut être plus pratique d'utiliser des combinaisons logiques pour une lecture meilleure et plus facile.

La mise en œuvre de combinaisons sur des termes logiques peut être effectuée avec 3 méthodes, comme indiqué dans le tableau suivant:

Il serait intéressant de savoir que l'opérateur NOT peut fonctionner comme un commutateur pour une variable qui peut être désignée comme étant soit vrai ou faux (ou BAS ou HAUT).

L'exemple suivant illustre la condition:

int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}

Ici, le ledState sera BAS, et par la suite dès que ledState = !ledState, il deviendra HIGH. La boucle suivante provoquera ledState être HIGH quand ledState = !ledState est faible.

2.7 Instructions FOR

Nous allons maintenant essayer de comprendre une autre structure de contrôle qui est pour boucle. Cela peut être très pratique lorsque vous souhaitez implémenter quelque chose plusieurs fois.

Comprenons cela avec l'exemple suivant:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}

Vous pouvez trouver quelque chose d'unique dans la ligne avec pour.

C'est le code i ++? . Ceci est utile pour les programmeurs qui sont plutôt paresseux et qui souhaitent implémenter le codage via des raccourcis pratiques

Le terme ci-dessus est connu sous le nom d'opérateurs composés, car ils font le travail de combiner un opérateur d'affectation avec un autre opérateur d'affectation. Les plus populaires d'entre eux peuvent être visualisés dans le tableau suivant:

Vous constaterez qu'il y a 3 sous-instructions dans une instruction for. Il est structuré comme indiqué ci-dessous:

for (statement1conditionstatement2){
// statements
}

La déclaration n ° 1 se produit juste au début et une seule fois. La condition est testée à chaque fois au cours de la boucle. Chaque fois que c'est vrai à l'intérieur des accolades, l'instruction suivante n ° 2 est appliquée. En cas de faux, le système passe au bloc de code suivant.

Connecter plus de LED

OK, nous allons maintenant voir comment nous pouvons connecter plus de LEds pour obtenir des effets plus intéressants.

Veuillez connecter les LED et l'Arduino comme indiqué ci-dessous. Le fil rouge n'est en fait pas nécessaire, mais comme c'est toujours une bonne idée d'avoir les deux rails d'alimentation inclus dans la maquette, la configuration est logique.

Corrigeons maintenant un programme qui nous permettra de vérifier si notre matériel est correctement configuré ou non.

Il est toujours recommandé de coder et d'exécuter de petits morceaux de programmes par étapes pour vérifier si les matériels respectifs sont correctement câblés ou non.

Cela permet de dépanner rapidement une erreur possible.

L'exemple de code ci-dessous fournit aux LED 2 à 5 un motif spécifique en les tournant l'une après l'autre de manière cyclique.

const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}

Comme vous le remarquerez peut-être, il n'y a rien de mal avec le code, sauf le fait qu'il a l'air long et donc sujet aux erreurs.

Bien sûr, il existe de meilleures façons d'écrire le code ci-dessus, la section suivante le révélera.

2.9 Présentation des tableaux

Les tableaux peuvent être un groupe de variables qui peuvent être indexées avec des numéros d'index. L'exemple suivant nous aidera à mieux le comprendre.

const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}

OK, parcourons maintenant chaque section et comprenons comment elles fonctionnent réellement.

const int k_numLEDs = 4

Le code ci-dessus définit le nombre maximum d'éléments que nous sommes censés avoir dans le tableau. Ce code nous aide dans les sections suivantes à nous assurer que tout est écrit dans un tableau et rien une fois le tableau terminé.

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

Dans cette ligne suivante, nous mettons en place la structure du tableau. Les nombres à l'intérieur du crochet indiquent le nombre d'éléments dans le tableau. Bien que la quantité réelle ait pu être écrite, l'écriture sous forme de constantes fonctionne mieux. Les valeurs sont normalement visibles à l'intérieur du crochet avec des virgules et désignent les valeurs du tableau.

Lorsque vous trouvez un tableau indexé avec le numéro 0, cela indique le tout premier élément du tableau, comme indiqué dans le code: k_LEDPins is k_LEDPins[0].

De même, le dernier élément sera affiché comme k_LEDPins[3], puisque le nombre de 0 à 3 est 4.

void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}

Le code ci-dessus montre l'utilisation de la boucle pour parcourir chaque élément du tableau et pour les définir comme SORTIES. Nous implémentons des crochets avec l'index pour atteindre chacun des éléments du tableau.

Si vous vous demandez s'il est possible d'utiliser la broche # 2 à la broche # 5 sans tableaux, la réponse est oui, c'est possible. Mais dans cet exemple, ce n'est pas fait parce que nous ne l'avons pas fait de cette manière. Dans les sections suivantes, vous pouvez éliminer l'approche par matrice si les broches de sortie sélectionnées ne sont pas alignées.

En allant de l'avant, voyons ce que fait le prochain bloc de code:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}

Ici, le code passe à travers chacune des LED pour les allumer séquentiellement avec un intervalle ou un retard de 100 millisecondes.

for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}

L'utilisation du code ci-dessus montre comment l'application de pour boucle pourrait être utilisé pour se déplacer dans la boucle même dans l'ordre inverse.

Il commence à partir de k_numLEDs - 1 car les tableaux sont indexés à zéro. Nous ne partons pas de k_LEDPins[4] car cela aurait pour effet de franchir la fin du tableau.

Le code utilise> = 0 pour vérifier que le premier élément à l'index 0 n'est pas manqué ou ignoré.

chapitre 3

Qu'est-ce qu'une entrée

Nous avons donc appris à faire fonctionner les choses en utilisant Arduino. Dans ce chapitre, nous discuterons de la manière de détecter le monde réel en interfaçant les entrées de paramètres externes.

3.1 Utilisation des boutons poussoirs

Nous savons tous ce qu'est un bouton-poussoir et comment il fonctionne. C'est une sorte d'interrupteur ou de bouton qui connecte momentanément un signal d'un étage de circuit à un autre alors qu'il est en état enfoncé, et interrompt le signal lorsqu'il est relâché.

3.1.1 Un bouton et une LED

Nous connecterons l'Arduino avec un bouton-poussoir avec Arduino selon les détails ci-dessus et apprendrons le fonctionnement de base et la mise en œuvre de la configuration.

Le bouton-poussoir indiqué, également appelé bouton-poussoir micro-interrupteur, possède 4 broches au total (2 paires de chaque côté). Lorsqu'elles sont poussées, chaque paire de broches sont jointes en interne et permettent une connexion ou une conduction entre elles.

Dans cet exemple, nous n'utilisons qu'une seule paire de ces broches ou contacts, l'autre paire n'est pas pertinente et est donc ignorée.

Continuons d'appliquer le code suivant et vérifions qu'il fonctionne!

const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Vous pouvez trouver ici quelques éléments qui semblent inhabituels. Découvrons-les par étapes.

void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}

La première chose que nous faisons est de réparer le boutonPin comme le SAISIR. Eh bien, c'est assez basique, je sais.

Ensuite, nous attribuons HAUT à la SAISIR épingler. Vous vous demandez comment il est possible d'écrire quoi que ce soit à l'entrée? Bien sûr, cela peut être intéressant.

En fait, l'attribution d'un HAUT à une entrée Arduino active une résistance de rappel interne de 20k Ohm (un BAS sur cette broche la désactive).

Une autre question que vous pouvez vous poser est de savoir ce qu'est une résistance pull-up. J'ai couvert un article complet sur les résistances de traction que vous apprenez-le ici .

OK, allons-y, regardons maintenant le code de la boucle principale:

void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Lorsque vous appuyez sur le bouton-poussoir, la broche filaire est connectée à la terre, ce qui rend un FAIBLE à cette épingle. Et tandis que dans l'état non pressé, la même épingle est tenue à HAUT ou + 5V via la résistance de rappel interne de 20K.

Ici, nous voulons que l'Arduino allume la LED lorsque le bouton-poussoir est enfoncé (LOW), donc nous écrivons HIGH pour la sortie pour chaque réponse d'un LOW du bouton-poussoir, alors qu'il est enfoncé.

3.1.2 Deux boutons et une LED

Eh bien, vous vous demandez peut-être que l'action illustrée ci-dessus aurait également pu être effectuée sans Arduino. Je comprends, cependant, que c'est une pierre inflexible pour apprendre comment le bouton-poussoir pourrait être utilisé avec Arduno.

Jusqu'à ce point, nous avons étudié l'écriture de codes pour allumer (HIGH) ou éteindre (LOW) une LED.

Voyons maintenant comment la luminosité de la LED peut être contrôlée avec un Arduino.

Cela peut être fait en utilisant deux méthodes:

1. En limitant la quantité de courant à la LED
2. En utilisant PWM ou une modulation de largeur d'impulsion, dans laquelle l'alimentation de la LED est activée / désactivée à une certaine vitesse souhaitée très rapidement, produisant un éclairage moyen dont l'intensité dépendrait du PWM.

Dans une carte Arduino, le support PWM est disponible sur les broches marquées d'un tilde (~), qui sont les broches 3, 4,5,9,10 et 11) à 500 Hz (500 fois par seconde). L'utilisateur est capable de fournir n'importe quelle valeur entre 0 et 255, où 0 fait référence à pas de HIGH ou pas de + 5V, et 255 indique à Arduino d'obtenir un HIGH ou + 5V tout le temps. Pour lancer ces commandes, vous devrez accéder à analogWrite () avec la valeur souhaitée.

Vous pouvez supposer que PWM est x / 255 où x est la valeur souhaitée que vous souhaitez envoyer via analogWrite().

Configurez l'Arduino et d'autres paramètres comme indiqué ci-dessus.

const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
}

Vous pouvez trouver 3 lignes ici nécessitant des explications.

ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)

La ligne: ledBrightness = constrain(ledBrightness, 0, 255) illustre une fonction unique à l'intérieur d'Arduino connue sous le nom de contrainte ().

Cette fonction interne comprend un code semblable au suivant:

int contrainte (valeur int, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Tous les codes discutés avant cela ont commencé par annuler , ce qui signifiait ne rien rendre (nul). Alors que le code ci-dessus commence par int , ce qui indique qu'il renvoie un entier. Nous en discuterons plus dans les sections suivantes, pour le moment, rappelez-vous simplement qu'un entier n'a pas de parties fractionnaires.

Bon, donc cela implique, le code: ledBrightness = constrain(ledBrightness, 0, 255) affecte le ledBrightness to be within the range of 0 and 255.

La ligne suivante utilise analogWrite pour ordonner à Arduino d'appliquer PWM sur la broche sélectionnée avec la valeur souhaitée.

La ligne suivante crée un retard de 20 millisecondes, c'est pour s'assurer que nous ne réglons pas la consommation plus rapide que 50 Hz ou 50 fois par seconde. C'est parce que les humains peuvent être beaucoup plus lents qu'un Arduino. Par conséquent, si le retard n'est pas fait, le programme pourrait nous faire sentir que le fait d'appuyer sur le premier bouton éteignait la LED et que d'appuyer sur le second pour l'allumer (essayez vous-même pour confirmer).

3.2 Potentiomètres

Avançons et apprenons à utiliser potentiomètres avec Arduino.

Pour savoir comment fonctionne un potentiomètre ou un pot, vous pouvez lire le article .

Connectez les paramètres affichés avec votre Arduino comme indiqué ci-dessus.

Un pot aura 3 bornes. Le terminal central se connectera à ANALOG IN 0 sur l'Arduino. Les deux autres bornes externes peuvent être connectées à des rails d'alimentation + 5V et 0V.

Programmons et vérifions les résultats:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
}

Vous trouverez quelques éléments qui peuvent paraître entièrement nouveaux et qui ne sont inclus dans aucun de nos codes précédents.

1. La constante kPinPot est assigné à A0, où A est le raccourci pour décrire l'une des broches analogiques. Cependant, A0 fait également référence à la broche n ° 14, A1 à la broche n ° 15 et ainsi de suite, et celles-ci vous permettent d'être utilisées comme entrées / sorties numériques au cas où vous seriez à court de broches pour une expérience. Mais rappelez-vous que vous ne pouvez pas utiliser de broches numériques comme broches analogiques.
2. La ligne: ledBrightness = map(sensorValue, 0, 1023, 0, 255) présente une nouvelle fonction interne dans Arduino connue sous le nom de carte(). Cette fonction recalibre d'une plage donnée à une autre, appelée map (valeur, fromLow, fromHigh, toLow, toHigh). Cela peut devenir crucial puisque analogueRead donne une valeur comprise entre 0 et 1023, mais analogWrite peut accepter une valeur de 0 à 255.

Vous pensez peut-être que, puisqu'il est possible de contrôler la luminosité d'une LED grâce à une résistance changeante, un simple pot aurait pu être suffisant à cet effet, pourquoi l'utilisation d'Arduino. Eh bien, encore une fois, ce n'est que la base, pour montrer comment un pot pourrait être configuré avec un Arduino.

Pas de problème, nous allons maintenant faire quelque chose qui ne peut pas être fait sans Arduino.

Dans cette expérience, nous verrons comment la résistance variable d'un pot pourrait être utilisée pour contrôler la vitesse de clignotement ou le taux d'une LED.

Voici le programme:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}

3.2.3 Éviter les retards ()

Le code ci-dessus semble bon, mais la LED ne peut pas vérifier la valeur du pot jusqu'à ce qu'elle passe par chaque cycle complet. Pour des délais plus longs, ce processus s'allonge, l'utilisateur doit attendre de voir la réponse du pot pendant qu'il la déplace. Ce retard peut être évité avec une programmation intelligente, de sorte qu'il permet à l'utilisateur de vérifier la valeur sans délais minimum. Voici le code.

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}

Alors, qu'est-ce qui est différent dans le code ci-dessus? C'est la ligne suivante qui fait la différence.

long lastTime = 0

Jusqu'à cette section, nous avons discuté de la variable int. Cependant, il peut y avoir de nombreuses autres variables de types auxquelles vous pouvez accéder. La liste peut être lue ci-dessous:

À l'heure actuelle, il n'est peut-être que crucial de savoir que pour stocker des nombres relativement importants int variable, vous pouvez utiliser le terme longue ou un long int.

Ici vous pouvez voir une autre fonction intéressante appelée millis ().

Cela produit l'intervalle de temps en millisecondes pendant lequel l'Arduino a fonctionné au cours de son fonctionnement depuis le début (cela sera réinitialisé à 0 tous les 50 jours). Ici il retourne un long car s'il est retourné int , compter pendant de longues périodes peut ne pas être possible. Pouvez-vous répondre exactement combien de temps? La réponse est de 32,767 secondes.

Par conséquent, au lieu d'utiliser delay (), nous vérifions les millis (), et dès que le nombre de millisecondes s'écoule, nous changeons la LED. Par conséquent, nous stockons l'heure à laquelle nous l'avons modifié pour la dernière fois dernière fois variable, de sorte qu'il nous permet de le vérifier à nouveau chaque fois que vous le souhaitez.

3.3 LED RVB

Jusqu'à présent, nous avons joué avec une LED à une seule couleur. Bien que la couleur de la LED puisse être modifiée en remplaçant la LED par une autre couleur, mais que diriez-vous d'utiliser des LED RVB pour changer les couleurs des LED sans changer les LED?

Une LED RVB est essentiellement une LED ayant une LED rouge, verte et bleue intégrée et fusionnée en une seule LED. Il a un fil commun qui va à la terre ou au rail d'alimentation 0V tandis que les 3 autres fils sont alimentés avec des signaux positifs PWM diversifiés pour mettre en œuvre le mélange de couleurs .

Vous pouvez câbler l'installation comme indiqué ci-dessous:

Cela peut sembler un peu complexe, mais en fait, c'est une réplique de notre conception antérieure de contrôle LED utilisant PWM.

Voici un code de programme d'entraînement:

const int kPinPot1 = A0
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
}

Après avoir téléchargé ce code, voyez simplement comment les réglages du pot créent un effet de lumière intéressant sur le RVB, cela peut être très amusant.

Vous constaterez que lorsque tous les 3 pots sont déplacés à des positions maximales, au lieu d'une couleur blanche, vous verrez du rouge. En effet, la couleur rouge est la plus importante parmi les 3 couleurs et domine donc dans cette situation. Cependant, vous pouvez expérimenter la fonction carte() , avant de l'exécuter sur la partie rouge de la LED, afin de créer un équilibre plus sensible.

Audio avec Arduino

Dans cette section, nous allons apprendre comment ajouter un son et de la musique de base à une configuration Arduino.

Nous verrons comment basculer un signal vers une enceinte connectée avec une fréquence souhaitée.

Pour être plus précis, une note moyenne A sera essayée, qui est une note de fréquence de 440 Hz.

Pour ce faire, nous allons simplement jouer une note médiane A et optimiser le signal sinusoïdal avec une onde carrée.

De plus, nous calculerons la durée pendant laquelle un haut-parleur peut rester allumé en appliquant la formule:

timeDelay = 1 seconde / 2 x toneFrequency.

timeDelay = 1 seconde / 2 x 440

timeDelay = 1136 microsecondes

4.1 Connectons la carte Arduino

4.2 Ajouter une note simple

Nous avons déjà discuté de la fonction retard() où l'unité est en millisecondes (seconde / 1000), mais vous trouverez encore une autre fonction delayMicroseconds() où l'unité est en microsecondes, (milliseconde / 1000).

Pour la configuration actuelle, nous programmons un code pour activer / désactiver + 5V sur la broche sélectionnée liée à l'enceinte, à la fréquence de 440 impulsions par seconde.

Rappelez-vous, dans la dernière discussion, nous avons déterminé la valeur de 1136 microseconde pour la note audio prévue.

Voici donc le programme pour cela, qui vous permettra d'entendre une note audio de 440 Hz dès que vous programmez l'arduino avec un haut-parleur connecté.

const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}

Avec l'application ci-dessus, il est possible de créer une note audio, ce qui signifie également que nous pouvons créer une musique selon notre propre choix.

D'après le code, nous comprenons qu'Arduino comprend quelques fonctions intégrées qui contribuent en outre à la création de musique.

Le premier est Ton() qui fonctionne avec 2 éléments avec un 3ème élément optionnel, désigné comme tonalité (broche, fréquence, durée). ou tonalité (broche, fréquence)

Les deux sont désignés pour exécuter respectivement la période de temps attribuée par vous.

En l'absence de délai, la musique continuera à jouer jusqu'à l'appel Ton() est exécuté à nouveau, ou jusqu'à ce que vous exécutiez pas une ().

Cela devra être fait en utilisant une fonction de retard au cas où la lecture de musique serait la seule chose fondamentale que vous implémentiez.

La durée peut être cruciale car elle permet de fournir une heure pour la durée de lecture de la musique, vous pouvez donc être libre de faire d'autres choses. Dès que la durée est écoulée, la musique s'arrête.

La fonction suivante pas une () gère un seul paramètre et arrête la tonalité sélectionnée sur une broche assignée particulière.

Un avertissement particulier: à tout moment Ton() La fonction est implémentée, la fonction PWM sur les broches 3 et 11 cessera de fonctionner.

Par conséquent, chaque fois qu'une pièce jointe de haut-parleur est utilisée dans le programme, assurez-vous de ne pas utiliser la broche mentionnée pour les haut-parleurs, essayez plutôt d'autres broches pour la fixation de haut-parleur.

OK alors voici le programme pour implémenter de la musique sur un haut-parleur, bien que ce ne soit pas une vraie musique plutôt une note de base à l'échelle C.

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}

Dans le code ci-dessus, vous avez peut-être remarqué quelque chose de nouveau et c'est #définir .

Ce terme fonctionne comme une commande de recherche et de remplacement pour l'ordinateur pendant la compilation.

Chaque fois qu'il trouve la première chose avant un espace, il le remplace par la partie restante de la ligne (appelée macros).

Donc, dans cet exemple, lorsque l'ordinateur voit NOTE_E4 il le remplace rapidement par la quantité 330.

Pour plus de notes et de personnalisation, vous pouvez vous référer à un fichier de votre clé USB nommé emplacements.h , où la plupart des fréquences peuvent être trouvées selon vos préférences.

4.4 Musique avec fonctions

Le code ci-dessus a l'air bien, mais semble avoir beaucoup de répétitions, il devrait y avoir une méthode pour raccourcir ces répétitions, non?

Jusqu'à présent, nous avons travaillé avec deux fonctions essentielles incluses avec Arduino. Il est peut-être temps maintenant de créer nos propres fonctions.

Chaque fonction doit commencer par le type de variable auquel elle peut être associée. Par exemple la fonction annuler fait référence à un type qui ne renvoie rien d'où le nom void. Notez que nous avons déjà discuté d'une liste de variables dans nos sections précédentes, vous voudrez peut-être vous y référer.

Par conséquent, le nom de la fonction particulière obtient une parenthèse ouverte '(' suivi d'une liste de paramètres séparés par des virgules.

Chacun des paramètres acquiert son type avec un nom, et enfin une clôture ')' parenthèse.

Ces paramètres peuvent être appliqués au sein de la fonction sous forme de variables.

Voyons un exemple ci-dessous où nous développons une fonction appelée ourTone () conçu pour fusionner les Ton() avec retard() lignes, de sorte que la fonction cesse de revenir jusqu'à ce que la note ait fini de jouer le son.

Nous implémentons ces fonctions dans notre code précédent, et obtenons le programme ci-dessous, voir les dernières lignes:

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Les fonctions peuvent être extrêmement pratiques pour rendre un programme plus facile à comprendre.

Ce qui suit est un exemple où nous pouvons spécifier le choix du son que nous voulons jouer en utilisant deux tableaux. Un tableau pour conserver les notes, l'autre pour conserver les temps.

#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i if (notes[i] == 0) {
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Vous pouvez voir clairement sur la première ligne l'introduction de #comprendre déclaration. Le travail de cette instruction est de ramasser le fichier entier entre les guillemets et de le placer à la position du #comprendre déclaration. Conformément aux règles standard, celles-ci sont strictement placées au début du programme.

Chapitre 5

Mesure de la température

Pour rappel, rappelez-vous qu'au lieu d'écrire de gros programmes, il est toujours sage d'écrire et d'analyser de petites parties de codes, ce qui permet de localiser rapidement les erreurs.

5.1 Moniteur série

Jusqu'à présent, les codes dont nous avons discuté ne semblent pas si faciles à permettre un dépannage rapide. Ici, nous allons essayer de faciliter la surveillance et de résoudre plus facilement un problème éventuel.

L'Arduino a une fonctionnalité qui lui permet de «répondre» avec l'ordinateur. Vous remarquerez peut-être que les broches 0 et 1 sont marquées comme RX et TX l'une à côté de l'autre. Ces broches sont en fait suivies par un IC séparé dans Arduino qui les met à niveau pour les lire à travers le câble USB lorsqu'il est branché sur le PC.

La section ci-dessous montre un programme à part entière, veuillez y aller, nous en apprendrons plus sur les nouvelles entrées dans le code par la suite. Ce code est le même que celui exprimé à la section 2.2 sauf le fait qu'il comprend des données supplémentaires pour nous permettre d'identifier ce pour quoi il a été codé.

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Vous pouvez identifier deux nouveautés ici, une nouvelle ligne dans le installer() fonction.

Serial.begin(9600)

Cette ligne exprime simplement la nécessité d'utiliser le Série1 code pour l'appliquer avec 9600 bauds. (ici la série fait référence à morceaux envoyé l'un après l'autre, et baud signifie la vitesse à laquelle il est envoyé). Cette valeur en bauds et celle à l'intérieur du moniteur série (nous l'apprendrons plus tard) doivent être égales, sinon les données du moniteur série afficheront des déchets. 9600 étant la norme devient plus pratique à utiliser.

La deuxième nouvelle entrée est la suivante

Serial.print('delayTime = ')
Serial.println(delayTime)

Ici, la deuxième ligne suggère que la chose suivante sortant du port série commencera sur la ligne suivante. Voilà comment la deuxième ligne est différente de la première ligne.

Une autre chose que vous pouvez voir sont les guillemets ('). Ceci est connu comme une chaîne, qui ne sera utilisée que comme des constantes ici, car une discussion plus approfondie sur ce sujet peut être trop élaborée et hors de portée.

OK, nous pouvons maintenant télécharger le code ci-dessus dans Arduino et voir ce qui se passe.

Quoi, oups, rien ne semble s'être passé, la LED de la broche Arduino # 13 a clignoté et s'est arrêtée, tandis que la LED Tx est restée clignotante.

Eh bien, c'est parce que la fenêtre Serial Monitor n'est pas encore fixe.

Vous devez cliquer sur la case Serial Monitor dans votre IDE comme indiqué ci-dessus. N'oubliez pas de vérifier le débit en bauds situé en bas à droite, par défaut il doit être de 9600 et correspondra au code. Si ce n'est pas le cas, assurez-vous de sélectionner 9600.

Le clip vidéo suivant explique comment procéder.

Maintenant, allons de l'avant et apprenons comment la fonction de surveillance série ci-dessus peut aider à traiter le mesure de la température à l'aide d'Arduino

Nous utiliserons l'IC TMP36 comme capteur de température, avec une plage de -40 à 150 degrés Celsius.

La configuration peut être vue ci-dessous:

Le code suivant lancera la mesure de la température en lisant la sortie du capteur TMP36 et en les envoyant au moniteur série de l'ID.

const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Comprenons le code par le haut.

float temperatureC = getTemperatureC()

Ici vous pouvez voir que nous avons inclus le type de variable flotter.

C'est le seul type de variable qui permet de stocker tout sauf les nombres entiers (nombres sans partie décimale ou fractionnaire).

La précision d'une variable flottante peut aller jusqu'à 6 à 7 chiffres.

Le code adjacent getTemperatureC() est notre propre fonction qui calcule et convertit mathématiquement la différence de tension détectée par le capteur TMP36 en degrés Celsius.

float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}

Dans la section suivante des codes, puisque le terme analogIn() est assigné pour renvoyer un chiffre entre 1 et 1023, il nous devient possible d'évaluer la tension du capteur en multipliant notre lecture par 5 puis en la divisant par 1024.

Le capteur TMP36 est spécifié pour générer 0,5 V à 0 degré Celsius, puis génère 10 mV pour chaque augmentation de degré Celsius.

Voici l'approximation que nous sommes en mesure de générer grâce aux calculs:

Vous pouvez considérer comme votre première fonction qui retourne une valeur (notez que toutes les fonctions restantes jusqu'à présent n'ont renvoyé aucune valeur puisqu'elles sont du type annuler ).

Vous pouvez comprendre que pour obtenir une valeur d'une fonction, il vous suffit d'ajouter revenir suivi du numéro que vous souhaitez renvoyer.

Quand on dit revenir cela signifie que la fonction renvoie une réponse ou une réponse à chaque fois qu'elle est appelée, qui pourrait être appliquée à une variable.

Lorsqu'il est envoyé au moniteur série, la lecture est convertie en Fahrenheit via convertToF ().

float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Cette fonction prend la plage Celsius et la convertit en Fahrenheit.

Pour convertir Fahrenheit en Celsius, nous implémentons la formule Fahrenheit = 9 / 5 (Celsius) + 32.

5.3 Interfaçage d'un écran LCD

Voyons maintenant comment interfacer ou connecter un affichage LCD avec Arduino pour obtenir un affichage visuel des sorties requises.

Dans notre application, nous allons utiliser un écran LCD graphique de 84x48, ayant une résolution horizontale de 84 pixels ou points et une résolution verticale de 48 pixels. Puisqu'un contrôleur dédié devient impératif pour tous les LCD, le présent dispositif en incorpore également un sous la forme d'un contrôleur PCD8544.

Dans ce didacticiel, nous allons connecter le module LCD spécifié ci-dessus avec Arduino et appliquer certaines routines pour créer des messages texte sur l'écran.

Dans la figure suivante, vous pouvez trouver des détails concernant l'interface de l'écran LCD, ainsi qu'un petit Régulateur de tension 3.3V . Ce régulateur est nécessaire car l'écran LCD est spécifié pour fonctionner avec une alimentation de 3,3 V.

Vous pouvez également voir 8 brochage du module LCD, les spécifications de brochage peuvent être étudiées à partir du tableau suivant:

Voyons maintenant comment nous pouvons connecter l'écran LCD et les paramètres pertinents avec notre Arduino. Les détails peuvent être visualisés dans l'illustration ci-dessous:

5.4 Communication avec l'écran LCD

Bien qu'il soit possible d'écrire des étudiantes élaborées pour interagir avec l'écran LCD d'Arduino, nous allons plutôt apprendre à faire de même en utilisant des bibliothèques.

Les bibliothèques comprennent un assortiment de codes qui peuvent être rapidement appliqués pour un programme Arduino sélectionné.

Cela permet à l'utilisateur d'appeler une fonction sans effort sans avoir à passer par un travail de codage complexe.

5.4.1 Comment installer la bibliothèque

Pour cela, vous devrez créer un répertoire appelé bibliothèques dans votre ordinateur Arduino IDE, comme expliqué ici

5.4.2 Implémentation des opérations LCD

Tout comme notre approche précédente, nous allons d'abord vérifier l'ensemble du code, puis essayer de comprendre les détails des lignes individuelles.

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

La ligne comprend le code #include

Le code #include demande au PC de récupérer le fichier mentionné et de remplacer l'élément #include par le contenu du fichier au cours de la compilation du programme.

L'élément #include peut posséder des crochets angulaires qui indiquent une recherche dans le répertoire de la bibliothèque, ou il peut également posséder des guillemets qui indiquent une recherche dans le même répertoire dans lequel le programme est situé.

Les lignes de code suivantes expriment les broches LCD, puis nous écrivons une nouvelle forme de variable:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Ici, nous exprimons une variable avec le nom lcd de type PCD8544 et demandons au PC de recadrer ses broches associées à l'Arduino.

Dans ce processus, nous décrivons la variable au PC en indiquant comment les broches clk, din, dc et reset sont interfacées avec l'Arduino.

void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}

La ligne lcd.init() initialise le fonctionnement de l'écran LCD. Une fois que ceci est exécuté, la ligne suivante impose un curseur en haut à gauche de l'écran. Et la ligne suivante suivante fait un effort pour imprimer le message «Hello, World».

Cela semble tout à fait identique à la technique dans laquelle nous avons envoyé des messages sur le moniteur série. La seule différence étant l'utilisation du code lcd.print au lieu de serial.print.

Le bloc de code suivant est en fait appelé de manière répétitive.

void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

En utilisant cette ligne lcd.setCursor(0,1) nous fixons le curseur sur la 0ème colonne à l'extrême gauche de la 1ère ligne, sur l'écran LCD.

La ligne suivante utilise un raccourci: lcd.print(millis())

Si vous vous souvenez, nous avons travaillé avec millis() dans nos codes précédents, nous aurions pu appliquer la même chose ici aussi à travers les codes:

long numMillis = millis()
lcd.print(numMillis)

Cependant, étant donné qu'ici aucune période de temps en millisecondes n'est impliquée, nous l'accomplissons simplement en envoyant millis() fonction directement vers lcd.print() .

5.5 Combiner le tout

OK, combinons maintenant tous les codes que nous avons appris ci-dessus pour créer le circuit de température LCD, et voyons à quoi il ressemble:

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
const int kPin_Temp = A0
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(10,0)
lcd.print('Temperature:')
}
void loop()
{
float temperatureC = getTemperatureC()
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
lcd.setCursor(21,1)
lcd.print(temperatureC)
lcd.print(' C')
lcd.setCursor(21,2)
lcd.print(temperatureF)
lcd.print(' F')
delay(100)
}
float getTemperatureC()
{
int reading = analogRead(kPin_Temp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Tout semble standard dans le programme ci-dessus, sauf l'utilisation de la fonction setCursor () . Ceci est utilisé pour aligner le texte autant que possible autour du centre de l'affichage.

Génial! Et félicitations, vous venez de programmer votre propre petit indicateur de température LCD en utilisant Arduino.

Applications Arduino pratiques

Puisque, à ce stade, nous avons couvert en détail les différentes techniques de programmation, il est temps de les développer en les appliquant à quelques implémentations pratiques utiles.

Nous allons commencer par les capteurs et voir comment les capteurs peuvent être utilisés avec Arduino en exécutant quelques exemples de codes.

7.1 Introduction aux capteurs

Dans ce tutoriel, nous allons découvrir la grande variété de capteurs qui pourraient être utilisés avec Arduino. Ceux-ci peuvent inclure des appareils tels que le capteur de lumière LDR, le capteur à effet Hall magnétique, les capteurs d'inclinaison, le capteur de vibration, le capteur de pression, etc.

Nous allons commencer par l'interfaçage de capteur de lumière LDR avec Arduino, comme indiqué dans le schéma suivant:

Comme nous le savons tous, le LDR est un dispositif à résistance dépendant de la lumière dont la résistance dépend de l'intensité de l'incident ambiant à sa surface.

L'intensité de la lumière est inversement proportionnelle à la lecture de la résistance du LDR.

Ici, nous allons apprendre comment cette propriété peut être intégrée à Arduino pour exécuter une application utile:

Le code du programme complet peut être visualisé comme indiqué ci-dessous:

const int kPin_Photocell = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
int value = analogRead(kPin_Photocell)
Serial.print('Analog Reading = ')
Serial.print(value)
if(value <200){
Serial.println(' - Dark')
}else if(value <400){
Serial.println(' - Dim')
}
else if(value <600){
Serial.println(' - Light')
}
else if(value <800){
Serial.println(' - Bright')
}
else{
Serial.println(' - Very Bright')
}
delay(1000)
}

Tous les paramètres utilisés dans le code ont déjà été discutés dans notre cours que nous avons appris jusqu'à présent. Vous pouvez vérifier les lignes en vous référant aux sections pertinentes.

Les valeurs ont été choisies au hasard, vous pouvez facilement changer selon vos propres préférences.

Capteur d'inclinaison

Un capteur d'inclinaison est un dispositif simple qui peut être utilisé pour détecter une action d'inclinaison sur n'importe quel objet où il est installé. Le dispositif a essentiellement une bille métallique à l'intérieur, qui, lors de l'inclinaison, roule sur une paire de contacts provoquant une conduction à travers ces contacts. Ces contacts se terminant comme les conducteurs du commutateur d'inclinaison, sont utilisés avec un circuit externe pour détecter la conduction due à une action d'inclinaison et activer l'application de sortie souhaitée.

Voyons maintenant comment un capteur d'inclinaison l'appareil pourrait être câblé. L'image ci-dessous nous donne une idée de la configuration complète:

const int kPin_Tilt = 3
const int kPin_LED = 13
void setup()
{
pinMode(kPin_Tilt, INPUT)
digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor
pinMode(kPin_LED, OUTPUT)
}
void loop()
{
if(digitalRead(kPin_Tilt) == HIGH){
digitalWrite(kPin_LED, LOW)
}
else{
digitalWrite(kPin_LED, HIGH)
}
}

Dans cet exemple, la LED de la broche # 13 par défaut est utilisée comme indicateur d'inclinaison.

Vous pouvez clairement voir l'inclusion de la résistance pull-up ici, assez similaire à ce que nous avons fait dans la section 3.1. Par conséquent, le terme BAS indique que la fonction d'inclinaison n'est pas déclenchée.

7.4 Relais de commutateur Reed (relais activé par aimant miniature)

Voyons maintenant comment connecter un commutateur de relais ou un capteur de champ magnétique avec Arduino. Un relais Reed est une sorte d'interrupteur qui s'active ou se conduit lorsqu'un champ magnétique ou un aimant est amené à proximité. Fondamentalement, il a une paire de contacts ferromagnétiques à l'intérieur d'une enceinte en verre miniature qui se rejoignent ou établissent un contact en raison de la traction magnétique chaque fois qu'un magnétique est à proximité. Lorsque cela se produit, les bornes des contacts montrent une conduction due à la fermeture des contacts.

Ici aussi, nous utilisons la LED de la broche # 13 pour indiquer la réponse. Vous pouvez connecter une LED externe à partir de cette broche si nécessaire, selon nos explications précédentes.

const int kPinReedSwitch = 2
const int kPinLed = 13
void setup()
pinMode(kPinReedSwitch, INPUT)
digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinReedSwitch) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Les termes du code doivent être familiers et explicites.

7.5 Capteur de vibrations utilisant un transducteur piézo

Dans le prochain exemple de programme, nous verrons comment un transducteur piézo peut être utilisé comme capteur de vibration pour éclairer une LED via Arduino.

Un élément piézo est en fait un dispositif qui génère des vibrations ou des oscillations lorsqu'une fréquence est appliquée à ses bornes. Cependant, le même piezo pourrait être utilisé dans le processus inverse pour générer des impulsions électriques en réponse aux vibrations appliquées sur son corps. Cette vibration peut prendre la forme d'un coup ou d'un coup sur la surface du piézo.

Configurez l'Arduino et un élément piézo comme indiqué dans la figure suivante

const int kPinSensor = A5
const int kPinLed = 13
const int k_threshold = 100
int ledState = LOW // variable used to store the last LED status, to toggle the light
void setup()
{
pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT
}
void loop()
{
int val = analogRead(kPinSensor)
if (val >= k_threshold) {
ledState = !ledState // toggle the value of ledState
digitalWrite(kPinLed, ledState)
delay(20) // for debouncing
}
}

Le seuil 100 est introduit juste pour s'assurer que l'Arduino ne répond qu'aux vibrations authentiques par des coups, et non à d'autres vibrations plus petites telles que des sons forts ou des klaxons.

La sélection de la broche A5 n'est pas obligatoire, vous pouvez sélectionner toute autre entrée analogique selon votre préférence et en la faisant correspondre dans le code du programme.

Utilisation d'un servomoteur avec Arduino

Un servomoteur est un type de moteur à courant continu qui peut être tourné à des angles précis selon la demande d'une application particulière. Cela peut être fait en appliquant une commande calculée aux entrées pertinentes du moteur pour produire un angle de rotation ou de rotation précis dans une plage de 180 degrés sur le moteur.

Généralement, un servomoteur a 3 fils ou entrées. Les fils positifs sont normalement de couleur rouge, le fil négatif ou de masse est noir, le fil de commande ou le fil de signalisation étant normalement de couleur blanche ou jaune.

Arduino facilite le contrôle des servomoteurs grâce à un langage de support intégré qui rend le contrôle très pratique et idéal pour les servomoteurs.

L'exemple suivant nous montrera le programme de configuration de base pour la mise en œuvre du contrôle de servomoteur via Arduino:

Le code est donné ci-dessous:

#include
Servo servo1
const int kPinPot = A0
const int kPinServo1 = 9
void setup()
{
servo1.attach(kPinServo1)
}
void loop()
{
int val = analogRead(kPinPot)
val = map(val, 0, 1023, 0, 180)
servo1.write(val)
delay(15)
}

Nous pouvons voir quelques nouvelles entrées ici. Celui qui indique au fil attaché du servo à quelle broche il est affecté. L'autre est le code qui fournit à la broche une valeur comprise entre 0 et 180, pour déterminer l'angle de rotation sur le servo.

Conclusion

Le sujet Arduino peut être infiniment long, et donc sortir du cadre de cet article. Cependant, j'espère que le tutoriel ci-dessus devrait certainement vous avoir aidé à apprendre les bases mêmes d'Arduino et à comprendre les paramètres importants à travers les différents exemples de codes d'application.

Nous espérons que plus d'informations pourront être mises à jour de temps en temps ici, chaque fois qu'elles sont disponibles.

En attendant, profitez de votre cours de programmation, Happy Arduinoing à vous !!