Arduino Touchscreen-Rechner - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:18

Hallo! Dies ist ein Projekt zur Herstellung eines Touchscreen-Rechners mit einem Arduino Uno und einem TFT-LCD-Schild. Ich habe das Konzept für meinen Homeschool-Programmierkurs entwickelt und die Erfahrung beim Aufbau dieses Projekts war sehr interessant. Dieser Rechner kann die vier einfachen mathematischen Operationen (Addition, Subtraktion, Multiplikation und Division) ausführen. Es zeigt auch bis zu zwei Dezimalstellen für die Divisionsantworten an, die sie enthalten. Lass uns direkt eintauchen! Die Materialien für dieses Projekt sind unten aufgeführt.

Lieferungen

- Arduino Uno

- 2.4 TFT LCD Shield (hier habe ich es gekauft:

- USB A-zu-B-Kabel (Kabel zum Verbinden von Arduino mit dem Computer)

- Computer mit installierter Arduino IDE

- Sie müssen außerdem zwei Bibliotheken herunterladen: MCUFRIEND_kbv und Touchscreen. Die erste finden Sie auf github (Link: https://github.com/prenticedavid/MCUFRIEND_kbv) oder Sie können die Bibliotheks-Zip-Datei verwenden, die ich unten eingefügt habe. Die zweite befindet sich im Arduino-Bibliotheksmanager zur Installation.

Schritt 1: Hardwareverbindungen

Der Anschluss des Touchscreen-Shields an das Arduino Uno ist einfach und schnell. Alles, was Sie tun müssen, ist die untersten Pins auf dem Schild mit den niedrigsten Pins auf dem Arduino auszurichten und das Schild in die Pins zu drücken. Der obere 5V-Pin und der unbeschriftete Pin auf der Stromseite sollten keine Pins aus der Abschirmung enthalten, wobei die gleichen Parameter für die Pins mit der Bezeichnung SCL und SDA auf der anderen Seite der Platine gelten. Jetzt können wir codieren!

Schritt 2: Der Code: Globale Definitionen & Einrichtung

#enthalten

MCUFRIEND_kbv tft; // sowieso fest verdrahtet für UNO-Schilde

#enthalten

#define YP A3

#define XM A2

#define YM 9

#Define XP 8

TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);

#define MINDERDRUCK 10

Dies ist der Anfang des Codes, in dem wir Bibliotheken (MCUFRIEND_kbv & Touchscreen) einschließen, die X- und Y-Pins definieren, die Touchscreen-Parameter einrichten und den minimalen Druck definieren, der für das Arduino erforderlich ist, um eine Benutzerpresse zu registrieren.

int-ID;

int user_selection;

float save_number = 0;

Float-Term1;

int op_num;

Float-Ergebnis;

int CursorLocX = 5;

int CursorLocY = 20;

Direkt vor dem Setup müssen wir einige globale Variablen einrichten. ID hilft bei der Inbetriebnahme des Touchscreens. user_selection enthält eine Zahl, die der Taste entspricht, die der Benutzer beim Drücken des Touchscreens auswählt. saved_number ist die Variable, die wir nach einer Benutzereingabe auf den Bildschirm ausgeben (mehr dazu in der Schleife). Es ist ein Float, kann also sowohl Dezimalzahlen als auch ganze Zahlen aufnehmen. term1 ist die Variable, in der die erste Zahl der Gleichung gespeichert wird, nachdem ein Operand ausgewählt wurde. op_num speichert den Operanden als Zahl (1 für Addition, 2 für Subtraktion, 3 für Multiplikation und 4 für Division). result ist die Variable, die auf dem Bildschirm ausgegeben wird, nachdem der Benutzer das Gleichheitszeichen gedrückt hat. Es ist auch ein Schwimmer. CursorLocX und CursorLocY sind die Zuordnungspunkte auf dem Touchscreen, auf die der Cursor mehrmals gesetzt wird (er befindet sich in der grauen Leiste oben, auch als Ergebnisfeld bekannt).

Void-Setup () {

tft.reset();

ID = tft.readID();

tft.begin(ID);

tft.setRotation(0);

tft.fillScreen(TFT_DARKGREY);

Quadrate ();

Zahlen();

tft.setTextSize(3);

tft.setTextColor(TFT_BLUE, TFT_DARKGREY);

}

Unsere Setup-Funktion beinhaltet zunächst die Initialisierung für die Touchscreen-Abschirmung (Zeilen 1-3). Die Ausrichtung des Schildes wird mit dem Befehl tft.setRotation() eingestellt, wobei 0 aufrecht steht. Der gesamte Bildschirm wird mit dem Befehl tft.fillScreen(), den wir überschreiben (außer dem Ergebnisfeld), dunkelgrau gefärbt. Die Funktionen squares() und numbers() zeichnen die Quadrate des Taschenrechners, färben die Quadrate in einem Schachbrettmuster schwarz und weiß und schreiben Zahlen/Operanden in Blau auf die Quadrate. Zu denen kommen wir im nächsten Schritt. Der Befehl tft.setTextSize() setzt die Textgröße des Ergebnisfelds auf 3, was einer mittleren Schriftart entspricht. Der Befehl tft.setTextColor() setzt die Textfarbe des Ergebnisfeldes auf Blau, das über das dunkelgraue Feld geschrieben wird.

Schritt 3: Der Code: Schleife

Void Schleife () { ZahlAuswählen ();

Verzögerung (100);

if (user_selection == 16){

;

}anders{

if (user_selection < 10){

gespeicherte_nummer = gespeicherte_nummer * 10 + Benutzerauswahl;

tft.setCursor(cursorLocX, cursorLocY);

tft.print (gespeicherte_nummer);

}sonst wenn (user_selection > 10){

wechseln (user_selection){

Fall 11:

op_num = 1;

tft.setCursor(cursorLocX, cursorLocY);

tft.print("+");

Begriff1 = gespeicherte_Nummer;

gespeicherte_nummer = 0;

brechen;

Fall 12:

op_num = 2;

tft.setCursor(cursorLocX, cursorLocY);

tft.print("-");

Begriff1 = gespeicherte_Nummer;

gespeicherte_nummer = 0;

brechen;

Fall 13:

op_num = 3;

tft.setCursor(cursorLocX, cursorLocY);

tft.print("X");

Begriff1 = gespeicherte_Nummer;

gespeicherte_nummer = 0;

brechen;

Fall 14:

op_num = 4;

tft.setCursor(cursorLocX, cursorLocY);

tft.print("/");

Begriff1 = gespeicherte_Nummer;

gespeicherte_nummer = 0;

brechen;

Fall 15:

gespeicherte_nummer = 0;

Begriff1 = 0;

op_num = 0;

tft.setCursor(cursorLocX, cursorLocY);

tft.print(" ");

brechen;

}

tft.setCursor(cursorLocX, cursorLocY);

Das ist eine Menge zu kauen, also werde ich erklären, was oben steht. Wir beginnen mit dem Aufruf der Funktion numberSelect(), die jedem Quadrat auf dem Touchscreen eine Zahl zuweist. Wenn ein Benutzer eines dieser Quadrate drückt, setzt die Funktion die Variable user_selection auf die Nummer des Quadrats. Die erste if-Anweisung soll die Schleife nur durchlaufen, wenn eine gültige Benutzerauswahl getroffen wurde. Wenn ja, fragt die nächste if-Anweisung, ob in user_selection eine Zahl kleiner als 10 gespeichert ist (die Zahlen 0-9). Ist dies der Fall, wird saved_number mit 10 multipliziert und die Zahl in user_selection wird zu saved_number addiert, das im Ergebnisfeld auf dem Touchscreen gedruckt wird. Ist dies nicht der Fall, fragt die nächste if-Anweisung, ob in user_selection eine Zahl größer als 10 gespeichert ist (die Operandennummern: 11 für +, 12 für -, 13 für X, 14 für / und 15 für das leere Bildschirmquadrat). Eine Switch-Funktion kümmert sich um jeden Fall (bestimmt durch user_selection). Die Variable op_num erhält eine Nummer, die dem ausgewählten Operanden entspricht (1 für +, 2 für -, 3 für X und 4 für /). Der Wert in saved_number wird in der Variablen term1 gespeichert, damit die Variable saved_number für die zweite Hälfte der Gleichung verwendet werden kann. Das Operandensymbol wird zusammen mit dem Löschen aller Zahlen im Ergebnisfeld auf dem Bildschirm gedruckt. Die einzige Ausnahme ist das leere Bildschirmquadrat, das alle Berechnungsvariablen zurücksetzt und das Ergebnisfeld von allem löscht.

}anders{

switch(op_num){

Fall 1:

Ergebnis = Begriff1 + gespeicherte_Nummer;

tft.setCursor(cursorLocX, cursorLocY);

tft.print (double (Ergebnis));

brechen;

Fall 2:

Ergebnis = Begriff1 - gespeicherte_Nummer;

tft.setCursor(cursorLocX, cursorLocY);

tft.print (double (Ergebnis));

brechen;

Fall 3:

Ergebnis = Begriff1 * gespeicherte_Nummer;

tft.setCursor(cursorLocX, cursorLocY);

tft.print (double (Ergebnis));

brechen;

Fall 4:

Ergebnis = float(term1) / float(gespeicherte_nummer);

tft.setCursor(cursorLocX, cursorLocY);

tft.print (Ergebnis);

brechen;

}

tft.setCursor(cursorLocX, cursorLocY);

Gespeicherte_Nummer = Ergebnis;

Begriff1 = 0;

op_num = 0;

Verzögerung (1000);

}

}

}

Der letzte Teil der Schleife befasst sich mit dem Ereignis, bei dem der Benutzer das Gleichheitszeichen auswählt (user_selection == 10). Eine weitere Schaltfunktion arbeitet durch die vier mathematischen Funktionen (bestimmt durch op_num). Die Addition case (case 1) addiert term1 und saved_number und speichert die Zahl in der Ergebnisvariablen. Das Ergebnis wird als Double in das Ergebnisfeld ausgegeben. Der Subtraktionsfall (Fall 2) subtrahiert saved_number von term1 und speichert die Zahl in der Ergebnisvariablen. Das Ergebnis wird als Double in das Ergebnisfeld gedruckt. Der Multiplikationsfall (Fall 3) multipliziert term1 mit saved_number und speichert die Zahl in der Ergebnisvariablen. Das Ergebnis wird als Double in das Ergebnisfeld ausgegeben. Der Divisionsfall (Fall 4) teilt Term1 durch gespeicherte_Zahl zusammen und speichert die Zahl in der Ergebnisvariablen. Das Ergebnis wird als Float im Ergebnisfeld ausgegeben (da die Divisionsantworten Dezimalzahlen sein können). Nachdem entweder eine Zahl, ein Operand oder ein Ergebnis auf dem Bildschirm ausgegeben wurde, wird der Cursor zurückgesetzt, saved_number wird auf das vorherige Ergebnis gesetzt und term1 & op_num werden zurückgesetzt.

Ein paar Hinweise: Der Benutzer kann aufgrund des fehlenden Kommaquadrats keine Dezimalzahlen in den Taschenrechner eingeben. Außerdem kann der Benutzer jeweils nur eine Gleichung ausführen. Sie können kein Ergebnis berechnen und dann dieses Ergebnis addieren/subtrahieren/multiplizieren/dividieren. In der Funktion numberSelect() gibt es eine Funktion, die den Bildschirm löscht, nachdem ein Ergebnis gedruckt wurde, wenn ein Benutzer ein weiteres Quadrat gedrückt hat.

Schritt 4: Der Code: Squares-Funktion

leere Quadrate (){

// schwarze und weiße Quadrate wechseln sich in jeder Reihe ab und die erste und dritte Reihe haben ein entgegengesetztes Muster als die zweite und vierte Reihe

tft.fillRect(0, 60, 60, 65, TFT_BLACK); // erste Reihe von Quadraten beginnt, schwarz nach weiß tft.fillRect(60, 60, 60, 65, TFT_WHITE);

tft.fillRect(120, 60, 60, 65, TFT_BLACK);

tft.fillRect(180, 60, 60, 65, TFT_WHITE); // erste Reihe von Quadraten endet

tft.fillRect(0, 125, 60, 65, TFT_WHITE); // zweite Reihe von Quadraten beginnt, weiß nach schwarz tft.fillRect(60, 125, 60, 65, TFT_BLACK);

tft.fillRect(120, 125, 60, 65, TFT_WHITE);

tft.fillRect(180, 125, 60, 65, TFT_BLACK); // zweite Reihe von Quadraten endet

tft.fillRect(0, 190, 60, 65, TFT_BLACK); // dritte Reihe von Quadraten beginnt, schwarz nach weiß tft.fillRect(60, 190, 60, 65, TFT_WHITE);

tft.fillRect(120, 190, 60, 65, TFT_BLACK);

tft.fillRect(180, 190, 60, 65, TFT_WHITE); // dritte Reihe von Quadraten endet

tft.fillRect(0, 255, 60, 65, TFT_WHITE); // vierte Reihe von Quadraten beginnt, weiß nach schwarz tft.fillRect(60, 255, 60, 65, TFT_BLACK);

tft.fillRect(120, 255, 60, 65, TFT_WHITE);

tft.fillRect(180, 255, 60, 65, TFT_BLACK); // vierte Reihe von Quadraten endet

}

Die Funktion squares() ist ziemlich einfach. Der Befehl tft.fillRect(X1, Y1, X2, Y2, TFT_COLOR) zeichnet ein Rechteck gemäß den übergebenen Parametern, also den ersten Positionen von x und y, den zweiten Positionen von x und y und der Farbe, mit der das Rechteck gefüllt ist. Diese Funktion zeichnet alle vier Reihen von Quadraten (technisch Rechtecke) und füllt jedes Quadrat mit der ihr übergebenen Farbe.

Schritt 5: Der Code: Zahlenfunktion

leere Zahlen (){

tft.setTextColor(TFT_BLUE); // setzt Zahl/Zeichenfarbe auf Blau

tft.setTextSize(5); // setzt Zahl/Zeichengröße auf 5

tft.setCursor(18, 75); // setzt den Cursor für die erste Zeile mit Zahlen/Zeichen

tft.print("7 8 9 /"); // gibt die erste Zeile mit Zahlen/Zeichen aus

tft.setCursor(18, 140); // setzt den Cursor für die zweite Zeile mit Zahlen/Zeichen

tft.print("4 5 6 X"); // gibt die zweite Zeile mit Zahlen/Zeichen aus

tft.setCursor(18, 205); // setzt den Cursor für die dritte Zeile mit Zahlen/Zeichen

tft.print("1 2 3 -"); // gibt die dritte Zeile mit Zahlen/Zeichen aus

tft.setCursor(18, 270); // setzt den Cursor für die vierte Zeile mit Zahlen/Zeichen

tft.print("C 0 = +"); // gibt die vierte Zeile mit Zahlen/Zeichen aus

}

Die Funktion numbers() ist ebenfalls einfach. Die ersten beiden Zeilen setzen die Textgröße größer und die Farbe auf Blau. Der Befehl tft.setCursor() setzt den Cursor in jeder Zeile an die Position, an der das Schreiben der Zahlen beginnt. Dann druckt der Befehl tft.print() die Zahlen/Zeichen über die Quadrate.

Schritt 6: Der Code: NumberSelect-Funktion

Leere ZahlSelect(){

TSPoint p = ts.getPoint();

pinMode (XM, AUSGANG);

pinMode (YP, AUSGANG);

if (p.z > MINDRUCK){

p.x = map(p.x, 250, 845, 0, 239);

p.y = map(p.y, 245, 860, 0, 319);

if (Ergebnis != 0){

Ergebnis = 0;

gespeicherte_nummer = 0;

tft.print ("WERTE LÖSCHEN");

Verzögerung (500);

tft.setCursor(cursorLocX, cursorLocY);

tft.print(" ");

tft.setCursor(cursorLocX, cursorLocY);

}

Um die Funktion numberSelect() zu starten, bitten wir mit dem Befehl ts.getPoint() um eine Benutzereingabe vom Touchscreen. Nachdem diese Daten gesammelt wurden, überprüfen wir, ob der Mindestdruck überschritten wurde (oder anders gesagt, ob der Benutzer irgendwo auf den Touchscreen gedrückt hat). Ist dies der Fall, werden die x- und y-Koordinaten von kartesischen Koordinaten auf Touchscreen-spezifische Koordinaten abgebildet. (0, 0) ist die obere linke Ecke des Touchscreens, wobei die x-Achse quer und die y-Achse nach unten verläuft. Der nächste Teil prüft, ob im Ergebnis eine Zahl gespeichert ist. Ist dies der Fall, werden Ergebnis und gespeicherte_Nummer auf 0 zurückgesetzt. Die Meldung "CLEAR VALUES" wird über das Ergebnisfeld gedruckt und der Bildschirm wird mit dem Cursor zurück in seine Ausgangsposition gelöscht.

if (p.y 60){// erste Reihe von Quadraten

wenn (p.x < 60)

user_selection = 7;

sonst wenn (p.x < 120)

user_selection = 8;

sonst wenn (p.x < 180)

user_selection = 9;

sonst user_selection = 14;

}sonst if (p.y 125){// zweite Reihe von Quadraten

wenn (p.x < 60)

user_selection = 4;

sonst wenn (p.x < 120)

user_selection = 5;

sonst wenn (p.x < 180)

user_selection = 6;

sonst user_selection = 13;

}sonst if (p.y 190){// dritte Reihe von Quadraten

wenn (p.x < 60)

user_selection = 1;

sonst wenn (p.x < 120)

user_selection = 2;

sonst wenn (p.x < 180)

user_selection = 3;

sonst user_selection = 12;

}sonst if (p.y > 255){// vierte Reihe von Quadraten

wenn (p.x < 60)

user_selection = 15;

sonst wenn (p.x < 120)

user_selection = 0;

sonst wenn (p.x < 180)

user_selection = 10;

sonst user_selection = 11;

}

}anders{

user_selection = 16; // user_selection wird auf 16 gesetzt (nichts Variable)

}

}

Dies ist der Teil, der bestimmt, welche Schaltfläche ausgewählt wurde. Beginnend mit der oberen Reihe von Quadraten und endend mit der unteren Reihe sucht das Arduino nach der Stelle, an der der Bildschirm tatsächlich gedrückt wurde. Es weist dem Quadrat dann eine Zahl zu und speichert diese Zahl in user_selection. Die Zahlen 0-9 entsprechen den Zahlenquadraten, die Zahlen 11-15 entsprechen den Operandenquadraten und dem Clear-Quadrat und die Zahl 10 entspricht dem Gleichheitszeichen-Quadrat. Wenn kein Quadrat ausgewählt wurde, wird user_selection auf 16 gesetzt, wodurch die Schleife von vorne beginnt (siehe Schleifenfunktion).

Schritt 7: Genießen Sie Ihr fertiges Projekt

Hier hast du es! Sie haben jetzt einen Touchscreen-Rechner, der Addition, Subtraktion, Multiplikation und Division ausführen kann. Dieses Projekt änderte die ganze Art und Weise, wie ich dachte, dass ein Taschenrechner funktioniert. Als ich an diesem Projekt arbeitete, erinnere ich mich, dass ich meinem Lehrer im Unterricht sagte: "Ich werde einen Taschenrechner nie wieder so ansehen!" Die Funktionen, die Sie als Benutzer für einfach halten, sind etwas schwierig, wenn Sie hinter dem Computer sitzen und versuchen, Ihre Idee zu emulieren. Ich hoffe, Ihnen hat das Projekt gefallen, und ich hoffe, dass sich auch Ihre Einstellung zur Funktionsweise eines Taschenrechners geändert hat!

Hier ist der gesamte Code für Ihre Bequemlichkeit. Es ist mit Kommentaren gefüllt. Wenn Sie also Probleme haben, sollten sie Ihnen zeigen, was jede Zeile bewirkt.