Wie erstelle ich einen Arduino-basierten Rechner?

Projekte erstellen mit Arduino Uno als Mikrocontroller-Board macht richtig Spaß, wenn man an Embedded-Projekten arbeitet. Wenn Sie einen einfachen Taschenrechner erstellen möchten, der alle grundlegenden arithmetischen Operationen wie Addition, Subtraktion, Multiplikation und Division ausführen kann, können Sie dies sofort tun, wenn Sie mit dem Arduino-Board vertraut sind. In diesem Projekt werden wir also einen Arduino Uno verwenden, um einen einfachen Taschenrechner zu erstellen. Wir werden eine 4×4-Tastatur integrieren, um die Eingabe zu senden, und ein 16×2-LCD, um die Ausgabe unserer Operationen anzuzeigen.

Da wir nun die grundlegende Zusammenfassung unseres Projekts kennen, was wir am Ende erreichen wollen, lassen Sie uns weitermachen und weitere Informationen sammeln, um mit der Arbeit an diesem Projekt zu beginnen.

Wie erstelle ich einen einfachen Rechner auf Arduino?

Schritt 1: Sammeln der Komponenten

Bevor Sie ein Projekt starten, müssen Sie zunächst eine vollständige Liste aller Komponenten erstellen, die im Projekt nicht verwendet werden sollen. Dies ist ein perfekter Ansatz, da er viel Zeit spart und verhindert, dass wir mitten im Projekt stecken bleiben. Nachfolgend finden Sie eine vollständige Liste aller Komponenten, die leicht auf dem Markt erhältlich sind:

Schritt 2: Arbeiten

Da wir jetzt alle Komponenten haben, die wir in diesem Projekt verwenden werden, beginnen wir mit der Arbeit an diesem Projekt. Als Mikrocontroller-Platine werden wir ein Arduino Uno verwenden. Auf diesem Board wird ein Code geschrieben und gebrannt, der dem Board mitteilt, welche Operationen wie auszuführen sind. Eine 4×4-Tastatur wird verwendet, um die numerischen Daten einzugeben, die in den Taschenrechner berechnet werden sollen. Der Mikrocontroller führt alle arithmetischen Operationen aus und sendet dann die Ausgabe an den 16×2 LCD.

Vor dem Anschließen der Hardware ist es besser, den Code und die Schaltungsverbindungen auf Computersoftware zu simulieren und zu testen. Wir werden verwenden Proteusfür diesen Zweck. Nachdem wir die Schaltung getestet und bestätigt haben, dass sie mit der Software einwandfrei funktioniert, werden wir uns der Hardware zuwenden.

Schritt 3: Simulation der Schaltung

Bevor wir dieses Projekt auf Hardware implementieren, werden wir es zuerst auf Proteus simulieren, um zu überprüfen, ob der Code gut funktioniert oder nicht. Wenn Sie noch nie an Proteus gearbeitet haben, müssen Sie sich keine Sorgen machen. Führen Sie die folgenden Schritte aus, um die Schaltung auf Software zu simulieren.

Wenn Sie diese Software noch nicht auf Ihrem Computer installiert haben, klicken Sie hier, um sie herunterzuladen.
Nachdem die Software installiert ist, öffnen Sie die Software und erstellen Sie ein neues Projekt, indem Sie auf das IS Taste.
Proteus hat zunächst keine Arduino-Bibliothek. Wir werden es aufnehmen müssen. Die Arduino-Bibliothek für Proteus ist zusammen mit dem Code unter dem unten angegebenen Link beigefügt. Kopieren Sie die Dateien und fügen Sie sie ein C:\ProgramData\Labcenter Electronics\Proteus 8 Professional\BIBLIOTHEK.
Ein neuer Schaltplan wurde gerade geöffnet. Klick auf das P, um das Komponentenmenü zu öffnen.
Es erscheint ein Feld mit einer Suchleiste in der oberen linken Ecke. Suchen Sie die Komponente, die Sie im Projekt verwenden müssen.
Nachdem Sie alle Komponenten ausgewählt haben, sehen Sie auf der linken Seite des Bildschirms eine vollständige Liste.
Erstellen Sie einen Schaltplan wie unten gezeigt.
Öffnen Sie nun die unten angegebene Arduino-Datei. Klicken Sie im Sketch-Menü auf Kompilierte Binärdatei exportieren. Dadurch wird eine .hex-Datei generiert, die in der Simulation von Arduino in Proteus verwendet wird.
Dies sind die beiden Dateien, die generiert werden. Wir werden den ersten in unseren Simulationen verwenden.
Nachdem die HEX-Datei generiert wurde, öffnen Sie den Proteus und doppelklicken Sie auf die Mikrocontrollerplatine. Es erscheint ein Feld zum Bearbeiten der Komponente. Laden Sie dort die Hex-Datei hoch.
Da der Code hier erfolgreich hochgeladen wurde, können Sie den Rechner testen, indem Sie eine arithmetische Operation durchführen und die Ergebnisse bestätigen.

Schritt 4: Zusammenbau der Schaltung

Da die Schaltung simuliert wird und der Code einwandfrei funktioniert. Gehen wir einen Schritt weiter und montieren Sie alle Komponenten gemeinsam auf dem Veroboard ein Endprodukt zu machen. Führen Sie die folgenden Schritte aus, um alle Verbindungen in der Schaltung herzustellen.

Es gibt insgesamt 8 Pins auf der 4×4-Tastatur mit den Namen A, B, C, D, 1, 2, 3 und 4. Stellen Sie sicher, dass Sie die Pins A, B, C und D mit Pin0, Pin1 verbinden. Pin2 und Pin3 der Arduino Uno-Platine und Pin 1, 2, 3 und 4 Pins der Tastatur an Pin4, Pin5, Pin6 und Pin7 der Arduino Uno-Platine.
Verbinden Sie nun die Pins D4, D5, D6 und D7 des 16×2-LCDs mit den Pins 10, 11, 12 und 13 des Arduino-Boards.
Verbinden Sie nun die RE und EPin des LCD an Pin8 bzw. Pin9 der Arduino-Platine.
Kurz die VSS, VEE und RW Pin des LCD und verbinden Sie sie mit der Masse des Arduino Uno.
Schalten Sie das LCD ein, indem Sie das VDD Pin des LCD an die 5V des Arduino UNO.

Schritt 5: Erste Schritte mit Arduino

Arduino IDE ist eine Software, mit der Sie einen Code schreiben, debuggen und kompilieren können, der auf einem Arduino-Mikrocontroller ausgeführt wird. Dieser Code wird über diese IDE auf den Mikrocontroller hochgeladen. WENN Sie noch keine Erfahrung mit dieser Software haben, müssen Sie sich keine Sorgen machen, da das gesamte Verfahren zur Verwendung dieser Software unten aufgeführt ist.

Wenn Sie die Software noch nicht installiert haben, klicken Sie hier, um die Software herunterzuladen.
Verbinden Sie Ihr Arduino-Board mit dem PC und öffnen Sie die Systemsteuerung. Klicke auf Hardware und Ton.Jetzt offen Geräte und Drucker und suchen Sie den Port, an den Ihre Karte angeschlossen ist. Dieser Port ist auf verschiedenen Computern unterschiedlich.
Öffnen Sie nun die Arduino-IDE. Stellen Sie das Arduino-Board unter Tools auf Arduino/Genuino UNO.
Legen Sie im selben Tool-Menü die Portnummer fest. Diese Portnummer sollte genau mit der Portnummer übereinstimmen, die zuvor im Bedienfeld beobachtet wurde.
Um nun die 4 × 4-Tastatur und das 16 × 2-LCD mit Arduino IDE zu verwenden, müssen wir spezielle Bibliotheken importieren, mit denen wir Code auf Arduino Uno brennen und verwenden können. diese beiden Bibliotheken sind in dem unten angegebenen Link angehängt. Um die Bibliothek einzubinden, gehe zu Sketch > Bibliothek einschließen > ZIP-Bibliothek hinzufügen. Ein Feld wird angezeigt. Suchen Sie den ZIP-Ordner auf Ihrem Computer und klicken Sie auf OK, um die Ordner einzuschließen. Diese Bibliothek ist zusammen mit dem Code im folgenden Link angehängt.
Laden Sie den unten angehängten Code herunter und kopieren Sie ihn in Ihre IDE. Um den Code hochzuladen, klicken Sie auf den Upload-Button.

Klicken Sie hier, um den Code herunterzuladen.

Schritt 6: Den Code verstehen

Der Code ist sehr gut kommentiert. Aber dennoch, der Einfachheit halber, wird es unten erklärt.

1. Zu Beginn werden die Header-Dateien geschrieben, um die Bibliotheken aufzunehmen, damit die Tastatur und das LCD mit dem Arduino Uno-Board verbunden werden können.

#einschließen  // Header-Datei für LCD einschließen #include  // Header-Datei für Keypad einschließen

2. Danach werden zwei Variablen deklariert, die die Anzahl der Zeilen und Spalten der Tastatur enthalten. Die Tastenbelegung informiert uns über die Reihenfolge der Tasten, die in der Tastatur vorhanden sind.

konstantes Byte ROWS = 4; // Vier Zeilen der Tastatur const byte COLS = 4; // Drei Spalten der Tastatur // Definiere die Keymap char keys[ROWS][COLS] = { {'7','8','9','D'}, {'4','5',' 6','C'}, {'1','2','3','B'}, {'*','0','#','A'} };

3. Danach wird festgelegt, welche Zeile und Spalte der Tastatur mit welchem Pin des Arduino verbunden sind. Nachdem alles erledigt ist, kann eine Tastatur erstellt werden, indem alle ihre Pins zugeordnet werden.

Byte rowPins[ROWS] = { 0, 1, 2, 3 }; // Schließen Sie die Tastatur ROW0, ROW1, ROW2 und ROW3 an diese Arduino-Pins 0,1,2,3 an. Byte colPins[COLS] = { 4, 5, 6, 7 }; // Schließen Sie die Tastatur COL0, COL1 und COL2 an diese Arduino-Pins 4,5,67 an. Tastatur kpd = Tastatur (makeKeymap(keys), rowPins, colPins, ROWS, COLS); // Erstellen Sie die Tastatur

4. Danach sagen wir, welche Pins des LCD mit welchen Pins des Arduino verbunden sind.

const int rs = 8, en = 9, d4 = 10, d5 = 11, d6 = 12, d7 = 13; // Pins, an die das LCD angeschlossen ist LiquidCrystal lcd (rs, en, d4, d5, d6, d7); // Erstellen Sie das LCD

5. Dann werden einige Variablen initialisiert, um die Werte von Berechnungen zu halten und Operationen während der Laufzeit auszuführen.

lang Zahl1,Zahl2,Zahl; char-Taste,Aktion; boolesches Ergebnis = false;

6. Void-Setup () ist eine Funktion, die nur einmal ausgeführt wird, wenn der Stromkreis eingeschaltet ist. In dieser Funktion deklarieren wir, welcher Pin des Arduino-Boards verwendet wird, um den Eingang aufzunehmen und welcher zum Senden des Ausgangs verwendet wird. In dieser Funktion wird auch die Baudrate eingestellt, die im Grunde die Kommunikationsgeschwindigkeit in Bits pro Sekunde ist.

void setup () {Serial.begin (9600); lcd.begin(16, 2); // Wir verwenden ein 16 * 2 LCD-Display lcd.print ("Rechner"); //Eine Intro-Nachricht anzeigen lcd.setCursor(0, 1); // setze den Cursor auf Spalte 0, Zeile 1 Verzögerung (1000); // 1 Sekunde warten lcd.clear (); // lösche den LCD-Bildschirm}

7. CalculateResult()ist eine Funktion, die verwendet wird, um das auf der Tastatur gedrückte Zeichen zu erkennen. auf der Grundlage des gedrückten Vorzeichens entscheidet es, welche arithmetische Operation ausgeführt werden soll.

void CalculateResult () {if (action == '+') // wenn + Zeichen gedrückt wird Number = Num1 + Num2; // beide Zahlen addieren if (action=='-') // if - Zeichen wird gedrückt Zahl = Num1-Num2; // beide Zahlen subtrahieren if (action=='*') // wenn das *-Zeichen gedrückt wird Number = Num1*Num2; // beide Zahlen multiplizieren if (action=='/') // wenn / Zeichen gedrückt wird Number = Num1/Num2; // dividiere beide Zahlen }

8. DisplayResult()ist eine Funktion, die verwendet wird, um das Ergebnis auf dem LCD anzuzeigen. Zunächst setzt es den Cursor auf die Anfangsposition und druckt die erste Zahl. Dann wird der logische Operator und dann die zweite Zahl angezeigt. Nach dem Drucken des „=“-Zeichens wird die Antwort auf dem LCD angezeigt.

Void DisplayResult () {lcd.setCursor (0, 0); // setze den Cursor auf Spalte 0, Zeile 1 lcd.print (Num1); // die erste Zahl auf dem Bildschirm ausgeben lcd.print(action); // Drucken Sie das auf dem Bildschirm gedrückte Zeichen lcd.print (Num2); // Zweite Zahl auf dem Bildschirm ausgeben if (result==true) // Ergebnis anzeigen { lcd.print(" = "); // drucke das = Zeichen auf dem Bildschirm lcd.print(Number); // die Antwort auf dem Bildschirm ausgeben } }

9. DetectButtons()ist eine Funktion, die verwendet wird, um zu erkennen, welche Taste gedrückt wird. Es erkennt auch, wenn die Taste zweimal gedrückt wird. Diese Funktion gibt eine Zahl zurück, die auf der Tastatur gedrückt wird.

Void DetectButtons () {lcd.clear (); // Dann reinigen, wenn (key = = '*') // Wenn die Abbrechen-Taste gedrückt wird { Serial.println ("Button Cancel"); // einen Kommentar ausgeben Number=Num1=Num2=0; Ergebnis=falsch; aufrechtzuerhalten. Wenn (Taste == '1') // Wenn Taste 1 gedrückt wird {Serial.println ("Taste 1"); if (Zahl==0) Zahl=1; sonst Zahl = (Zahl*10) + 1; // Zweimal gedrückt} if (Taste == '4') // Wenn Taste 4 gedrückt wird { Serial.println ("Taste 4"); if (Zahl==0) Zahl=4; sonst Zahl = (Zahl*10) + 4; // Zweimal gedrückt} if (Taste == '7') // Wenn Taste 7 gedrückt wird { Serial.println ("Taste 7"); if (Zahl==0) Zahl=7; sonst Nummer = (Nummer * 10) + 7; // zweimal gedrückt} if (key == '0') // Wenn Button 0 gedrückt wird {Serial.println ("Button 0"); if (Zahl==0) Zahl=0; sonst Zahl = (Zahl*10) + 0; // Zweimal gedrückt} if (Taste == '2') // Taste 2 wird gedrückt {Serial.println ("Taste 2"); wenn (Zahl==0) Zahl=2; sonst Zahl = (Zahl*10) + 2; // Zweimal gedrückt} if (Taste == '5') // Taste 5 wird gedrückt {Serial.println ("Taste 5"); if (Zahl==0) Zahl=5; sonst Zahl = (Zahl*10) + 5; // Zweimal gedrückt} if (Taste == '8') // Taste 8 wird gedrückt {Serial.println ("Taste 8"); if (Zahl==0) Zahl=8; sonst Zahl = (Zahl*10) + 8; // zweimal gedrückt} if (key == '#') // Button # wird gedrückt {Serial.println ("Button Equal"); Zahl2=Zahl; Ergebnis = wahr; aufrechtzuerhalten. Wenn (Taste == '3') // Taste 3 gedrückt wird { Serial.println ("Taste 3"); if (Zahl==0) Zahl=3; sonst Zahl = (Zahl*10) + 3; // Zweimal gedrückt} if (Taste == '6') // Taste 6 wird gedrückt {Serial.println ("Taste 6"); if (Zahl==0) Zahl=6; sonst Zahl = (Zahl*10) + 6; // zweimal gedrückt} if (key == '9') // Taste 09 ist gedrückt {Serial.println ("Taste 9"); if (Zahl==0) Zahl=9; sonst Zahl = (Zahl*10) + 9; //Zweimal gedrückt} if (Taste == 'A' || Taste == 'B' || Taste == 'C' || Taste == 'D') //Erkennen von Schaltflächen in Spalte 4 { Num1 = Number; Zahl =0; if (key == 'A') {Serial.println ("Addition"); Aktion = '+'; } if (key == 'B') {Serial.println ("Subtraktion"); Aktion = '-'; aufrechtzuerhalten. Wenn (Schlüssel == 'C') {Serial.println ("Multiplikation"); Aktion = '*'; } if (key == 'D') {Serial.println ("Devesion"); Aktion = '/'; } Verzögerung (100); } }

10. Leere Schleife ()ist eine Funktion, die immer wieder in einer Schleife ausgeführt wird. Diese Funktion wird verwendet, um alle anderen Funktionen aufzurufen, die verwendet werden, um alle Operationen auszuführen. Diese Funktionen sind oben erläutert.

Void Schleife () { Schlüssel = kpd.getKey (); // den Wert der gedrückten Taste in einem Zeichen speichern if (key!=NO_KEY) DetectButtons(); // Funktion aufrufen if (result==true) CalculateResult(); // Funktion DisplayResult() aufrufen; // Funktion aufrufen }

Schritt 7: Testen

Nachdem wir nun alle Komponenten miteinander verbunden und den Code in den Mikrocontroller hochgeladen haben, testen wir den Rechner, ob er gut funktioniert oder nicht. Um den Taschenrechner zu testen, drücken Sie eine beliebige Zifferntaste. Drücken Sie danach EINund drücken Sie dann erneut eine beliebige Zifferntaste. Wenn Sie dies getan haben, zeigt das LCD die Addition beider Zahlen an.

Dies war das gesamte Verfahren, um einen Taschenrechner mit Arduino zu erstellen und zu testen. Jetzt können Sie Ihren eigenen Arduino-basierten Taschenrechner zu Hause herstellen.