Nous continuons la série d'articles sur l'utilisation des capacités du kit Digital Lab NR05 pour étudier la programmation des microcontrôleurs en utilisant l'exemple d'Arduino et la conception de dispositifs électroniques utiles.
Notre matériel ne prétend pas être un design fini, mais, comme vous le verrez, il remplit pleinement toutes les fonctions de base d'un verrou de code et peut servir de bonne illustration des capacités des microcontrôleurs et de l'utilisation de plug-ins externes. Le programme du microcontrôleur peut être refait à votre discrétion, en ajoutant ou en modifiant les fonctions de la serrure, tout en augmentant le niveau de vos connaissances en programmation.Nous utiliserons tout d'abord le fait que la carte d'extension, qui fait partie de l'ensemble, dispose d'un affichage à cristaux liquides à deux lignes, ainsi que de 5 boutons. Nous utilisons ces éléments pour construire une serrure à combinaison.Faisons les exigences suivantes:1. Il y a 5 boutons pour entrer le code qui ouvre la serrure;2. Le bouton le plus à gauche correspond au code 1, puis de gauche à droite - 2,3,4,5;3. Le nombre de chiffres du code d'entrée peut être n'importe lequel (dans des limites raisonnables) et simplement installé dans le programme;4. Le code composé s'affiche avec des astérisques;5. Si le code saisi coïncide avec l'exemple, une impulsion positive de la durée spécifiée dans le programme est fournie à l'actionneur;6. Si le code n'est pas entré correctement, un message d'erreur apparaît;7. Si vous tapez partiellement le code, les valeurs composées sont réinitialisées après un certain temps.8. Nous utilisons l'écran, la LED RVB et l'émetteur sonore inclus dans le kit pour afficher des informations conviviales.9. Nous ouvrirons une véritable serrure électromécanique alimentée en 12 volts.Maintenant, nous prenons l'appareil qui appliquera la tension d'ouverture à la serrure. Cette tension, conformément au passeport de la serrure électromécanique, que nous allons ouvrir, est de 12 volts à un courant d'environ 1 ampère. La carte d'extension du kit NR05 ne peut pas fonctionner avec de telles tensions et courants, un module de commutation supplémentaire est donc nécessaire. Ces modules peuvent être des relais MP515 proposés par Master Kit ou des unités de relais MP2211 , MP4411selon que nous voulons contrôler non seulement la serrure, mais aussi d'autres appareils, par exemple, allumer la lumière lorsque la porte est ouverte. Tous ces appareils sont compatibles avec les niveaux de signal de contrôle Arduino. Dans notre cas particulier, nous utilisons MP2211 - un module avec deux relais.Compte tenu de ce qui précède, nous allons dessiner un schéma de connexion des appareils utilisés:
Si vous regardez attentivement le marquage de la carte d'extension, nous verrons que le canal vert de la LED RGB verte et la sortie vers le relais CH3 sont connectés à une broche du D9 Arduino Nano. Dans ce cas, cela est autorisé, car l'entrée du circuit de commande de relais a une résistance d'entrée suffisamment élevée et la broche D9 est utilisée uniquement comme sortie numérique. En général, vous devriez vérifier si les broches de la carte que vous utilisez sont connectées à la même broche Arduino et éviter cette situation.La serrure consomme beaucoup de courant pendant son fonctionnement, nous l'alimentons ainsi que le circuit de commande séparément.Voici un croquis travaillant en Arduino, un spoiler// RGB-
// NR05
//-------------------------------------------------------------------
// LiquidCrystalRus
#include <LiquidCrystalRus.h>
#include <LineDriver.h>
#include <LiquidCrystalExt.h>
// RGB-
#define red 5
#define blue 6
#define green 9
#define beep 12
// ,
#define NUM_KEYS 5
// ( )
int adcKeyVal[NUM_KEYS] = {30, 150, 360, 535, 760};
///////////////////////////////////////////////////////////
// ,
#define codeLength 6
// , , . codeLength
const int codeOrigin[codeLength] = {1, 2, 3, 4, 5, 3};
// ,
const int unlockTime = 400;
///////////////////////////////////////////////////////////
//
int codePressed[codeLength];
// ( )
int pressCount;
//
unsigned long oldTime;
unsigned long currentTime;
const int timeout = 5; // , .
//-----------------------------------------------------------------------
// , RS,EN,DB4,DB5,DB6,DB7
LiquidCrystalRus lcd(A1, A2, A3, 2, 4, 7);
//-----------------------------------------------------------------------
// 1 Arduino
void setup()
{
// LCD: 16 2
lcd.begin(16, 2);
// ()
// « »
lcd.print(« »);
//
lcd.setCursor(0,1);
lcd.print(«t.: „);
lcd.print(unlockTime);
lcd.print(“ »);
// 2000 = 2
delay(2000);
//
lcd.clear();
//
pressCount = 0;
// « » RGB-
pinMode(red, OUTPUT);
pinMode(blue, OUTPUT);
pinMode(green, OUTPUT);
pinMode(beep, OUTPUT);
}
//-----------------------------------------------------------------------
// setup .
void loop() {
// ( ),
currentTime = millis();
// ,
if (currentTime — oldTime <= timeout*1000){
// key
int key;
// , get_key
key = get_key();
lcd.setCursor(0, 0);
lcd.print(« :»);
//
digitalWrite(blue, HIGH);
if (key > 0){ //
codePressed[pressCount] = key; //
// (50 )
digitalWrite(beep, HIGH);
delay(50);
digitalWrite(beep, LOW);
// ,
lcd.setCursor(pressCount, 1);
lcd.print('*');
digitalWrite(blue, LOW);
delay(200);
digitalWrite(blue, HIGH);
pressCount++; //
//
oldTime = currentTime;
}
}
// ,
else{
pressCount = 0;
lcd.clear();
oldTime = currentTime;
}
// , : codeOrigin codePressed
if (pressCount == codeLength){
int compareResult = 1;
for (int i = 0; i < codeLength; i++)
if (codeOrigin[i] != codePressed[i])
compareResult = 0; //
//
if (compareResult == 1){ //
digitalWrite(blue, LOW);
digitalWrite(green, HIGH);
lcd.setCursor(0, 0);
lcd.print(« „);
delay(unlockTime);
digitalWrite(green, LOW);
pressCount = 0;
delay(1000);
lcd.clear();
digitalWrite(blue, HIGH);
}
//
else {
lcd.setCursor(0, 1);
lcd.print(“ »);
digitalWrite(blue, LOW);
digitalWrite(red, HIGH);
digitalWrite(beep, HIGH);
delay(2000);
pressCount = 0;
lcd.clear();
digitalWrite(beep, LOW);
digitalWrite(blue, HIGH);
digitalWrite(red, LOW);
}
}
}
//-----------------------------------------------------------------------
//
// ,
// ,
int get_key()
{
int input = analogRead(A6);
int k;
for(k = 0; k < NUM_KEYS; k++)
if(input < adcKeyVal[k])
return k + 1;
return 0;
}
//
La liste des croquis est fournie avec des commentaires détaillés pour vous aider à comprendre le programme.Néanmoins, nous attirons votre attention sur certaines de ses fonctionnalités.Comme nous l'avons déjà écrit, dans la carte d'extension, un schéma de connexion de bouton est utilisé qui n'utilise qu'une seule broche Arduino. Un tel schéma permet d'économiser les sorties du microprocesseur, mais ne permet pas de traiter la pression simultanée de plusieurs boutons en même temps, mais dans notre cas ce n'est pas nécessaire. Remarquez la fonction get_key à la fin de l'esquisse. Si aucun bouton n'est enfoncé, la fonction renvoie 0, si elle est enfoncée, puis le numéro du bouton enfoncé.Regardez également l'implémentation de la comparaison de deux tableaux: codes de référence et typés:int compareResult = 1;for (int i = 0; i <codeLength; i ++)if (codeOrigin [i]! = codePressed [i])compareResult = 0; // si au moins une paire d'éléments n'est pas égale Laquestion de l'algorithme pour une telle comparaison est souvent discutée dans les forums de programmation, mais à chaque fois il s'agit d'une comparaison élément par élément, qui est utilisée dans notre cas. La variable compareResult reste égale à 1 si les éléments des tableaux avec le même indice sont égaux et devient égale à 0 si au moins une paire d'éléments ne correspond pas.Pour afficher les caractères cyrilliques, la bibliothèque LiquidCrystalRus, développée par Ilya Danilov, est utilisée. Pour que la bibliothèque fonctionne correctement, le titre de notre esquisse doit comporter trois lignes:#include <LiquidCrystalRus.h>#include <LineDriver.h>#include <LiquidCrystalExt.h>Et l'initialisation de l'affichage devrait ressembler à ceci:LiquidCrystalRus lcd (A1, A2, A3, 2, 4, 7);La longueur du code d'entrée est spécifiée par la constante de longueur de code prédéfinie, par exemple, pour un code en six clics#define codeLength 6Un tableau de valeurs de référence pour un code en 6 clics est spécifié par la ligne suivante:const int codeOrigin [codeLength] = {1, 2, 3, 4, 5, 3} ;Le nombre de valeurs entre accolades doit être égal à codeLength. S'il y a plus de valeurs, le compilateur lancera une erreur; s'il y en a moins, il n'y aura pas d'erreur, mais des valeurs aléatoires seront utilisées comme éléments manquants, ce qui ne permettra pas de taper du code qui ouvrira le verrou.Toutes les 5 secondes, le programme réinitialise les éléments de code saisis. Si le bouton a été enfoncé, le temps de pression est mémorisé et le compte à rebours de l'intervalle de cinq secondes recommence. Ceci est implémenté à l'aide des fonctions intégrées millis (), qui retourne le nombre de millisecondes qui se sont écoulées depuis le début de l'esquisse, et les variables oldTime et currentTime.Voici une courte vidéo montrant le fonctionnement du verrouillage de code:Pour les programmeurs électroniques curieux et curieux, vous pouvez jeter quelques idées supplémentaires pour l'auto-finalisation du croquis et l'inclusion de modules dans le circuit qui étendent les capacités du château. Par exemple, entrez un code maître dans le programme, à l'aide duquel le verrou est mis en mode programmation et se souvient des boutons enfoncés comme code de référence, afin de ne pas changer ce code dans l'esquisse. La programmation d'un nouveau code se termine si l'intervalle entre les clics dépasse un certain temps.Ou, sur la base de matériel sur l'interaction d'Arduino avec un smartphone via Bluetooth, créez un verrou qui s'ouvre avec un code envoyé par ce même smartphone.Vous pouvez également simplement entrer le canal de contrôle sans fil dans notre appareil. Pour ce faire, il suffit d'utiliser deux modules: l'émetteur-émetteur MP910 et un récepteur monocanal avec sortie relais MP911 , fonctionnant à une fréquence de 433 MHz. Les contacts de relais du module MP2211 sont connectés en parallèle avec le bouton de la télécommande et le relais du module récepteur est connecté à la serrure. La distance de contrôle peut aller jusqu'à 100 m.Étudiez Arduino, étudiez les microcontrôleurs et leur programmation - et vous pouvez créer de nombreux appareils électroniques intelligents et utiles!