Arduino intermédiaire : Entrées et sorties (1 / 9 étapes)

Étape 1: Blink sans Delay()

Jusqu'à présent, que nous avons utilisé la fonction delay() pour suspendre le sketch Arduino momentanément alors qu’un peu de temps peut passer entre deux commandes Arduino. Dans l’esquisse de clignotement de LED, nous avons utilisé delay() pour définir la quantité de temps qu'a été envahie de l’Arduino et la quantité de temps, qu'elle a été désactivée :

digitalWrite (ledPin, HIGH); //turn LED sur
Delay(1000); / / attente de 1000 millisecondes (1 seconde)
digitalWrite (ledPin, LOW); //turn LED éteint
retard (1000); //wait une seconde

Parfois à l’aide de delay() n’est pas une bonne option car l’Arduino ne peut pas effectuer toutes les tâches secondaires, tandis que le retard qui se passe. Imaginons que nous voulions à clignoter une LED et détecter une touche à la fois à l’aide de delay() :

Loop() {}

digitalWrite (ledPin, HIGH) ;
Delay(1000) ;
digitalWrite (ledPin, basse) ;
Delay(1000) ;
buttonState booléen = digitalRead(7) ;

}

Dans le code ci-dessus, nous seulement mesurons le bouton une fois toutes les deux secondes, donc il peut prendre jusqu'à deux secondes avant un bouton est détecté, et presses très brèves ne peuvent pas jamais pas détectées du tout.

Millis() nous donne le contrôle quand les événements se produisent sans mettre des pauses dans le sketch. Chaque fois que nous appelons millis() dans une esquisse de l’Arduino, il retourne le nombre de millisecondes depuis l’Arduino a été mise en marche.

Exécutez le code suivant pour voir comment fonctionne la millis() :

Voici comment utiliser millis() à clignoter une LED sans utiliser delay().

Le croquis ci-dessus introduit quelques nouveautés :

unsigned long est un autre type de données (jusqu'à présent nous avons vu int et booléen). Unsigned long est comme int, mais plus grande, je vais vous expliquer... Chaque type de données requiert une certaine quantité d’espace dans la mémoire de l’Arduino, et la quantité d’espace qui libère de l’Arduino pour une variable donnée dicte les valeurs minimale et maximale que peut stocker la variable. Par exemple, int peut varier de-32 768 à 32 767, si vous avez essayé de faire quelque chose comme ceci :

int mavariable = 100 000 ;

Vous finiriez avec un bug très étrange dans votre code. Cela peut sembler une gamme arbitraire, mais il vient du fait qu’int nécessite de l’espace dans la mémoire de l’Arduino 16 bits et 16 bits binaires, vous pouvez stocker des nombres de 0 à (2 ^ 16 - 1) = 65535. Mais les gens ont décidé qu’int devrait être en mesure de stocker des nombres négatifs trop, alors un des bits du nombre 16 bits est utilisé pour stocker le signe (positif ou négatif) et les bits restants 15 stocker la valeur: 2 ^ 15 = 32768. Y compris 0, nous nous retrouvons avec la gamme de-32 768 à 32 767. Un autre type de données appelé int reçu ne stocke pas signe, il obtient la plage de 0 à 65535 que j’ai calculé avant, mais vous ne pouvez pas stocker un nombre négatif dans une int reçu.

Lorsque nous avons besoin d’utiliser des nombres supérieurs à 65535 ou moins de -32768, nous utilisons un type de données appelé long. Long 32 bits d’espace dans la mémoire de l’Arduino sont alloués. 2 ^ 32 = 4294967296, ce centre autour de zéro pour obtenir une gamme de :-2,147,483,648 à 2 147 483 647. Unsigned long a, comme unsigned int est toujours positif, donc ils comprise entre 0 et 4 294 967 295.

Il n’y a aucun plus grand type de données pour stocker des nombres plus long, donc si vous avez besoin de stocker un nombre supérieur à 4 294 967 295, vous devrez venir avec une autre façon de ranger (peut-être les premiers bits 9 un numéro et les neuf derniers dans un autre?). Cette limitation a des conséquences intéressantes pour la fonction millis(). Millis retourne longs non signés, et c’est compter sans cesse en millisecondes, millis() se réinitialise en fait retour à zéro une fois il atteint :

4294967295 ms

= 4 294, 967seconds

= jours 49.71

Si vous utilisez millis() et que vous envisagez de maintien que vous du projet en cours d’exécution pendant de longues périodes de temps sans jamais l’éteindre ou de recommencer, vous devriez être conscient de cela.

Un commentaire de plus sur les types de données : nous pourrions ont utilisé de long ou unsigned long tout ce temps quand nous déclarons NIP ou autres variables dans les esquisses d’exemple jusqu'à présent, mais généralement c’est une bonne idée d’utiliser les données plus petites de type possibles pour une variable, vous avez beaucoup d’espace supplémentaire dans la mémoire de l’Arduino pour d’autres choses comme ça. Dans l’Arduino, longs sont rarement utilisés, mais millis() est un bon exemple de quand ils viennent maniable.

Pour en revenir à l’esquisse, l’idée générale est de stocker la dernière fois vous activé/désactivé la LED allumé ou éteint et comparez cela à l’heure actuelle retournée par millis(). Une fois la différence entre ces deux fois supérieure à certains intervalles, vous le savez qu'il est temps d’activer/désactiver la LED à nouveau. Pour ce faire j’ai mis en place de nouvelles variables de stockage :

int ledState = faible ; //current état de la LED
unsigned long timeOfLastLedEvent = 0; //the dernière fois la LED a été mis à jour
int intervalON = 1000 ; //how long, nous voulons que la LED de rester sur
int intervalOFF = 500 ; //how long, nous voulons que la LED de rester hors de

Dans le loop() il y a un tas de logique qui vérifie pour voir si assez de temps a passé et dans l’affirmative, active/désactive la LED, met à jour la variable « timeOfLastLedEvent » et fait basculer l’État stockée de la LED. La logique est répétée deux fois, une fois pour le cas que la LED est haute et une fois pour le cas que la LED est faible, je vais répéter le faible cas ci-dessous :

Si (currentMillis - timeOfLastLedEvent > intervalOFF) {//and suffisamment de temps écoulé

digitalWrite (ledPin, HIGH); //turn sur
ledState = haut ; //store son état actuel
timeOfLastLedEvent = currentMillis ; //update le temps de ce nouvel événement

}

currentMillis est un unsigned long représentant l’heure actuelle qui est mis à jour chaque démarrage de fonction loop() de l’Arduino. (currentMillis - timeOfLastLedEvent) donne le sinus de temps état de la LED a été modifié, nous comparons cela contre l’intervalOFF pour voir si il est temps d’éteindre la LED, si ce n’est pas l’Arduino gardera mise à jour de currentMillis et re-vérifié jusqu'à ce qu’il est temps.