Hoe maak je een op Arduino gebaseerde rekenmachine?

Projecten maken met Arduino Uno als microcontroller board is echt leuk als je aan embedded projecten werkt. Als je een eenvoudige rekenmachine wilt maken die in staat is om alle elementaire rekenkundige bewerkingen uit te voeren, zoals optellen, aftrekken, vermenigvuldigen en delen, dan kun je dat nu doen als je kennis hebt van het Arduino-bord. Dus in dit project gaan we een Arduino Uno gebruiken om een eenvoudige rekenmachine te maken. We zullen een 4 × 4 toetsenbord integreren om de input te sturen en een 16 × 2 LCD om de output van onze operaties te zien.

Dus, aangezien we nu de basisuittreksel van ons project kennen, wat we uiteindelijk willen bereiken, laten we doorgaan en beginnen met het verzamelen van meer informatie om aan dit project te beginnen.

Hoe maak je een eenvoudige rekenmachine op Arduino?

Stap 1: De componenten verzamelen

Voordat u met een project begint, is de eerste stap het maken van een volledige lijst van alle componenten die in het project zullen worden gebruikt. Dit is een perfecte aanpak omdat het veel tijd bespaart en voorkomt dat we midden in het project vast komen te zitten. Dus een volledige lijst van alle componenten die gemakkelijk op de markt verkrijgbaar zijn, wordt hieronder gegeven:

Stap 2: werken

Aangezien we nu alle componenten hebben die we in dit project gaan gebruiken, laten we aan dit project gaan werken. We gaan een Arduino Uno gebruiken als microcontrollerbord. Op dit bord wordt een code geschreven en gebrand die het bord vertelt welke bewerkingen moeten worden uitgevoerd en hoe. Een 4 × 4 toetsenbord wordt gebruikt om de numerieke gegevens in te voeren die in de rekenmachine moeten worden berekend. De microcontroller voert alle rekenkundige bewerkingen uit en stuurt vervolgens de uitvoer naar het 16 × 2 LCD.

Voordat u de hardware aansluit, is het beter om de code en de circuitverbindingen op computersoftware te simuleren en te testen. We zullen gebruiken ProteusVoor dit doeleinde. Nadat we het circuit hebben getest en hebben bevestigd dat het perfect werkt op de software, gaan we naar de hardware.

Stap 3: Simulatie van het circuit

Voordat we dit project op hardware implementeren, zullen we het eerst op Proteus simuleren om te controleren of de code goed werkt of niet. Als u nog niet eerder aan Proteus heeft gewerkt, hoeft u zich nergens zorgen over te maken. Doorloop de volgende stappen om het circuit op software te simuleren.

Als u deze software nog niet op uw computer heeft geïnstalleerd, klik dan hier om deze te downloaden.
Nadat de software is geïnstalleerd, opent u de software en maakt u een nieuw project door op het ISIS knop.
Proteus heeft aanvankelijk geen Arduino-bibliotheek. We zullen het moeten opnemen. De Arduino-bibliotheek voor proteus is bijgevoegd samen met de code in de onderstaande link. Kopieer de bestanden en plak ze in C: \ ProgramData \ Labcenter Electronics \ Proteus 8 Professional \ BIBLIOTHEEK.
Er is net een nieuw schema geopend. Klik op de P.knop om het componentmenu te openen.
Er verschijnt een vak met een zoekbalk in de linkerbovenhoek. Zoek de component die u in het project moet gebruiken.
Nadat u alle componenten heeft geselecteerd, ziet u aan de linkerkant van het scherm een volledige lijst.
Maak een schakelschema zoals hieronder weergegeven.
Open nu het Arduino-bestand dat hieronder wordt weergegeven. Klik in het Sketch-menu op Export gecompileerd binair bestand. Dit genereert een .hex-bestand dat zal worden gebruikt in de simulatie van Arduino in Proteus.
Dit zijn de twee bestanden die worden gegenereerd. We zullen de eerste gebruiken in onze simulaties.
Nu het HEX-bestand is gegenereerd, opent u de proteus en dubbelklikt u op de microcontroller-kaart. Er verschijnt een vak om de component te bewerken. Upload daar het hex-bestand.
Aangezien de code hier met succes is geüpload, kunt u de rekenmachine testen door een rekenkundige bewerking uit te voeren en de resultaten te bevestigen.

Stap 4: Het circuit in elkaar zetten

Omdat het circuit is gesimuleerd en de code er prima op werkt. Laten we een stap verder gaan en alle componenten samenvoegen op de Veroboard om een eindproduct te maken. Doorloop de volgende stappen om alle verbindingen in het circuit te maken.

Er zijn in totaal 8 pinnen op het 4 × 4 toetsenbord genaamd A, B, C, D, 1, 2, 3 en 4. Zorg ervoor dat u de A, B. C en D pin aansluit op pin0, pin1, pin2 en pin3 van het Arduino Uno-bord en pin 1, 2, 3 en 4 pinnen van het toetsenbord op respectievelijk de pin4, pin5, pin6 en pin7 van het Arduino Uno-bord.
Verbind nu de D4-, D5-, D6- en D7-pin van het 16 × 2 LCD-scherm met respectievelijk pin10, pin11, pin12 en pin13 van het Arduino-bord.
Sluit nu het OPNIEUW en E.pin van het LCD-scherm op respectievelijk pin8 en pin9 van het Arduino-bord.
Kort de VSS, VEE en RW pin van het LCD-scherm en verbind ze met de aarde van de Arduino Uno.
Schakel het LCD-scherm in door de VDD pin van de LCD op de 5V van de Arduino UNO.

Stap 5: Aan de slag met Arduino

Arduino IDE is software waarop u een code kunt schrijven, debuggen en compileren die op een Arduino-microcontroller kan worden uitgevoerd. Deze code wordt via deze IDE naar de microcontroller geüpload. ALS u geen eerdere ervaring met deze software heeft, hoeft u zich nergens zorgen over te maken, want de hele procedure om deze software te gebruiken wordt hieronder gegeven.

Als u de software nog niet heeft geïnstalleerd, klikt u hier om de software te downloaden.
Verbind je Arduino-bord met de pc en open het Configuratiescherm. Klik op Hardware en geluid.Nu open Apparaten en printer en zoek de poort waarop je board is aangesloten. Deze poort is verschillend op verschillende computers.
Open nu de Arduino IDE. Stel vanuit Tools het Arduino-bord in op Arduino / Genuino UNO.
Stel in hetzelfde Tool-menu het poortnummer in. Dit poortnummer moet exact hetzelfde zijn als het poortnummer dat eerder in het bedieningspaneel werd waargenomen.
Om nu een 4 × 4-toetsenbord en het 16 × 2 LCD-scherm met Arduino IDE te gebruiken, moeten we speciale bibliotheken importeren waarmee we code op Arduino Uno kunnen branden en gebruiken. deze twee bibliotheken zijn bijgevoegd in de onderstaande link. Ga naar om de bibliotheek op te nemen Schets> Bibliotheek opnemen> ZIP-bibliotheek toevoegen. Er verschijnt een vak. Zoek de ZIP-map op uw computer en klik op OK om de mappen op te nemen. Deze bibliotheek is bijgevoegd samen met de code in de onderstaande link.
Download de onderstaande code en kopieer deze naar uw IDE. Om de code te uploaden, klikt u op de uploadknop.

Klik hier om de code te downloaden.

Stap 6: De code begrijpen

De code is zeer goed becommentarieerd. Maar toch, voor uw gemak, wordt het hieronder uitgelegd.

1. In het begin worden de header-bestanden geschreven om de bibliotheken te bevatten, zodat het toetsenbord en het LCD-scherm kunnen worden gekoppeld aan het Arduino Uno-bord.

#inclusief  // Inclusief koptekstbestand voor LCD #include  // Inclusief koptekstbestand voor toetsenbord

2. Daarna worden twee variabelen gedeclareerd die het aantal rijen en kolommen van het toetsenbord bevatten. De keymap vertelt ons over de volgorde van de toetsen in het toetsenbord.

const byte RIJEN = 4; // Vier rijen van het toetsenbord const byte COLS = 4; // Drie kolommen van het toetsenbord // Definieer de Keymap-tekens [ROWS] [COLS] = {{'7', '8', '9', 'D'}, {'4', '5', ' 6 ',' C '}, {' 1 ',' 2 ',' 3 ',' B '}, {' * ',' 0 ',' # ',' A '}};

3. Daarna wordt gespecificeerd welke rij en kolom van het keypad met welke pin van de Arduino zijn verbonden. Nadat alles is voltooid, kan een toetsenbord worden gemaakt door alle pinnen in kaart te brengen.

byte rowPins [ROWS] = {0, 1, 2, 3}; // Sluit toetsenbord ROW0, ROW1, ROW2 en ROW3 aan op deze Arduino-pinnen 0,1,2,3 respectievelijk. byte colPins [COLS] = {4, 5, 6, 7}; // Verbind toetsenbord COL0, COL1 en COL2 met respectievelijk deze Arduino-pinnen 4,5,67. Toetsenbord kpd = Toetsenbord (makeKeymap (toetsen), rowPins, colPins, ROWS, COLS); // Maak het toetsenbord

4. Daarna vertellen we dat welke pinnen van het LCD-scherm zijn aangesloten op welke pinnen van de Arduino.

const int rs = 8, en = 9, d4 = 10, d5 = 11, d6 = 12, d7 = 13; // Pinnen waarop LCD is aangesloten LiquidCrystal lcd (rs, en, d4, d5, d6, d7); // Maak de LCD

5. Vervolgens worden enkele variabelen geïnitialiseerd om de waarden van berekeningen vast te houden en bewerkingen uit te voeren tijdens de looptijd.

lang Num1, Num2, Getal; char-toets, actie; booleaans resultaat = false;

6. leegte setup () is een functie die slechts één keer wordt uitgevoerd wanneer het circuit is ingeschakeld. In deze functie geven we aan welke pin van het Arduino-bord zal worden gebruikt om de invoer te nemen en welke zal worden gebruikt om de uitvoer te verzenden. De baudrate wordt ook ingesteld in deze functie, wat in feite de communicatiesnelheid is in bits per seconde.

leegte setup () {Serial.begin (9600); lcd.begin (16, 2); // We gebruiken een 16 * 2 LCD-scherm lcd.print ("Calculator"); // Toon een introbericht lcd.setCursor (0, 1); // zet de cursor op kolom 0, regel 1 vertraging (1000); // Wacht 1 seconde lcd.clear (); // maak het LCD-scherm leeg}

7. BerekenResultaat ()is een functie die wordt gebruikt om het teken dat op het toetsenbord wordt ingedrukt, te detecteren. op basis van het ingedrukte teken, zal het beslissen welke rekenkundige bewerking moet worden uitgevoerd.

void CalculateResult () {if (action == '+') // if + teken wordt ingedrukt Getal = Num1 + Num2; // voeg beide nummers toe if (action == '-') // als - teken wordt ingedrukt Number = Num1-Num2; // trek beide getallen af if (action == '*') // als * teken wordt ingedrukt Getal = Num1 * Num2; // vermenigvuldig beide getallen if (action == '/') // als / teken wordt ingedrukt Getal = Num1 / Num2; // deel beide getallen}

8. DisplayResultaat ()is een functie die wordt gebruikt om het resultaat op het LCD-scherm weer te geven. Allereerst zet het de cursor op de beginpositie en drukt het het eerste cijfer af. Vervolgens wordt de logische operator weergegeven en vervolgens het tweede nummer. Nadat het teken "=" is afgedrukt, wordt het antwoord op het LCD-scherm weergegeven.

leegte DisplayResult () {lcd.setCursor (0, 0); // zet de cursor op kolom 0, regel 1 lcd.print (Num1); // print het eerste nummer op het scherm lcd.print (actie); // print het bord gedrukt op het scherm lcd.print (Num2); // print het tweede nummer op het scherm if (result == true) // Toon het resultaat {lcd.print ("="); // print het = teken op het scherm lcd.print (nummer); // print het antwoord op het scherm}}

9. DetectButtons ()is een functie die wordt gebruikt om te detecteren welke knop wordt ingedrukt. het zal ook detecteren of de knop twee keer wordt ingedrukt. Deze functie retourneert een nummer dat op het toetsenbord wordt ingedrukt.

leegte DetectButtons () {lcd.clear (); // Maak het vervolgens schoon if (key == '*') // Als de knop Annuleren wordt ingedrukt {Serial.println ("Knop Annuleren"); // print een opmerking Number = Num1 = Num2 = 0; resultaat = onwaar; } if (key == '1') // Als knop 1 wordt ingedrukt {Serial.println ("Button 1"); if (Number == 0) Number = 1; anders Nummer = (Nummer * 10) + 1; // Twee keer gedrukt} if (key == '4') // Als knop 4 wordt ingedrukt {Serial.println ("Button 4"); if (Number == 0) Number = 4; anders Getal = (Getal * 10) + 4; // Twee keer gedrukt} if (key == '7') // Als knop 7 wordt ingedrukt {Serial.println ("Button 7"); if (Number == 0) Number = 7; anders Getal = (Getal * 10) + 7; // Twee keer gedrukt} if (key == '0') // Als knop 0 is ingedrukt {Serial.println ("Button 0"); if (Number == 0) Number = 0; anders Nummer = (Nummer * 10) + 0; // Twee keer gedrukt} if (key == '2') // Knop 2 is ingedrukt {Serial.println ("Knop 2"); if (Number == 0) Number = 2; anders Getal = (Getal * 10) + 2; // Twee keer gedrukt} if (key == '5') // Knop 5 wordt ingedrukt {Serial.println ("Knop 5"); if (Number == 0) Number = 5; anders Getal = (Getal * 10) + 5; // Twee keer gedrukt} if (key == '8') // Knop 8 is ingedrukt {Serial.println ("Knop 8"); if (Number == 0) Number = 8; anders Nummer = (Nummer * 10) + 8; // Tweemaal ingedrukt} if (key == '#') // Knop # wordt ingedrukt {Serial.println ("Button Equal"); Num2 = nummer; resultaat = waar; } if (key == '3') // Knop 3 wordt ingedrukt {Serial.println ("Knop 3"); if (Number == 0) Number = 3; anders Getal = (Getal * 10) + 3; // Twee keer gedrukt} if (key == '6') // Knop 6 is ingedrukt {Serial.println ("Knop 6"); if (Number == 0) Number = 6; anders Getal = (Getal * 10) + 6; // Tweemaal ingedrukt} if (key == '9') // Knop 09 wordt ingedrukt {Serial.println ("Button 9"); if (Number == 0) Number = 9; anders Nummer = (Nummer * 10) + 9; // Twee keer ingedrukt} if (key == 'A' || key == 'B' || key == 'C' || key == 'D') // Detectie van knoppen in kolom 4 {Num1 = Number; Getal = 0; if (key == 'A') {Serial.println ("Addition"); actie = '+'; } if (key == 'B') {Serial.println ("Aftrekken"); action = '-'; } if (key == 'C') {Serial.println ("Vermenigvuldiging"); action = '*'; } if (key == 'D') {Serial.println ("Devesion"); action = '/'; } vertraging (100); }}

10. leegte lus ()is een functie die keer op keer in een lus wordt uitgevoerd. Deze functie wordt gebruikt om alle andere functies op te roepen die zullen worden gebruikt om alle bewerkingen uit te voeren. Deze functies worden hierboven uitgelegd.

void loop () {key = kpd.getKey (); // opslaan van ingedrukte sleutelwaarde in een char if (key! = NO_KEY) DetectButtons (); // roep functie if (result == true) CalculateResult (); // roep functie DisplayResult (); // call functie}

Stap 7: testen

Nu we alle componenten met elkaar hebben verbonden en de code in de microcontroller hebben geüpload, gaan we de rekenmachine testen of deze goed werkt of niet. Druk op een willekeurige numerieke toets om de rekenmachine te testen. Na die pers EENen druk vervolgens opnieuw op een willekeurige numerieke toets. Als u dit heeft gedaan, zal het LCD-scherm de optelling van beide nummers weergeven.

Dit was de hele procedure om een rekenmachine te maken en te testen met Arduino. Nu kunt u genieten van het thuis maken van uw eigen op Arduino gebaseerde rekenmachine.