Kodierte Tür

Wie im Schaltplan der Komponenten zu sehen ist, wurde ein 2-Zoll-TFT-Waveshare-Bildschirm verwendet, um sowohl die vier Zahlen anzuzeigen, die zum Öffnen des Tores gespeichert werden müssen, als auch die aktuelle Zahl mit einer größeren Größe, die durch die Interaktion des Encoders geändert wird, um die Zahl für jede Position auszuwählen, wird der Schalter verwendet, der in das KY-040-Drehgeber Modul integriert ist. Die roten und grünen LEDs werden zur Anzeige des Status des Gates verwendet. 330-Ohm-Widerstände müssen verwendet werden, um die Spannung der LEDs an die von den Mikrocontroller-Ports gelieferten 5 VDC anzupassen. Der Servomotor MG90S wird als Verriegelung verwendet, um das Tor geschlossen zu halten. Alle oben genannten Komponenten werden von einem AZ-ATmega328-Mikrocontroller gesteuert und das kleine MB102-Netzteil wurde für die Stromversorgung der gesamten Baugruppe gewählt.

 

Beschreibung der Funktionsweise des Projekts und Skizze

Die Funktionsweise dieses Projekts ist ähnlich wie bei den alten Tresoren, die eine nummerierte Scheibe hatten und bei denen der geheime Zahlenschlüssel eingegeben werden musste, um sie zu öffnen. Daher ist die Tür bei der Initialisierung des Projekts geschlossen und die rote LED leuchtet, um dies anzuzeigen. Um die Tür zu öffnen, muss der Encoder nach rechts oder links gedreht werden, bis die erste der vier Geheimzahlen (-10, 15, 5, -7), die zum Öffnen der Tür gewählt wurde, auf dem TFT-Bildschirm angezeigt wird, sobald die Zahl angezeigt wird, Drehen Sie den Encoder nach rechts, um die Zahl zu erhöhen, oder nach links, um die Zahl zu verringern, und wählen Sie die entsprechende Zahl mit dem Schalter aus. Wenn eine der vier ausgewählten Zahlen falsch ist, leuchtet die rote LED und die vier Zahlen werden aus dem Display gelöscht. Wenn die vier ausgewählten Zahlen richtig sind, leuchtet die grüne LED und der Servomotor ändert seine Position, um das Öffnen der Tür zu ermöglichen, die vier Zahlen werden ebenfalls aus dem Display gelöscht. Um die Tür zu schließen, geben Sie einfach vier andere Zahlen als die Geheimzahlen ein, der Servomotor ändert seine Position erneut, um die Tür zu verriegeln, und die rote LED leuchtet auf. Nachdem die Funktionsweise erklärt wurde, wird die Projektskizze analysiert.

Um den TFT-Bildschirm und den Servomotor richtig nutzen zu können, müssen die für jeden von ihnen erforderlichen Bibliotheken im Abschnitt zur Definition der globalen Variablen (am Anfang des Sketches) implementiert werden, da die zu verwendenden Methoden in diesen Bibliotheken definiert sind. Die erste Bibliothek, die hinzugefügt werden muss, ist SPI.h, diese Bibliothek ermöglicht die Kommunikation zwischen dem Mikrocontroller und SPI-Geräten, die zweite Bibliothek ist Adafruit_ST7789.h und enthält den Treiber für die Displays mit dem ST 7789-Controller-Chip, die dritte Bibliothek ist Adafruit_GFX.h, die die Haupt-Grafikbibliothek ist, sie stellt eine Reihe von Grafik-Primitiven (Punkte, Linien, Kreise, etc.) bereit. Die letzte implementierte Bibliothek ist Servo.h für den Mikrocontroller zur Steuerung von Servomotoren.

 

#include <SPI.h>

#include < Adafruit_ST7789.h>

#include < Adafruit_GFX.h>

#include <Servo.h>

 

 Nach dem Einbinden der Bibliotheken, einem Objekt aus der Adafruit_ST7789.h, um das TFT-Display verwenden zu können, sind die Parameter, die in dieser Implementierung enthalten sein müssen, der Mikrocontroller-Port, an dem der CS (SPI Chip select) Pin, DC (Data) Pin und RST (Reset) Pin des Displays angeschlossen sind, Um den Code klarer und sauberer zu machen, definiere zunächst Variablen mit den Namen der Display-Pins und als Wert den Mikrocontroller-Port, an den er angeschlossen ist, implementiere dann das Objekt tft_safe_box und füge die Namen der definierten Variablen ein.

 

#define cs   10

#define dc   9

#define rst  8

Adafruit_ST7789 tft_safe_box = Adafruit_ST7789 (cs, dc, rst);

 

Es werden auch Variablen definiert, die nach den Pins des KY-040 Drehgebermoduls benannt sind und deren Werte auch die Mikrocontroller-Ports sind, an die sie angeschlossen sind.

 

int CLK = 2;

int DT = 3;

int SW = 4;

 

Die nächsten beiden Zeilen der Skizze sind die Implementierung eines Objekts aus der Servomotor-Bibliothek und die Definition einer Variablen, die für den Positionswert der Servomotor-Bewegung verwendet wird, um das Öffnen der Tür zu ermöglichen und sie zu verankern, wenn man sie schließen will.

 

Servo servo_lock;

int servo_position = 10;

 

Für die beiden zu verwendenden LEDs werden Variablen definiert, die als Wert den Port des Mikrocontrollers haben, an den sie angeschlossen sind.

 

int green_led = 6;

int red_led = 5;

 

Nachdem die Objekte implementiert und die für die Verwendung der Module erforderlichen Variablen definiert wurden, werden die Variablen und ein Array definiert, die für die Anzeige der Zahlen auf dem TFT-Bildschirm und deren Speicherung erforderlich sind. Die erste zu definierende Variable ist letzte_Zahl und wird verwendet, um die aktuelle Zahl zu speichern, bevor der Geber gedreht wird, um die neue Zahl auf dem Bildschirm anzuzeigen. Die Variable aktuelle_Zahl wird definiert, um die Zahl zu speichern, die auf dem Display angezeigt wird, wenn der Encoder gedreht wird. Sie wird vom Typ flüchtig deklariert, um im RAM des Mikrocontrollers gespeichert zu werden, da ihr Wert von der Hardware-Interrupt-Service-Routine durch die Änderung des Signals am CLK-Pin des Encoders geändert wird. Die beiden oben genannten Variablen sind vom Typ int, da es sich bei den Zahlen um Ganzzahlen handeln wird.

 

int last_number = 0;

volatile int actual_number = 0;

 

 In den nächsten vier zu definierenden Variablen müssen die geheimen Zahlen, die mit den durch Drehen und Drücken des Geberschalters eingegebenen Zahlen verglichen werden sollen, wiedergegeben werden.

 

int first_secured_number = -10;

int second_secured_number = 15;

int third_secured_number = 5;

int fourth_secured_number = -7;

 

In den folgenden vier Variablen werden die Zahlen gespeichert, die durch Drehen und Drücken des Geberschalters ausgewählt werden. Die in diesen vier Variablen gespeicherten Zahlen sind diejenigen, die mit den vier in den vorherigen Variablen gespeicherten Zahlen gekauft werden.

 

int first_selected_number;

int second_selected_number;

int third_selected_number;

int fourth_selected_number;

 

Speichern Sie in der Variablen encoder_selected_number die Zahl, die auf dem Display erscheint, wenn der Drehgeberschalter gedrückt wird, und speichern Sie sie in den Zahlenvariablen zum Öffnen der Tür.

 

int encoder_selected_number;

 

Schließlich werden fünf Arrays definiert, um die Zeichen für die Zahlen zu speichern, die auf dem TFT-Bildschirm angezeigt werden sollen. TFT-Displays zeigen die von einem Sensor empfangenen Daten nicht direkt an, sondern diese Daten müssen in Zeichenketten umgewandelt werden, damit die Displays sie darstellen können.

 

char first_number[4];

char second_number[4];

char third_number[4];

char fourth_number[4];

char encoder_number[4];

 

Mit der Definition der fünf vorangegangenen Arrays ist der Variablendefinitionsblock abgeschlossen, so dass der nächste Schritt darin besteht, den anfänglichen Konfigurationsblock der Module zu analysieren, wenn die Spannung angeschlossen oder der Mikrocontroller initialisiert wird. Dies ist der Block setup() und das erste, was getan werden muss, ist die Initialisierung des seriellen Monitors.

 

Serial.begin(9600);

 

Um die LEDs zu verwenden, müssen Sie die Mikrocontroller-Ports, an die die LEDs angeschlossen sind, als Ausgang konfigurieren, um Spannung zu senden, dies geschieht mit dem Befehl pinMode(pin ,MODE). Der Anfangszustand jeder LED muss ebenfalls konfiguriert werden, da das Gate geschlossen sein muss, muss die rote LED an sein, also muss der Port high sein, um Spannung zu liefern, während die grüne LED aus sein muss, dies wird mit dem Befehl digitalWrite(pin, value) gemacht. Die vier Zeilen des Sketches, die diese Aktionen ausführen, sind:

 

pinMode(green_led,OUTPUT);

pinMode(red_led,OUTPUT);

digitalWrite(red_led,HIGH);

digitalWrite(green_led,LOW);

 

Die nächste Komponente, die konfiguriert werden muss, ist der Servomotor. Dazu muss man mit servo_name.attach(pin) den Mikrocontroller-Port angeben, an den der Servomotor-Signal-Pin angeschlossen ist, und mit servo_name.write(degree) die Position des Servomotors in Grad.

 

servo_lock.attach(7);

servo_lock.write(90);

 

Dann wird der TFT-Bildschirm initialisiert, dazu muss er zunächst mit dem Befehl tft_safe_box.init(240, 320) initialisiert werden, der als Argumente die Größe des Bildschirms in Pixel hat. In diesem Projekt wird der Hintergrund des Bildschirms die Farbe Schwarz haben, wir geben ihn mit dem Befehl fillScreen(ST77XX_BLACK) des Bildschirmobjekts an, in den Parameter muss die Hintergrundfarbe des Bildschirms geschrieben werden. Die beiden Zeilen der Skizze sind:

 

tft_safe_box.init(240, 320);

tft_safe_box.fillScreen(ST77XX_BLACK);

 

Da das Einzige, was sich auf dem TFT-Bildschirm ändern wird, die Zahlen sind, wurde im Block setup() der gesamte Text programmiert, der auf dem Bildschirm erscheint, da er statisch ist und sich nicht ändern wird.setTextColor(color), die Größe des Textes mit tft_safe_box.setTextSize(value), die Koordinaten, an denen der Text geschrieben werden soll, mit tft_safe_box.setCursor(x-Koordinate, y-Koordinate) und die Zeichen, die in die Koordinaten geschrieben werden sollen mit tft_safe_box.println("Zeichen").

Unterhalb des Haupttextes auf dem Bildschirm wurde auch eine Linie gezeichnet, dies geschieht mit dem Befehl drawLine(x-Startkoordinate, y-Startkoordinate, x-Endkoordinate, y-Endkoordinate, Farbe) des Bildschirmobjekts.

 

   Die Codezeilen, die den Text und die Zeile auf dem Bildschirm darstellen, sind:

 

tft_safe_box.stroke(4, 255, 33);

tft_safe_box.setTextSize(2);

tft_safe_box.text("CODED DOOR", 20, 0);

tft_safe_box.line(18, 16, 140, 16);

 

tft_safe_box.setTextSize(1);

tft_safe_box.stroke(16, 93, 209);

tft_safe_box.text("ENTER NUMBERS", 0, 23);

tft_safe_box.stroke(255, 255, 255);

tft_safe_box.text("1st number: ", 0, 35);

tft_safe_box.text("2nd number: ", 0, 47);

tft_safe_box.text("3rd number: ", 0, 59);

tft_safe_box.text("4th number: ", 0, 71);

 

Nun muss das KY-040 Modul für seinen korrekten Betrieb konfiguriert werden. Dieses Modul liefert Signale über die Pins CLK, DT und SW, also muss der Mikrocontroller angewiesen werden, Signale über die Ports zu empfangen, an denen die Pins des Moduls angeschlossen sind, Der Befehl dazu lautet pinMode(pin, MODE), wobei das Argument pin den angeschlossenen Port und das Argument MODE den Signalempfang mit INPUT angeben muss. Der Drehgeberschalter sendet, wenn er nicht gedrückt ist, ein High-Signal an den Mikrocontroller, daher muss sein Signal anfangs als HIGH Zustand im VALUE Argument des digitalWrite Befehls gesetzt werden (pin, WERT), wobei Pin der Port sein soll, an dem der SW-Pin des KY-40-Moduls angeschlossen ist. Wenn der Schalter gedrückt wird, soll dieses Signal auf den Zustand LOW gesetzt werden.

 

pinMode(CLK, INPUT);

pinMode(DT, INPUT);

pinMode(SW, INPUT);

digitalWrite(SW, HIGH);  

 

Die Anfangswerte der vier Variablen, die die Zahlen enthalten, die vom Drehgeber ausgewählt werden, damit die Tür geöffnet werden kann, werden mit Null initialisiert.

 

first_selected_number = 0;

second_selected_number = 0;

third_selected_number = 0;

fourth_selected_number = 0;

 

In der letzten Zeile der Methode setup() wird die Aktion konfiguriert, die ausgeführt werden soll, wenn der vom Drehgeberschalter ausgelöste Hardware-Interrupt über den CLK-Pin des Drehgebers empfangen wird. Die Funktion attachInterrupt(digitalPinToInterrupt(CLK), encoder, LOW) ist diejenige, die den Hardware-Interrupt empfängt, wie man in der Code-Zeile sehen kann, die Parameter sind digitalPinToInterrupt(CLK), das ist der Mikrocontroller-Port, an dem der Interrupt empfangen wird, in diesem Fall ist es Pin 2, das ist der Wert der CLK-Variable, die am Anfang des Sketches definiert wurde, der zweite Parameter ist ein Aufruf der Methode Encoder, die ausgeführt wird, wenn der Interrupt empfangen wird, und der dritte und letzte Parameter ist LOW, der die Erkennung einer Änderung des Signalpegels ist, die vom KY-040-Modul an den durch den ersten Parameter angegebenen Port gesendet wird, wenn letzteres geschieht, wird der Aufruf der Methode Encoder ausgeführt.

 

attachInterrupt(digitalPinToInterrupt(CLK), encoder, LOW);

 

Vor der Analyse der Methode Schleife() wird die Methode analysiert, die bei der Unterbrechung durch den CLK-Pin des Drehgebers aufgerufen wird. Wie analysiert, wird die Methode Encoder() aufgerufen, wenn das Drehgebermodul einen Pegelwechsel an seinem Pin CLK durchführt, Diese Methode steht am Ende des Sketches und als erstes wird die Variable letzte_Unterbrechung definiert und initialisiert, die die Zeit in Millisekunden speichert, in der die letzte Unterbrechung stattgefunden hat, außerdem wird die Variable Zeit_Unterbrechung definiert, in der die aktuellen Millisekunden gespeichert werden. Eine WENN-Bedingung wurde programmiert, um zu prüfen, ob die Zeit von der letzten Unterbrechung bis zur aktuellen Unterbrechung mehr als 10 Millisekunden beträgt. Wenn dies der Fall ist, wird der Code in den Tasten ausgeführt und es wird geprüft, ob das Signal des CLK-Pins des Encoders auf HIGH-Pegel mit digitalRead(DT) == HIGH ist, wenn true, erhöht sich die Zahl auf dem Display um eine Einheit, andernfalls verringert sich die Zahl auf dem Display um eine Einheit, diese Zahl wird in der Variablen actual_number gespeichert, um in den Auswahlmethoden der vier Zahlen verwendet zu werden, um die Tür zu öffnen. Mit der Zeile aktuelle_Zahl = min(50, max(-50, aktuelle_Zahl)) werden die Minimal- und Maximalwerte bei 50 und -50 der Zahlen definiert, die beim Bewegen des Encoders auf dem Bildschirm angezeigt werden sollen. In der letzten Zeile dieser Methode wird der Wert der aktuellen Zeitvariablen Zeit_Unterbrechung in der Variablen letzte_Unterbrechung gespeichert, um die nächste Überprüfung der zwischen den Unterbrechungen verstrichenen Zeit durchzuführen. Der vollständige Code für diese Methode lautet:

 

void encoder()  {

      static unsigned long last_Interruption = 0;

      unsigned long time_Interruption = millis();

 

      if (time_Interruption - last_Interruption > 10) {

                 if (digitalRead(DT) == HIGH){

                          actual_number++;

                 } else {

                          actual_number--;

                 }

 

                 actual_number = min(50, max(-50, actual_number));

                 last_Interruption = time_Interruption;

      }

}

 

 Nachdem die Anfangsbedingungen der Schaltung konfiguriert wurden und die Methode, die beim Auftreten eines Hardware-Interrupts ausgeführt werden soll, programmiert wurde, muss die Methode Schleife() , die kontinuierlich ausgeführt wird, programmiert werden, aber zunächst wird eine kurze Erklärung der Ausführung gegeben. Wenn der Encoder gedreht wird, um die für jede Position benötigte Zahl zu finden, wird die aktuelle Zahl, die auf dem Bildschirm angezeigt wird, in einer Variablen gespeichert, dann wird die aktuelle Zahl gelöscht und die neue Zahl wird angezeigt, diese Sequenz wird bei jeder Änderung der Zahl durchgeführt, wenn der Encoder gedreht wird, wenn der Encoderschalter gedrückt wird, wird die Zahl, die auf dem Bildschirm angezeigt wird, in der entsprechenden Position der Methode, die gerade ausgeführt wird, gespeichert und in ihrer Position auf dem Bildschirm angezeigt. Diese Sequenzen werden so lange durchgeführt, bis die vier zum Öffnen der Tür erforderlichen Zahlen ausgewählt sind. Wenn die vier ausgewählten Zahlen korrekt sind, erlischt die rote LED, die grüne LED leuchtet auf, die Position des Stellmotors ändert sich, so dass die Tür geöffnet werden kann, und die vier ausgewählten Zahlen werden aus der Anzeige gelöscht. Umgekehrt, wenn eine der vier ausgewählten Zahlen nicht korrekt ist, werden die vier Zahlen vom Display gelöscht, damit sie erneut ausgewählt werden können. Wenn die Tür offen ist und Sie die Tür schließen und verriegeln wollen, geben Sie einfach vier beliebige Zahlen ein, solange es nicht die richtigen sind, dann ändert der Stellmotor seine Position, die grüne LED erlischt, die rote LED leuchtet auf und die vier Zahlen werden gelöscht. Fahren wir fort mit der Beschreibung des Codes.

Das erste, was programmiert wird, ist der Vergleich der vier Zahlen, die mit dem Drehgeber ausgewählt wurden, mit den vier gewählten Geheimzahlen. Dazu wird die doppelte Bedingung IF-ELSE verwendet, wie in den Argumenten der IF-Bedingung zu sehen ist, werden die Zahlen verglichen, die mit dem Drehgeber ausgewählt und in den Variablen erste_gewählte_Zahl gespeichert wurden, zweite_ausgewählte_Zahl, dritte_ausgewählte_Zahl und vierte_ausgewählte_Zahl mit den geheimen Zahlen, die in den Variablen erste_gesicherte_Zahl, zweite_gesicherte_Zahl gespeichert sind, dritte_gesicherte_Zahl und vierte_gesicherte_Zahl, wenn alle vier Vergleiche wahr sind, dann ist die Bedingung wahr und der Code innerhalb der geschweiften Klammern wird ausgeführt. Wie du siehst, wird zuerst die rote LED mit digitalWrite(red_led,LOW) ausgeschaltet und dann die grüne LED mit digitalWrite(green_led, HIGH) eingeschaltet, Dies zeigt an, dass der eingegebene Code korrekt ist und die for-Schleife wird ausgeführt, um die Position des Servomotors von 90 Grad bis 160 Grad in Schritten von 10 Millisekunden für eine gleichmäßige Bewegung zu ändern.

 

if (first_selected_number == first_secured_number

    && second_selected_number == second_secured_number

    && third_selected_number == third_secured_number

    && fourth_selected_number == fourth_secured_number) {

                 digitalWrite(red_led,LOW);

                 digitalWrite(green_led, HIGH);

 

                 for (servo_position = 90; servo_position <= 160; servo_position += 1) {

                      servo_lock.write(servo_position);

                      delay(10);

                 }

}

 

Wenn der Vergleich nicht wahr ist, springt der Codefluss zur ELSE-Anweisung, um den Code in deinen Tasten auszuführen, der einfach darin besteht, die rote LED mit digitalWrite(red_led,HIGH) einzuschalten, die grüne LED mit digitalWrite(green_led,LOW) auszuschalten und die Servomotorposition mit servo_lock auf 90 Grad zu setzen.write(90). Um die Tür zu verankern, wenn wir sie schließen, geben Sie einfach eine der vier Zahlen falsch ein und dieser Code wird ausgeführt und verankert die Tür.

 

else {

         digitalWrite(red_led,HIGH);

         digitalWrite(green_led, LOW);            

         servo_lock.write(90);

}

 

Wie oben beschrieben, werden die Zahlen, wenn sie durch Bewegen und Drücken des Encoders eingegeben werden, gelöscht, wenn die vierte Zahl eingegeben wird, dies geschieht mit dem folgenden Teil des Codes. Zuerst setzen wir die Textgröße auf 2 mit tft_safe_box.setTextSize(2), die Textfarbe sollte schwarz sein, um den Eindruck zu erwecken, dass die Zahlen gelöscht wurden, wofür tft_safe_box programmiert wird.setTextColor(ST77XX_BLACK), aber was tatsächlich passiert, ist, dass die Zeichen der Zahlen schwarz dargestellt werden und da der Bildschirmhintergrund ebenfalls schwarz ist, wird es so aussehen, als ob die Zahlen gelöscht wurden. Der Cursor wird mit tft_safe_box.setCursor(x-Koordinate, y-Koordinate) an den entsprechenden Koordinaten positioniert und die Werte der Variablen der vier Zahlen werden mit tft_safe_box.println(position_number) "angezeigt".

 

tft_safe_box.setTextSize(2);

tft_safe_box.setTextColor(ST77XX_BLACK);

tft_safe_box.setCursor(150, 70);

tft_safe_box.println(first_number);

tft_safe_box.setCursor(150, 100);

tft_safe_box.println(second_number);

tft_safe_box.setCursor(150, 130);

tft_safe_box.println(third_number);

tft_safe_box.setCursor(150, 160);

tft_safe_box.println(fourth_number);

 

Nachdem die Zahlenzeichen von der Anzeige "gelöscht" worden sind, werden die entsprechenden Methoden aufgerufen, um die Zahlen für jede Position auf der Anzeige mit dem Drehgeber auszuwählen; bei der Rückkehr von jeder Zahlenauswahl wird eine Pause von 500 ms gemacht.

 

select_first_number();

delay(500);

select_second_number();

delay(500);

select_third_number();

delay(500);

select_fourth_number();

delay(500);

 

 Die Methoden für die Auswahl der vier Zahlen sind die gleichen, nur die entsprechenden Variablen zur Verwaltung jeder Zahl und die Koordinaten der Position dieser Zahl ändern sich, so lassen Sie uns die Methode zur Auswahl der ersten Zahl erklären. In der Methode verwenden wir die DO-WHILE-Schleife, WHILE steuert die Bedingung, dass, wenn keine Zahl für die erste Position ausgewählt ist, zu DO zurückzukehren, um den Encoder zu drehen und eine Zahl durch Drücken des Schalters auszuwählen. Innerhalb des DO-Blocks gibt es zwei einfache IF-Bedingungen, in der ersten Bedingung wird die Zahl auf dem Bildschirm angezeigt, je nachdem, ob sich der Encoder in die eine oder andere Richtung bewegt, und mit der zweiten Bedingung wird die Zahl, die durch Drücken des Encoder-Schalters ausgewählt wurde, gespeichert und auf dem Bildschirm angezeigt. Diese Blöcke sind ähnlich für die anderen drei zu wählenden Zahlen.

 

void select_first_number() {

       do {

              if (condition) {

                     . . .

              }

              if (condition) {

                     . . .

              }

       } while (condition);

}

 

Das erste, was in der Methode programmiert wird, ist, die Variablen auf Null zu initialisieren, die den Wert der Nummer, die für die erste Position ausgewählt werden soll, und den Wert der Variablen der Nummer, die vor der auf dem Bildschirm angezeigten Nummer liegt, wenn der Encoder gedreht wird, speichern. Die Codezeilen sind Erste_ausgewählte_Zahl = 0 und Letzte_Zahl = 0, dann wird eine Meldung vom seriellen Monitor mit Serial.println("Erster Nummerneintrag").

 

void select_first_number() {

         first_selected_number = 0;

         last_number = 0;

         Serial.println("First number entry");

 

Wenn der Geber gedreht wird, wird geprüft, ob die Zahl nicht mit der Codezeile Ist_Zahl != letzte_Zahl, wenn dieser Vergleich wahr ist, wird das Innere der Tasten ausgeführt und das erste, was getan wird, ist, mit dem seriellen Monitor den Wert der Variablen aktuelle_Zahl mit der neuen Zahl, die auf dem Bildschirm erscheint, anzuzeigen, dann den Wert dieser Variablen in der Variablen letzte_Zahl zu speichern, um später die neue Zahl zu überprüfen, die angezeigt wird, wenn der Geber geändert wird. Denken Sie daran, dass zur Anzeige einer Zahl auf dem TFT-Bildschirm der numerische Wert in Zeichenketten umgewandelt werden muss, aber zuerst muss die aktuelle Zahl gelöscht werden, damit die neue Zahl angezeigt werden kann. Zuerst wird die Farbe des anzuzeigenden Textes mit tft_safe_box.setTextColor(ST77XX_BLACK) auf schwarz gesetzt, um die vorherige Zahl zu "löschen", dann werden die Koordinaten, wo die Zahl angezeigt wird, mit tft_safe_box.setCursor(60, 220) und schließlich wird mit tft_safe_box.println(encoder_number) die String-Variable encoder_number über den Bildschirm angezeigt. Die Zahl, die durch das Bewegen des Encoders verändert wird, wird gelöscht. Der vollständige Code lautet:

 

if (actual_number != last_number) {

         Serial.println(actual_number);

         last_number = actual_number;

         tft_safe_box.setTextColor(ST77XX_BLACK);

         tft_safe_box.setCursor(60, 220);

         tft_safe_box.println(encoder_number);

                                . . . . . . .

                                . . . . . . .

}

Nun muss man die neue Zahl anzeigen, die sich aus dem Verschieben des Encoders ergibt und die in der Variablen Ist-Zahl gespeichert ist, die von der Methode Encoder() bereitgestellt wird. Man muss daran denken, dass der numerische Wert in eine Zeichenkette umgewandelt werden muss, also wird zuerst der Wert der Variablen Ist-Zahl in der Variablen Encoder_ausgewählte_Zahl gespeichert, die Umwandlung des numerischen Wertes in Zeichen erfolgt mit String convert_encoder_selected_number = String(encoder_selected_number), damit hat man den Wert in einen String umgewandelt in der Variablen convert_encoder_selected_number, nun muss man den String in das Zeichenarray encoder_encoder_number speichern, um ihn auf dem TFT-Bildschirm darzustellen, dies geschieht mit convert_encoder_selected_number.toCharArray(encoder_number, 4). Um die String-Array-Variable anzuzeigen, setzen Sie den Text auf weiß mit tft_safe_box.setTextColor(ST77XX_WHITE), die Koordinaten, wo die Zahl angezeigt werden soll, mit der Zeile tft_safe_box.setCursor(60, 220), die Textgröße mit tft_safe_box.setTextSize(8) und schließlich den Inhalt der Variable encoder_number, die das String-Array ist, mit tft_safe_box.println(encoder_number). Wenn alles oben genannte ausgeführt wird, erscheint die neue Nummer auf dem Bildschirm, sie kann höher oder niedriger sein, je nachdem, in welche Richtung der Geber bewegt wurde. 

encoder_selected_number = actual_number;

String convert_encoder_selected_number = String(encoder_selected_number);

convert_encoder_selected_number.toCharArray(encoder_number, 4);

tft_safe_box.setTextColor(ST77XX_WHITE);

tft_safe_box.setTextSize(8);

tft_safe_box.setCursor(60, 220);

tft_safe_box.println(encoder_number);

 

Die zweite Bedingung IF der Methode ist so programmiert, dass sie die Zahl auswählt, die in jeder Position gespeichert werden soll. Drücken Sie einfach die Encoderstange, um den Schalter zu betätigen, und die Zahl, die auf dem Bildschirm erscheint, wird gespeichert und an der entsprechenden Position angezeigt. Die Bedingung, die in dem Conditional geprüft wird, ist, dass das vom Mikrocontroller empfangene Signal keinen hohen Pegel hat, dies wird mit if (!digitalRead(SW)) geprüft, da das Signal mit dem Ausrufezeichen negiert wird, wenn diese Bedingung erfüllt ist, wird das Innere der Tasten ausgeführt. Als erstes wird die mit dem Encoder gewählte Zahl, die in der Variablen Ist-Zahl gespeichert ist, in der Variablen Erste_gewählte_Zahl gespeichert, nun muss der numerische Wert dieser Variablen in eine Zeichenkette umgewandelt werden, um ihn auf dem Bildschirm anzeigen zu können, dies geschieht mit der Zeile String convert_first_selected_number = String(first_selected_number), dann muss der String in der Variablen first_number gespeichert werden, die ein Array ist, dies geschieht mit der Zeile convert_second_selected_number.toCharArray(erste_Zahl, 4). Die Zahl ist bereit, auf dem Bildschirm angezeigt zu werden, jetzt müssen Sie die Parameter für die Anzeige dieser Variable einstellen, um dies zu tun, setzen Sie zuerst die Textfarbe auf weiß mit tft_safe_box.setTextColor(ST77XX_WHITE), die Textgröße wird einen Wert von 2 haben, sie wird mit der Zeile tft_safe_box.setTextSize(2) konfiguriert und die Koordinaten, wo die Zeichen angezeigt werden sollen, werden mit der Zeile tft_safe_box.setCursor(150, 70) konfiguriert. Mit den eingestellten Anzeigeparametern werden die Zeichen, die die Variable erste_Zahl hat, mit der Programmierung der Zeile tft_safe_box.println(erste_Zahl) angezeigt. Die letzte Zeile dieser Methode zeigt eine Meldung über den seriellen Monitor an, um mitzuteilen, dass die Nummer erfolgreich gespeichert wurde. Der vollständige Code lautet wie folgt:

if (!digitalRead(SW)) {

         first_selected_number = actual_number;

         String convert_first_selected_number = String(first_selected_number);

         convert_second_selected_number.toCharArray(first_number, 4);

         tft_safe_box.setTextColor(ST77XX_WHITE);

         tft_safe_box.setTextSize(2);

         tft_safe_box.setCursor(150, 70);

         tft_safe_box.println(first_number);

         Serial.println("The first number has been saved.");

}

 

Die Methoden zur Auswahl der übrigen drei Zahlen sind genau dieselben, nur die Variablen und Koordinaten ändern sich, um die Zahlen korrekt auf dem Bildschirm anzuzeigen. Wir hoffen, dass Sie dieses Projekt interessant und nützlich finden, vielen Dank.