Désormais, pour terminer les travaux sur l'appareil, il vous suffit d'effectuer un certain nombre d'opérations simples :

La compilation du code du programme et son chargement ultérieur dans la mémoire du microcontrôleur prendront un certain temps, généralement pas plus d'une minute. La réussite de l'opération sera signalée dans la console Arduino IDE. Après quoi il ne reste plus qu'à redémarrer l'Arduino à l'aide du bouton Reset de l'appareil - une simple horloge sur matrices LED est prête !

Horloge prête sur Arduino

L'horloge est réglée à l'aide de deux boutons. L'appareil prend en charge les formats horaires 12 et 24 heures, affiche la date et le jour de la semaine et affiche l'heure avec ou sans secondes. Il est également possible de modifier la luminosité des LED.

Vous souhaiterez probablement ajouter plus de fonctionnalités à l'avenir (par exemple, un thermomètre) ou installer l'appareil dans un corps de votre propre conception - de bons résultats peuvent être obtenus en fabriquant sur des machines de découpe laser. Mais maintenant, vous pouvez dire en toute sécurité que vous avez assemblé de vos propres mains une montre électronique à part entière !

Ainsi, après une courte pause technique, nous poursuivons notre connaissance de la famille ARDUINO MK. Dans cette leçon, nous allons essayer de réaliser une horloge qui fonctionne à partir du générateur interne du MK (avec un générateur externe il y aura l'une des leçons suivantes) et affiche des informations sur l'indicateur LCD de type 1602 (ce qui signifie 16 caractères en 2 lignes, il existe aussi le type 1604 - 16 caractères sur 4 lignes, vous avez déjà compris que les 2 premiers chiffres indiquent le nombre de caractères indicateurs et les seconds indiquent le nombre de lignes). Ne retardons pas l'introduction, mettons-nous au travail.

Pour le projet nous aurons besoin de :

1. Arduino Uno
2. Indicateur LCD 1602
3. Planche à pain
4. Fils
5. Résistance ajustable 10 kOhm

Pour ceux qui sont particulièrement paresseux, je vous conseille d'aller en bas de page et de télécharger le croquis fini ; pour ceux qui veulent apprendre à réaliser des croquis par eux-mêmes, je décrirai plus en détail toutes les étapes du projet . Pour travailler correctement et rapidement sur un projet, un algorithme de travail est nécessaire. Il est préférable d’esquisser presque n’importe quel projet sur papier, puis de suivre l’algorithme étape par étape. Nous ferons exactement la même chose. Créons donc un algorithme. Nous avons plusieurs conditions, écrivons-les par ordre croissant :

1. Les secondes fonctionnent dans la plage de 0 à 59 dans un cycle avec un intervalle de secondes (cela est compréhensible).
2. Les minutes fonctionnent dans la plage de 0 à 59 dans un cycle, la commutation se produit lorsque la valeur des secondes atteint 0.
3. L'horloge fonctionne dans la plage de 0 à 24 (ici, vous pouvez choisir de l'afficher dans un style étranger de 0 à 12 avec les valeurs AM et PM, selon votre préférence) dans un cycle, la commutation se produit lorsque la valeur des minutes atteint 0.
4. Afficher toutes les informations nécessaires sur l'écran (par exemple, vous pouvez décider de ne pas afficher les secondes mais simplement de faire un point clignotant entre les heures et les minutes)

Nous assemblons nos montres selon ce schéma :

Connexion de l'indicateur LCD 1602 à ARDUINO

Conseils de montage. L'indicateur 1602 provient généralement de Chine sous une forme « nue », c'est-à-dire aucune broche n'est soudée, je vous conseille d'utiliser à ces fins des prises d'ordinateur à double rangée de cartes mères, une broche de la prise est insérée dans 1602, la deuxième broche est derrière le bord de la carte, soudez les deux broches à une broche - ceci augmente la résistance mécanique et électrique. Ce schéma n'indique pas le schéma de connexion du rétroéclairage ; ce sont les 2 broches suivantes à droite de D7. Vous pouvez les connecter à l'alimentation 3,3 V de l'ARDUINO, vous pouvez effectuer un allumage/décoloration en douceur si vous connectez la broche positive (elle est étiquetée comme A-anode) à la sortie ARDUINO et contrôlez l'alimentation via cette broche, ceci est une tâche secondaire, pour l'instant connectez simplement la broche Et sur 1602 à 3,3V sur ARDUINO, et la broche K 1602 à GND ARDUINO.

Commençons maintenant à concevoir la montre. Nous lançons le shell ARDUINO sur l'ordinateur. Essayons de jouer avec 1602 pour vérifier les bonnes connexions du circuit. Allons-y Fichier-Exemples-LiqidCrystal et sélectionnez l'un des fichiers. Nous téléchargeons le croquis sur ARDUINO et regardons ce qui se passe. Si à la place des symboles vous voyez des carrés noirs, resserrez la résistance de trimmer, il s'agit d'un régulateur de contraste (faites de même si rien ne s'affiche du tout). Les informations doivent être affichées correctement et il ne doit tout simplement pas y avoir de « trucs fous ». S'ils apparaissent, vérifiez le schéma de connexion, où il a été mal assemblé. Vous pouvez immédiatement voir dans les croquis comment accéder à l'indicateur LCD et être étonné de la facilité de travailler avec lui ! Si tout fonctionne correctement pour vous, passons directement à la programmation.

Décidons que notre minuterie fonctionnera sans l'opérateur de retard comme indiqué. On rentre donc le code suivant :

#inclure

// Les variables changeront :

vide installation () {
lcd.begin(16, 2);

vide boucle ()
{

if (currentMillis - previousMillis >= intervalle) (

Ce code fonctionnera déjà mais n'affichera rien. 1 sera ajouté à la variable s chaque seconde. nous avons déjà obtenu l'intervalle exact de 1 seconde ! Maintenant, en suivant l'algorithme, nous avons besoin d'une limite de la variable entre 0 et 59. Faisons-le.

si(s>
{


}

Ajoutez ce code au programme. D'après la description, tout est clair - si la valeur de s est supérieure à 59, alors nous lui attribuons 0 et ajoutons 1 minute à la variable m. À l'heure actuelle, nous disposons d'une minuterie entièrement fonctionnelle et d'un compteur de minutes infini (jusqu'à 32 768 - la valeur maximale du type entier). Vous devez maintenant calculer les minutes de la même manière. Nous écrivons ce qui suit :

if (m>59) // si m les valeurs sont supérieures à 59
{


}

Ajoutez des lignes au programme. Cela devrait déjà ressembler à ceci :

int h, m, s ; // variables pour les heures, minutes, secondes
booléen z ; // variable pour afficher le point
// connecte la bibliothèque d'indicateurs
#inclure

// initialise la bibliothèque avec les numéros des broches de l'interface
Écran LCD LiquidCrystal (12, 11, 5, 4, 3, 2);

// Les variables changeront :
int ledState = FAIBLE ; // ledState utilisé pour définir la LED
non signé long précédentMillis = 0; // stockera la dernière fois que la LED a été mise à jour
intervalle long const = 1000 ; // intervalle auquel clignoter (millisecondes)

vide installation () {
lcd.begin(16, 2);

vide boucle ()
{

Courant long non signéMillis = millis();

if (currentMillis - previousMillis >= intervalle) (
// enregistre la dernière fois que vous avez clignoté la LED
précédentMillis = courantMillis;
s++; // en ajoute un, équivalent à écrire s=s+1;

// section de comptage des secondes

if (s>59) // si la valeur de s est supérieure à 59
{
s=0 ; // attribue la valeur 0 à la variable s
m++; // ajoute 1 à la variable m responsable des minutes
}

// section de comptage des minutes

si(m>
{
m = 0 ; // attribue la valeur 0 à la variable m
h++; // ajoute 1 à la variable h responsable de l'horloge
}

En principe, tout est clair. Il ne reste plus qu'à traiter l'horloge. Faisons-le. Nous ajoutons après la section de décompte des minutes :

si(h>
{

}

Ça y est, la montre est prête ! Remplissez le croquis et l'horloge fonctionnera comme il se doit ! J'attire votre attention sur le fait qu'ils compteront au format 24 heures. Essayez de créer vous-même un format de 12 heures. Il ne reste plus qu'à afficher les informations sur l'indicateur LCD. Il existe 2 façons d’écrire du code pour générer des informations.

1. Calculez certaines données et affichez-les immédiatement
2. Calculez toutes les données et affichez-les toutes en même temps.

À ce stade, vous déciderez vous-même du chemin que vous emprunterez. Si vous suivez le premier chemin, vous devez alors écrire l'affichage des informations immédiatement dans les sections de calcul, si vous suivez le deuxième chemin, vous écrivez un bloc après tous les calculs. Prenons la deuxième voie parce que... c'est plus préférable et plus logique (même si, pour être honnête, mon croquis de test a été écrit le long du premier chemin). Ainsi, pour transférer des données vers l'indicateur 1602, seules 2 commandes sont utilisées :

lcd.setCursor(3, 0); // définit le curseur sur le 3ème caractère de la 0ème ligne (le comptage des lignes et des caractères commence à 0)
lcd.print(0); // imprimer (imprimer- imprimer, apprendre l'anglais) 0

Il existe également la commande lcd.clear ; ce qui veut dire écran clair mais nous n'avons pas besoin de l'utiliser ici.

Nous commençons à afficher des informations. Commençons par les secondes (vous pouvez commencer avec n'importe quelle valeur, faites ce qui vous convient). Placez le curseur sur la ligne 0 en position 6 et affichez la valeur des secondes. Pourquoi en 6ème position demandez-vous ? Imaginons ce qui suit : le format d'affichage de l'horloge est de 2 caractères (heures), un séparateur (disons :), 2 caractères (minutes), un séparateur (:) et, enfin, des secondes. On compte à partir de la position zéro : 0+2+1+2+1=6. Puisque le comptage commence à 0, on soustrait un des données (zéro est aussi un nombre), on obtient 6-1=5. C'est le temps qu'il faut pour afficher les heures et les minutes avec des délimiteurs, la position suivante est la deuxième position et elle est égale à 5+1=6. Un peu déroutant mais j'écrirai ce qui suit hh:mm:ss et calculez les coordonnées en commençant par 0. C'est ainsi que les coordonnées sont calculées sur les indicateurs de la famille 16xx. Dans ces conditions, l'horloge sera affichée dans le coin supérieur gauche, vous pourrez modifier l'emplacement à votre guise, vous pourrez même saisir une variable et, en la sélectionnant, sélectionner la position d'affichage dont vous avez besoin. Bon, écrivons ces lignes :

lcd.setCursor(6, 0); // définit le curseur sur le 6ème caractère de la 0ème ligne (le comptage des lignes commence à 0)

Le programme ressemblera à ceci :

int h, m, s ; // variables pour les heures, minutes, secondes
booléen z ; // variable pour afficher le point
// connecte la bibliothèque d'indicateurs
#inclure

// initialise la bibliothèque avec les numéros des broches de l'interface
Écran LCD LiquidCrystal (12, 11, 5, 4, 3, 2);

// Les variables changeront :
int ledState = FAIBLE ; // ledState utilisé pour définir la LED
non signé long précédentMillis = 0; // stockera la dernière fois que la LED a été mise à jour
intervalle long const = 1000 ; // intervalle auquel clignoter (millisecondes)

vide installation () {
lcd.begin(16, 2);

vide boucle ()
{

Courant long non signéMillis = millis();

if (currentMillis - previousMillis >= intervalle) (
// enregistre la dernière fois que vous avez clignoté la LED
précédentMillis = courantMillis;
s++; // en ajoute un, équivalent à écrire s=s+1;

// section de comptage des secondes

if (s>59) // si la valeur de s est supérieure à 59
{
s=0 ; // attribue la valeur 0 à la variable s
m++; // ajoute 1 à la variable m responsable des minutes
}

// section de comptage des minutes

if (m>59) // si la valeur de m est supérieure à 59
{
m = 0 ; // attribue la valeur 0 à la variable m
h++; // ajoute 1 à la variable h responsable de l'horloge
}

// section de comptage des heures

if (h>23) // si la valeur de h est supérieure à 23
{
h = 0 ; // attribue la valeur 0 à la variable h
}

// section de sortie d'informations

lcd.setCursor(6, 0);
lcd.print(s); // affiche les données de la variable s

Remplissez le croquis et... les secondes ont commencé à apparaître !!! Faites juste attention, en comptant de 0 à 59, tout va bien, mais dès que la minute suivante commence, des dizaines de secondes commencent à changer au lieu d'unités de secondes, c'est-à-dire L'heure ne s'affiche pas correctement. Voyons cela. Nous avons donné au programme une position stricte 6,0 , et il affiche les données exactement à cette position sans écraser ce qui se trouve après cette position. Quittez 2. Appliquez lcd.clear ou décrivez correctement l'affichage, d'autant plus qu'avec la première option, il sera assez difficile de s'habituer aux chiffres sautants des secondes (plus tard les minutes et les heures). Écrivons un gestionnaire d'affichage correct. Quelles seront les conditions de ce traitement ? Pensons-y. Si les secondes sont inférieures à 10, alors on écrit leur valeur en 7ème position (6+1=7) et en 6ème position on écrit 0, si supérieure ou égale à 10, on écrit en 6ème position. C'est assez simple. La condition ressemblera à ceci :

si (s<10) //если секунд меньше 10
{

lcd.print(0); //imprimer 0


}
autre
{


}

Collez plutôt ce code

lcd.setCursor(6, 0); // définit le curseur sur le 7ème caractère de la 0ème ligne (le comptage des lignes commence à 0)
lcd.print(s); // affiche les données de la variable s

et nous sommes contents du résultat déjà obtenu ! Tout s'affiche correctement ! De plus, un séparateur « : » est apparu avant les secondes ! De la même manière, nous écrivons un gestionnaire pour les minutes et les heures avec les coordonnées du curseur correspondantes. Cela pourrait ressembler à ceci pendant quelques minutes :

Si (m<10)
{
lcd.setCursor(3, 0);
lcd.print(0);
lcd.setCursor(4, 0);
lcd.print(m);
}
autre
{
lcd.setCursor(3, 0);
lcd.print(m);
}

et ainsi de suite pendant des heures :

Si (h<10)
{
lcd.setCursor(0, 0);
lcd.print(0);
lcd.setCursor(1, 0);
lcd.print(h);
}
autre
{
lcd.setCursor(0, 0);
lcd.print(h);
}

Notre programme prendra la forme suivante :

int h, m, s ; // variables pour les heures, minutes, secondes
booléen z ; // variable pour afficher le point
// connecte la bibliothèque d'indicateurs
#inclure

// initialise la bibliothèque avec les numéros des broches de l'interface
Écran LCD LiquidCrystal (12, 11, 5, 4, 3, 2);

// Les variables changeront :
int ledState = FAIBLE ; // ledState utilisé pour définir la LED
non signé long précédentMillis = 0; // stockera la dernière fois que la LED a été mise à jour
intervalle long const = 1000 ; // intervalle auquel clignoter (millisecondes)

vide installation () {
lcd.begin(16, 2);

vide boucle ()
{

Courant long non signéMillis = millis();

if (currentMillis - previousMillis >= intervalle) (
// enregistre la dernière fois que vous avez clignoté la LED
précédentMillis = courantMillis;
s++; // en ajoute un, équivalent à écrire s=s+1;

// section de comptage des secondes

if (s>59) // si la valeur de s est supérieure à 59
{
s=0 ; // attribue la valeur 0 à la variable s
m++; // ajoute 1 à la variable m responsable des minutes
}

// section de comptage des minutes

if (m>59) // si la valeur de m est supérieure à 59
{
m = 0 ; // attribue la valeur 0 à la variable m
h++; // ajoute 1 à la variable h responsable de l'horloge
}

// section de comptage des heures

if (h>23) // si la valeur de h est supérieure à 23
{
h = 0 ; // attribue la valeur 0 à la variable h
}

// section de sortie d'informations

// secondes de sortie

si (s<10) //если секунд меньше 10
{
lcd.setCursor(6, 0); // curseur en position 6, ligne 0
lcd.print(0); //imprimer 0
lcd.setCursor(7, 0); //curseur en position 7 de la ligne 0
lcd.print(s); // affiche la valeur de la variable s
}
autre
{
lcd.setCursor(6, 0); //sinon le curseur est en 6ème position de la 0ème ligne
lcd.print(s); // affiche la valeur de la variable s
}
lcd.setCursor(5, 0); // curseur en position 5, ligne 0
lcd.print(':'); // affiche le séparateur entre les secondes et les minutes

// minutes de sortie

si (m<10)
{
lcd.setCursor(3, 0);
lcd.print(0);
lcd.setCursor(4, 0);
lcd.print(m);
}
autre
{
lcd.setCursor(3, 0);
lcd.print(m);
}
lcd.setCursor(2, 0); // curseur en position 2 de la ligne 0
lcd.print(':'); // affiche le séparateur entre les minutes et les heures

// horloge de sortie

si (h<10)
{
lcd.setCursor(0, 0);
lcd.print(0);
lcd.setCursor(1, 0);
lcd.print(h);
}
autre
{
lcd.setCursor(0, 0);
lcd.print(h);
}

L’intégralité du code tient dans un peu plus de 3 kilo-octets ! La plupart d'entre eux ont été consommés par la bibliothèque pour l'indicateur LCD. Précisons d'emblée que ce code n'est que le corps du programme, il faut également ajouter une fonction de réglage de l'heure. De plus, vous pouvez ajouter une photorésistance et éclaircir le rétroéclairage de l'écran. Vous pouvez ajouter une fonction d'entrée d'alarme et travailler avec le son. Vous pouvez également afficher la température ambiante, la date, etc... De manière générale, cet indicateur doté des capteurs appropriés peut faire de cette montre un appareil unique ! Le seul inconvénient de cet appareil est qu'en cas de panne de courant, vous devrez régler à nouveau l'horloge. Par conséquent, dans un avenir proche, je décrirai comment travailler avec le module RTC. Lorsque vous travaillez avec lui, même en cas de coupure de courant, lorsque la tension est appliquée, l'horloge fonctionnera comme si de rien n'était. Pour une version moins chère de l'horloge, vous pouvez utiliser arduino pro mini, c'est le même contrôleur qui n'a pas de connecteur USB mais coûte plusieurs fois moins cher et est de très petite taille. Vous pouvez également utiliser l'arduino nano, le même pro mais avec un connecteur USB. Jusqu'au prochain cours. Merci à tous pour votre attention.

PS*. À propos, la procédure d'affichage des valeurs peut être écrite comme une fonction distincte et lui transmettre les valeurs nécessaires. Essayez ceci et comparez la quantité de mémoire occupée. Visez toujours le plus petit volume possible.