Programmering og koding

Myntautomat med Arduino: myntakseptor, LCD og lås

Hvit 3D-printet myntautomat med myntakseptor, blå LCD som viser pris og saldo, rød lysdiode og tre norske mynter foran

Slipp en tikrone i sprekken, og skjermen teller opp. Når du har betalt nok, lyser den grønne lysdioden, låsen klikker, og luken med premien kan åpnes. Her bygger du en myntautomat med en programmerbar myntakseptor, en Arduino UNO R4 WiFi, en LCD-skjerm med to linjer på 16 tegn og en 12 V-lås, og du får et ferdig kabinett du kan 3D-printe.

Myntautomaten i tre nivåer: saldo og rød lysdiode, åpen luke med premie og grønn lysdiode, og pip med totalen i sparebøssen.
Slik skal det virke. Dette er en tegning. Nivå 1: skjermen viser pris og saldo, og rød lysdiode lyser til du har betalt. Nivå 2: låsen slipper luken når du har betalt, og grønn lysdiode lyser. Nivå 3: et pip for hver mynt og en teller som husker alt som er puttet inn.
Nivå
Nybegynner til viderekommen, nivå 3 er et lite tillegg
Tid
Rundt 3 timer, pluss kabinettet
Lodding
Bare I²C-adapteren på LCD-en
Spenning
12 V fra én strømforsyning
Du lærer
Pulser og avbrudd, I²C-skjerm, MOSFET og lås, tilstander med millis()
Kort forklartMyntakseptoren kjenner igjen mynter på diameter, tykkelse og hvor fort de faller, og sender en kort puls ned til 0 V for hver mynt. Du bestemmer selv antall pulser: her gir 5 kr én puls, 10 kr to og 20 kr fire, så hver puls er verdt 5 kr. Den hvite ledningen går til D2 på UNO med en motstand på 10 kΩ opp til 5 V, og programmet teller pulsene med et avbrudd. Låsen styres med en MOSFET-modul og en friløpsdiode, og en magnetkontakt på luken forteller når premien er tatt.

Dette trenger du på bordet

Alt kobles på et koblingsbrett med koblingsledninger. Den eneste loddingen er I²C-adapteren som skal sitte bak på LCD-skjermen. Myntakseptoren og låsen går på 12 V, og UNO-kortet får strøm fra den samme forsyningen. USB-kabelen trenger du bare når du laster opp kode.

  • Myntakseptor med kromfarget frontplate, myntsprekk og returlomme
    Programmerbar myntakseptor, MR-017431 stk, kjenner igjen tre mynttyper
    kr 829,00
    På lager
  • Arduino UNO R4 WiFi sett på skrå
    Arduino UNO R4 WiFi1 stk, teller myntene og styrer alt
    kr 599,00
    På lager
  • Blå LCD-skjerm med 2 linjer og 16 tegn
    LCD 16x2 med blått baklys1 stk, viser pris og saldo
    kr 99,00
    På lager
  • I²C-adapter med PCF8574 og blå kontrastskrue
    I²C-adapter for HD447801 stk, loddes bak på skjermen
    kr 139,00
    På lager
  • LED-sett med lysdioder på 5 mm og motstander
    LED-sett med 1,2 kΩ-motstander1 grønn og 1 rød lysdiode, 2 motstander
    kr 79,00
    På lager
  • Motstandssett med 16 verdier på papirremser
    Motstandssett, 16 verdier1 motstand på 10 kΩ til myntsignalet
    kr 149,00
    På lager
  • Strømforsyning på 12 V og 2,5 A med DC-plugg
    Strømforsyning 12 V, 2,5 A1 stk, strøm til hele automaten
    kr 239,00
    På lager
  • Liten modul med DC-kontakt, lysdiode og fire pinner
    Modul med DC-kontakt1 stk, fører 12 V fra pluggen til koblingsbrettet
    kr 79,00
    På lager
  • Loddefritt koblingsbrett med 830 hull
    Koblingsbrett, 830 hull1 stk, med skinner for 12 V, 5 V og jord
    kr 99,00
    På lager
  • Lite koblingsbrett, 170 hull, MR-012781 stk, bare når kretsen skal inn i kabinettet
    kr 49,00
    På lager
  • Sett med koblingsledninger i flere farger
    Koblingsledninger, 140 stkHann-hunn til modulene, hann-hann ellers
    kr 99,00
    På lager
  • Elektrisk lås MR-01826 i metallhus med skrå låsebolt
    kr 299,00
    På lager
  • Rød MOSFET-modul med IRF520, to blå skruterminaler og tre pinner
    MOSFET-modul med IRF520, MR-000951 stk, nivå 2, slår låsen av og på
    kr 99,00
    På lager
  • Likeretterdioder av typen 1N4007 med aksiale ledninger
    Dioder 1N4007, 10 stk1 stk som friløpsdiode over låsen, nivå 2
    kr 25,00
    På lager
  • Hvit magnetkontakt i to deler for dør eller vindu
    Magnetkontakt for dør, MR-001481 stk, nivå 2, merker når luken åpnes
    kr 99,00
    På lager
  • Blå summermodul med tre pinner merket GND, I/O og VCC
    Summermodul, aktiv LOW1 stk, bare til nivå 3
    kr 95,00
    På lager

Andre størrelser finner du under koblingsbrett og prototyping og koblingsledninger. Et multimeter er ikke påkrevd, men to av kontrollpunktene bruker det. Til kabinettet trenger du M3-skruer, se avsnittet om kabinettet.

Slik virker myntakseptoren

Mynten ruller gjennom en kanal med sensorer som måler diameter og tykkelse og tar tiden mens den faller. Ligner målingene på en av de tre mynttypene du har lært den, slipper akseptoren mynten ned gjennom bunnen og sender pulser på den hvite ledningen. Ukjente mynter, knapper og skiver kommer ut igjen i returlommen foran.

Myntakseptoren sett fra venstre side med display, knappene SET, ADD og MINUS, bryteren på NO og de fire ledningene.
Forenklet tegning, ikke i målestokk. Displayet og de tre knappene sitter på venstre side av akseptoren, og derfor programmerer du den før den skrus fast i kabinettet. Den grå ledningen bruker vi ikke.
LedningNavnKobles tilHva den gjør
RødDC 12 V+12 VStrøm til akseptoren, rundt 50 mA og opptil 350 mA i et kort øyeblikk
SvartGNDJord, felles med UNOMinus
HvitCOIND2, og 10 kΩ til 5 VTrekkes ned til 0 V én gang per puls
GråCOUNTERIngentingTil en mekanisk teller. Ikke i bruk her

Den hvite ledningen gir ikke ut spenning selv. Inne i akseptoren sitter en transistor som kobler ledningen til jord under hver puls, og ellers flyter den fritt. Det heter åpen kollektor. Motstanden på 10 kΩ fra ledningen til 5 V holder derfor signalet høyt mellom pulsene. Slik får UNO bare 5 V på pinnen, selv om akseptoren går på 12 V.

Tidsdiagram for den hvite ledningen: én puls ned til 0 V for 5 kr, to for 10 kr og fire for 20 kr, med 300 ms stille til slutt.
Tegnet eksempel, ikke en måling. Signalet ligger på 5 V og faller til 0 V én gang for hver puls. Når det har vært stille i 300 ms, regner programmet mynten som ferdig talt.
Test deg selv: hvorfor gir 20 kr fire pulser og ikke tre?

Fordi hver puls skal være like mye verdt. Med 5 kr per puls blir 10 kr to pulser og 20 kr fire. Da trenger programmet bare én regel: antall pulser ganger 5 kr. Du kunne valgt én, to og tre pulser, men da måtte programmet slå opp hva hvert antall betyr, og en tapt puls ville gjort 20 kr om til 10 kr.

Lær akseptoren de tre myntene

Akseptoren programmeres med knappene på siden og et lite display med to sifre. Du gjør det to ganger: først stiller du inn hvor mange mynttyper og hvor mange pulser hver av dem skal gi, deretter putter du inn prøvemynter, slik at akseptoren lærer målene til hver mynt. Gjør dette på bordet før akseptoren skrus fast. Akseptoren trenger bare 12 V for å bli programmert, så koble foreløpig bare den røde og den svarte ledningen.

MynttypeMyntH: prøvemynterP: pulserF: nøyaktighet
15 kr2018
210 kr2028
320 kr2048

Innstillinger: E, H, P og F

  1. Sett bryteren merket NO/NC på NO. Da ligger den hvite ledningen høyt mellom pulsene, slik koden forventer. Har akseptoren en bryter merket A og B, lar du den stå på A.
  2. Koble den røde ledningen til +12 V og den svarte til minus, for eksempel på skinnene på koblingsbrettet slik avsnittet om strøm viser. Displayet skal lyse.
  3. Hold ADD og MINUS inne samtidig til displayet viser A. På noen akseptorer heter knappene MGN og MAX.
  4. Trykk på SET, eller hold den inne et øyeblikk, til displayet viser E. Velg 3 med ADD og MINUS: tre mynttyper.
  5. Trykk på SET. Displayet viser H1. Velg 20 prøvemynter for mynttype 1, det høyeste tallet.
  6. Trykk på SET. Displayet viser P1. Velg 1 puls.
  7. Trykk på SET. Displayet viser F1. Velg 8. Lavere tall gjør akseptoren strengere, og produsenten anbefaler 8.
  8. Gjenta for H2, P2 og F2 (20, 2 og 8) og for H3, P3 og F3 (20, 4 og 8). Når displayet viser E igjen, trekker du ut 12 V-pluggen og setter den i igjen. Først da lagres innstillingene.

Prøvemynter: A1, A2 og A3

  1. Trykk på SET til displayet viser A, og én gang til, så det viser A1. Den første lampen ved displayet lyser.
  2. Putt inn en femkrone 20 ganger. Du kan bruke den samme mynten om og om igjen: den faller ut nederst, så hold en kopp under.
  3. Når lampene har løpt rundt et par ganger, viser displayet A2. Går ikke displayet videre av seg selv, holder du SET inne til A2 vises. Putt inn en tikrone 20 ganger.
  4. Ved A3 putter du inn en tjuekrone 20 ganger. Når lampene har løpt rundt igjen, er akseptoren ferdig.
  5. Prøv alle tre myntene og en enkrone. De tre skal falle gjennom, og enkronen skal komme ut i returlommen.

Strøm: én 12 V-plugg til alt

Myntakseptoren og låsen trenger 12 V, og UNO R4 WiFi tåler 6 til 24 V på pinnen VIN. Én strømforsyning på 12 V og 2,5 A holder derfor til hele automaten: akseptoren trekker rundt 50 mA, låsen 0,4 A mens den er åpen, og UNO med skjerm under 0,2 A. UNO lager selv 5 V, og den spenningen bruker vi til skjermen, lysdiodene og motstanden på myntsignalet.

  • Øverste skinnepar er 12 V. Pluss og minus fra DC-kontaktmodulen går hit, sammen med akseptoren, VIN på UNO og senere MOSFET-modulen.
  • Nederste skinnepar er 5 V. Pinnen 5V på UNO går til plusskinnen nederst. Hit kobler du skjermen og motstanden på 10 kΩ.
  • Jord er felles. Koble de to minusskinnene sammen med en svart ledning. Uten felles jord har ikke signalene noe å måles mot.
12 V skal aldri inn på en annen pinne enn VIN. Bruk røde ledninger til 12 V og en annen farge til 5 V, og mål skinnene før du kobler til skjermen. Havner 12 V på 5V, SDA eller en D-pinne, kan UNO-kortet og skjermen bli ødelagt.

Nivå 1: myntteller med LCD og to lysdioder

Nivå 1: nybegynner. Tid: rundt 1,5 timer medregnet programmeringen av akseptoren. Du trenger myntakseptoren, UNO R4 WiFi, LCD 16x2 med I²C-adapter, én grønn og én rød lysdiode med to motstander på 1,2 kΩ fra LED-settet, én motstand på 10 kΩ fra motstandssettet, 12 V-forsyningen, modulen med DC-kontakt, koblingsbrett og koblingsledninger. Flere størrelser finner du under koblingsbrett og koblingsledninger.

Skjermen viser prisen øverst og saldoen nederst. Den røde lysdioden lyser mens automaten venter på penger. Når saldoen når 20 kr, står det «Takk!» på skjermen i fire sekunder, den grønne lysdioden lyser, og prisen trekkes fra saldoen. Betaler du for mye, blir resten stående som saldo til neste gang.

Koblingstegning for nivå 1: myntakseptor med 10 kΩ til 5 V og D2, rød og grønn lysdiode på D6 og D5, LCD på I²C og UNO R4 på 12 V.
Det øverste skinneparet har 12 V og jord, det nederste 5 V og jord, og en svart ledning binder minusskinnene sammen. På brettet ditt kan pluss og minus være trykt i motsatt rekkefølge: følg fargen og tegnet på skinnen, ikke plasseringen. Den hvite ledningen går til D2, D6 går via 1,2 kΩ til rød lysdiode og D5 til grønn. SDA går til SDA og SCL til SCL.
  1. Lodd I²C-adapteren bak på skjermen med pinne 1 mot pinne 1, slik guiden om LCD 16x2 viser.
  2. Trekk ut USB-kabelen og 12 V-pluggen. Koble en VCC-pinne på DC-kontaktmodulen til plusskinnen øverst og en GND-pinne til minusskinnen øverst.
  3. Koble VIN på UNO til plusskinnen øverst og en GND-pinne på UNO til minusskinnen nederst. Koble 5V på UNO til plusskinnen nederst, og koble de to minusskinnene sammen.
  4. Akseptoren: rød ledning i plusskinnen øverst, svart i minusskinnen øverst og hvit i en ledig kolonne midt på brettet. Den grå ledningen lar du henge, med enden teipet.
  5. Sett 12 V-pluggen i et øyeblikk, og mål den hvite ledningen mot minus. Den skal ikke vise 12 V. Trekk ut pluggen igjen.
  6. Sett motstanden på 10 kΩ fra kolonnen med den hvite ledningen til plusskinnen nederst (5 V), og koble den samme kolonnen til D2.
  7. Lysdiodene: D5 går gjennom en motstand på 1,2 kΩ til det lange beinet på den grønne lysdioden, og D6 gjennom den andre motstanden til den røde. De korte beina går til minusskinnen.
  8. Skjermen: GND til minusskinnen, VCC til plusskinnen nederst (5 V), SDA til SDA og SCL til SCL på UNO. SDA og SCL er de to pinnene ved AREF.
  9. Sett 12 V-pluggen i, og mål før du går videre: rundt 12 V mellom plusskinnen og minusskinnen øverst, og rundt 5 V nederst. Er de byttet om, trekker du ut pluggen og retter opp.
Ledningene fra akseptoren sitter dårlig i brettet

Ledningene er flertrådete. Vri trådene stramt sammen før du stikker dem i brettet. Holder det ikke, skjøter du hver ledning med en hann-hann-ledning i en liten skruklemme, eller lodder på en hannpinne og trekker krympestrømpe over.

Last opp koden

  1. Installer Arduino IDE 2 fra arduino.cc. Åpne Boards Manager, søk etter «UNO R4» og installer «Arduino UNO R4 Boards».
  2. Åpne Library Manager, søk etter hd44780 og installer biblioteket til Bill Perry. Det finner selv adressen til I²C-adapteren.
  3. Koble UNO til datamaskinen med en USB-C-kabel. Velg «Arduino UNO R4 WiFi» og porten som dukker opp.
  4. Lim inn koden under, og trykk på pilen Upload. Det er greit at 12 V-pluggen står i samtidig.
  5. Åpne Serial Monitor, og velg 9600 baud.
// Nivå 1: myntteller med LCD 16x2 og to lysdioder.
// Myntakseptoren sender én kort puls for hver 5 kr: 5 kr = 1, 10 kr = 2, 20 kr = 4.
#include <Wire.h>
#include <hd44780.h>
#include <hd44780ioClass/hd44780_I2Cexp.h>

const byte COIN_PIN = 2;   // hvit ledning (COIN), 10 kΩ til 5V
const byte GREEN_LED = 5;  // grønn: nok penger
const byte RED_LED = 6;    // rød: sett inn mynt

const int PRICE_KR = 20;                // hva det koster
const int KR_PER_PULSE = 5;             // én puls er 5 kr
const unsigned long MIN_PULSE_MS = 5;   // kortere pulser er støy
const unsigned long COIN_DONE_MS = 300; // stille så lenge: mynten er ferdig talt
const unsigned long THANKS_MS = 4000;   // så lenge «Takk!» vises

hd44780_I2Cexp lcd;

volatile byte pulses = 0;
volatile unsigned long lastPulseMs = 0;
volatile unsigned long fallMs = 0;

int balanceKr = 0;
unsigned long thanksSince = 0;
bool thanking = false;

// Kjøres av maskinvaren hver gang COIN skifter mellom 5 V og 0 V.
// En puls teller først når den er ferdig og har vart lenge nok.
void coinEdge() {
  unsigned long now = millis();
  if (digitalRead(COIN_PIN) == LOW) {
    fallMs = now;                       // pulsen begynner
  } else if (now - fallMs >= MIN_PULSE_MS) {
    pulses++;                           // pulsen er ferdig og ekte
    lastPulseMs = now;
  }
}

void showBalance() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Pris: ");
  lcd.print(PRICE_KR);
  lcd.print(" kr");
  lcd.setCursor(0, 1);
  lcd.print("Saldo: ");
  lcd.print(balanceKr);
  lcd.print(" kr");
  digitalWrite(GREEN_LED, LOW);
  digitalWrite(RED_LED, HIGH);
}

void setup() {
  Serial.begin(9600);
  pinMode(GREEN_LED, OUTPUT);
  pinMode(RED_LED, OUTPUT);
  pinMode(COIN_PIN, INPUT);  // motstanden på 10 kΩ holder pinnen på 5 V

  int status = lcd.begin(16, 2);
  if (status) {
    hd44780::fatalError(status);
  }

  attachInterrupt(digitalPinToInterrupt(COIN_PIN), coinEdge, CHANGE);
  showBalance();
  Serial.println("Klar. Sett inn en mynt.");
}

void loop() {
  // Les telleren uten at avbruddet endrer den midt i lesingen.
  noInterrupts();
  byte count = pulses;
  unsigned long last = lastPulseMs;
  interrupts();

  if (count > 0 && millis() - last >= COIN_DONE_MS) {
    noInterrupts();
    pulses = 0;
    interrupts();

    int coinKr = count * KR_PER_PULSE;
    balanceKr += coinKr;
    Serial.print("Mynt: ");
    Serial.print(coinKr);
    Serial.print(" kr, saldo ");
    Serial.print(balanceKr);
    Serial.println(" kr");

    if (balanceKr >= PRICE_KR) {
      balanceKr -= PRICE_KR;
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Takk!");
      lcd.setCursor(0, 1);
      lcd.print("Betalt ");
      lcd.print(PRICE_KR);
      lcd.print(" kr");
      digitalWrite(RED_LED, LOW);
      digitalWrite(GREEN_LED, HIGH);
      thanking = true;
      thanksSince = millis();
      Serial.println("Betalt!");
    } else if (!thanking) {
      showBalance();
    }
  }

  if (thanking && millis() - thanksSince >= THANKS_MS) {
    thanking = false;
    showBalance();
  }
}

Dette gjør de viktigste delene:

  • attachInterrupt(..., CHANGE) får maskinvaren til å kjøre coinEdge() hver gang den hvite ledningen skifter nivå, uansett hva resten av programmet holder på med. En puls varer bare 20 til 100 ms, og det er lett å gå glipp av den med en vanlig digitalRead() i loop().
  • MIN_PULSE_MS er et filter. En puls teller først når den er over og har vart minst 5 ms. Korte forstyrrelser på ledningen blir ikke til penger.
  • COIN_DONE_MS er pausen som skiller én mynt fra den neste. Har det vært stille i 300 ms, gjøres pulsene om til kroner.
  • volatile og noInterrupts() hører sammen. Variablene endres av avbruddet, så loop() slår avbruddet kort av mens den leser dem.
  • KR_PER_PULSE og PRICE_KR er de to tallene du endrer hvis du vil ha en annen pris eller et annet antall pulser.

Putt inn en tikrone og to femkroner. Serial Monitor skal vise dette, og skjermen følger med:

Klar. Sett inn en mynt.
Mynt: 10 kr, saldo 10 kr
Mynt: 5 kr, saldo 15 kr
Mynt: 5 kr, saldo 20 kr
Betalt!

Nivå 2: luken åpnes når du har betalt

Nivå 2: viderekommen. Tid: rundt 1 time. Du bygger videre på nivå 1 og legger til den elektriske låsen MR-01826, MOSFET-modulen MR-00095, én 1N4007-diode og magnetkontakten MR-00148.

Nå skal betalingen åpne en luke. Låsen har en skrå bolt som står ute uten strøm. Med 12 V trekkes bolten inn i tre sekunder, og luken kan åpnes. Magnetkontakten forteller programmet at luken faktisk ble åpnet. Blir luken ikke åpnet, prøver programmet på nytt, og etter fem forsøk står pengene som saldo i stedet for å forsvinne.

Koblingstegning for nivå 2: låsen og en diode på MOSFET-modulen, SIG fra D8, og magnetkontakten mellom D3 og jord.
Delene fra nivå 1 står som før, men er ikke tegnet. D8 går til SIG, D3 til NC på magnetkontakten og COM til minusskinnen. Dioden sitter i V+ og V- med stripen i V+, og pinnen VCC på modulen står tom.

Låsen trekker 0,4 A, femti ganger mer enn en pinne på UNO tåler. D8 styrer derfor en MOSFET som kobler låsen til jord, og dioden over låsen tar imot spenningstoppen når strømmen brytes. Hvorfor dioden må med og hvordan modulen virker, står i guiden om elektromagneter og solenoider.

  1. Trekk ut 12 V-pluggen og USB-kabelen.
  2. Koble skruterminalen VIN på MOSFET-modulen til plusskinnen øverst (12 V) og skruterminalen GND til minusskinnen. Bruk hann-hann-ledninger.
  3. Koble pinnen SIG på modulen til D8 og pinnen GND til minusskinnen. La VCC stå tom.
  4. Låsen har en liten hvit plugg på ledningen. Sett en hann-hann-ledning i hvert hull i pluggen, og skru ledningen fra den røde lederen fast i V+ og ledningen fra den svarte i V-.
  5. Bøy beina på dioden, og skru dem fast i de samme klemmene: enden med den grå stripen i V+ og den andre i V-.
  6. Ta av lokket på den delen av magnetkontakten som har skruer. Skru én ledning fast under skruen merket NC og én under COM. Koble NC til D3 og COM til minusskinnen.
  7. Last opp koden under. Sett 12 V-pluggen i til slutt.
// Nivå 2: myntautomat som åpner luken med en 12 V-lås når du har betalt.
// Myntakseptoren sender én kort puls for hver 5 kr: 5 kr = 1, 10 kr = 2, 20 kr = 4.
// Magnetkontakten på luken forteller om den er åpnet, så ingen betaling går tapt.
#include <Wire.h>
#include <hd44780.h>
#include <hd44780ioClass/hd44780_I2Cexp.h>

const byte COIN_PIN = 2;    // hvit ledning (COIN), 10 kΩ til 5V
const byte DOOR_PIN = 3;    // magnetkontakten, den andre ledningen til GND
const byte GREEN_LED = 5;   // grønn: betalt, åpne luken
const byte RED_LED = 6;     // rød: sett inn mynt
const byte LOCK_PIN = 8;    // til SIG på MOSFET-modulen

const int PRICE_KR = 20;                 // hva det koster
const int KR_PER_PULSE = 5;              // én puls er 5 kr
const unsigned long MIN_PULSE_MS = 5;    // kortere pulser er støy
const unsigned long COIN_DONE_MS = 300;  // stille så lenge: mynten er ferdig talt
const unsigned long UNLOCK_MS = 3000;    // låsen får strøm så lenge om gangen
const unsigned long REST_MS = 3000;      // så lenge spolen hviler etterpå
const byte MAX_TRIES = 5;                // så mange forsøk før vi gir opp
const unsigned long DOOR_STEADY_MS = 50; // prellfilter for magnetkontakten

hd44780_I2Cexp lcd;

// Eget tegn for å, fordi skjermen ikke har norske bokstaver.
uint8_t litenAA[8] = {0b00100, 0b01010, 0b00100, 0b01110, 0b00001, 0b01111, 0b10001, 0b01111};

volatile byte pulses = 0;
volatile unsigned long lastPulseMs = 0;
volatile unsigned long fallMs = 0;

enum State { READY, UNLOCKED, RESTING, DOOR_OPEN };
State state = READY;
unsigned long stateSince = 0;
byte tries = 0;
int balanceKr = 0;

bool doorClosed = true;          // filtrert verdi
int doorReading = LOW;           // siste rå avlesning
unsigned long doorChangedAt = 0;

// Kjøres av maskinvaren hver gang COIN skifter mellom 5 V og 0 V.
// En puls teller først når den er ferdig og har vart lenge nok.
void coinEdge() {
  unsigned long now = millis();
  if (digitalRead(COIN_PIN) == LOW) {
    fallMs = now;                       // pulsen begynner
  } else if (now - fallMs >= MIN_PULSE_MS) {
    pulses++;                           // pulsen er ferdig og ekte
    lastPulseMs = now;
  }
}

void lock(bool open) {
  digitalWrite(LOCK_PIN, open ? HIGH : LOW);  // HIGH = strøm = bolten trekkes inn
}

void show(const char* line1, const char* line2) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(line1);
  lcd.setCursor(0, 1);
  lcd.print(line2);
}

void showBalance() {
  char line1[17];
  char line2[17];
  snprintf(line1, sizeof line1, "Pris: %d kr", PRICE_KR);
  snprintf(line2, sizeof line2, "Saldo: %d kr", balanceKr);
  show(line1, line2);
}

void enter(State next) {
  state = next;
  stateSince = millis();
  switch (next) {
    case READY:
      lock(false);
      digitalWrite(GREEN_LED, LOW);
      digitalWrite(RED_LED, HIGH);
      showBalance();
      Serial.println("Klar. Sett inn en mynt.");
      break;
    case UNLOCKED:
      lock(true);
      digitalWrite(GREEN_LED, HIGH);
      digitalWrite(RED_LED, LOW);
      show("Takk!", "\001pne luken n\001");
      Serial.print("Låsen er åpen, forsøk ");
      Serial.println(tries + 1);
      break;
    case RESTING:
      lock(false);
      Serial.println("Spolen hviler.");
      break;
    case DOOR_OPEN:
      lock(false);
      digitalWrite(GREEN_LED, HIGH);
      digitalWrite(RED_LED, LOW);
      show("Ta premien og", "lukk luken");
      Serial.println("Luken er åpnet.");
      break;
  }
}

void readDoor() {
  int reading = digitalRead(DOOR_PIN);  // LOW = magneten er nær = luken er lukket
  if (reading != doorReading) {
    doorReading = reading;
    doorChangedAt = millis();
  }
  if (millis() - doorChangedAt >= DOOR_STEADY_MS) {
    doorClosed = (doorReading == LOW);
  }
}

// Legger ferdig talte mynter til saldoen. Gir true når en mynt kom inn.
bool countCoins() {
  noInterrupts();
  byte count = pulses;
  unsigned long last = lastPulseMs;
  interrupts();
  if (count == 0 || millis() - last < COIN_DONE_MS) {
    return false;
  }
  noInterrupts();
  pulses -= count;  // pulser som kom akkurat nå, blir med neste gang
  interrupts();
  int coinKr = count * KR_PER_PULSE;
  balanceKr += coinKr;
  Serial.print("Mynt: ");
  Serial.print(coinKr);
  Serial.print(" kr, saldo ");
  Serial.print(balanceKr);
  Serial.println(" kr");
  return true;
}

void setup() {
  Serial.begin(9600);
  pinMode(LOCK_PIN, OUTPUT);
  lock(false);
  pinMode(GREEN_LED, OUTPUT);
  pinMode(RED_LED, OUTPUT);
  pinMode(COIN_PIN, INPUT);         // motstanden på 10 kΩ holder pinnen på 5 V
  pinMode(DOOR_PIN, INPUT_PULLUP);  // åpen luke = HIGH, lukket luke = LOW

  int status = lcd.begin(16, 2);
  if (status) {
    hd44780::fatalError(status);
  }
  lcd.createChar(1, litenAA);

  attachInterrupt(digitalPinToInterrupt(COIN_PIN), coinEdge, CHANGE);
  doorReading = digitalRead(DOOR_PIN);
  doorClosed = (doorReading == LOW);
  enter(READY);
}

void loop() {
  readDoor();
  bool newCoin = countCoins();
  unsigned long inState = millis() - stateSince;

  switch (state) {
    case READY:
      // Bare en ny mynt kan starte et kjøp, også når saldoen er stor nok fra før.
      if (newCoin && balanceKr >= PRICE_KR) {
        balanceKr -= PRICE_KR;
        tries = 0;
        enter(UNLOCKED);
      } else if (newCoin) {
        showBalance();
      }
      break;

    case UNLOCKED:
      if (!doorClosed) {
        enter(DOOR_OPEN);
      } else if (inState >= UNLOCK_MS) {
        enter(RESTING);
      }
      break;

    case RESTING:
      // Grønn lysdiode blinker mens spolen hviler.
      digitalWrite(GREEN_LED, (inState / 250) % 2 ? LOW : HIGH);
      if (!doorClosed) {
        enter(DOOR_OPEN);
      } else if (inState >= REST_MS) {
        tries++;
        if (tries < MAX_TRIES) {
          enter(UNLOCKED);
        } else {
          balanceKr += PRICE_KR;  // ingen åpnet luken: pengene står som saldo
          Serial.println("Ingen åpnet luken. Betalingen står som saldo.");
          enter(READY);  // neste mynt åpner luken igjen
        }
      }
      break;

    case DOOR_OPEN:
      if (doorClosed && inState >= 1000) {
        enter(READY);
      }
      break;
  }
}

Dette er nytt siden nivå 1:

  • enum State gir automaten fire tilstander: klar, låst opp, hviler og luken er åpen. switch i loop() gjør bare det som hører til tilstanden automaten er i, og enter() setter lysdioder, lås og skjerm hver gang automaten bytter tilstand.
  • UNLOCK_MS og REST_MS holder spolen kald: høyst tre sekunder med strøm, så tre sekunder pause før neste forsøk.
  • MAX_TRIES er fem. Åpner ingen luken i løpet av rundt 30 sekunder, legges prisen tilbake på saldoen, og neste mynt starter et nytt kjøp.
  • readDoor() leser magnetkontakten med et prellfilter på 50 ms. INPUT_PULLUP gjør at åpen luke gir HIGH og lukket luke LOW, fordi kontakten kobler D3 til jord når magneten er nær.
  • litenAA er et eget tegn. Skjermen har ikke æ, ø og å, så koden tegner å punkt for punkt og skriver det som \001.
Tilstandsdiagram for nivå 2: klar, låst opp, hviler og luken åpen, med hendelsene som flytter programmet mellom dem.
Tilstandene i programmet. Låsen har bare strøm i tilstanden «låst opp», og aldri lenger enn tre sekunder om gangen.

Prøv på bordet før du bygger kabinettet. Hold de to delene av magnetkontakten mot hverandre, putt inn en tjuekrone, og ta delene fra hverandre mens låsen er åpen:

Klar. Sett inn en mynt.
Mynt: 20 kr, saldo 20 kr
Låsen er åpen, forsøk 1
Luken er åpnet.
Klar. Sett inn en mynt.
Du gjørLåsenLysdioderSkjermen
VenterUten strøm, bolten uteRødPris og saldo
Betaler 20 krStrøm i 3 sGrønn«Takk!» og «åpne luken nå»
Åpner lukenUten strømGrønnTa premien og lukk luken
Lukker lukenBolten smekker i låsRød når luken er lukketPris og saldo
Åpner ikke3 s strøm, 3 s pause, fem gangerGrønn blinker i pausenePris og saldo med pengene tilbake

Kabinettet: 3D-print hele automaten

Vi har tegnet et kabinett tilpasset delene i denne guiden. Målene er hentet fra databladene og sjekket i 3D-modellen, men kabinettet er ikke skrevet ut og prøvd ennå. Myntakseptoren sitter øverst til venstre med en myntskuff under, LCD-skjermen og lysdiodene øverst til høyre, og premieluken under. Luken henger i to tapper og faller igjen av seg selv, og låsebolten går inn i et hull i en arm bak luken. Elektronikken ligger på en monteringsplate bak skjermen, med USB-C og 12 V-pluggen bak, så du kan laste opp ny kode uten å skru opp kabinettet.

3D-gjengivelse av kabinettet til myntautomaten forfra, med åpen luke og bakfra, med navn på myntakseptor, LCD, luke, lås og plugger.
3D-gjengivelse av kabinettet forfra, med luken åpen og bakfra. Elektronikkbrettet står bak skjermen og vises ikke. USB-C og 12 V-pluggen settes i bakfra.

Det store koblingsbrettet får ikke plass i kabinettet. Rammen på monteringsplaten passer til et lite koblingsbrett med 170 hull på 35 x 47 mm, og det har ingen skinner. Flytt kretsen slik: samle 12 V i én rad med fem hull, 5 V i en annen og jord i to rader som du kobler sammen med en svart ledning. Skjermen og summeren kan ta jord fra de ledige GND-pinnene på UNO. Resten kobles som på det store brettet.

Kabinettet er 176 mm bredt, 200 mm høyt og 153 mm dypt og består av sju deler. Alle skrives ut uten støttemateriale. Monter i denne rekkefølgen:

  1. Skyv luken inn bakfra med tappene i sporene, løft den 1,5 mm og senk den ned i hakkene. Den skal svinge fritt og falle igjen.
  2. Skru låsen fast på sokkelen i bunnen med fire M3 x 8-skruer, med den skrå siden av bolten mot luken. Skru gjennom den åpne luken.
  3. Skyv premiehyllen inn bakfra over låsen. Den er også stoppen som hindrer at luken kan skyves innover.
  4. Skru holderen til magnetkontakten fast fra utsiden av høyre vegg med to M3 x 10-skruer, og skru kontakten fast i holderen. Magneten skrus på ribben bak luken.
  5. Skru myntakseptoren fast forfra med fire M3 x 12-skruer, etter at du har programmert den.
  6. Trykk LCD-skjermen ned på de fire tappene bak vinduet, med en dråpe lim på hver tapp, og trykk lysdiodene inn i hullene under.
  7. Skru UNO fast på monteringsplaten med fire M3 x 8-skruer, legg MOSFET-modulen, DC-kontaktmodulen og det lille koblingsbrettet i rammene sine, og skyv monteringsplaten inn bakfra.
  8. Skru på bakplaten med åtte M3 x 10-skruer med senkhode.

Nivå 3: pip for hver mynt og en sparebøsse som husker

Nivå 3: et lite tillegg for de spreke. Tid: rundt 20 minutter. Du trenger summermodulen som er aktiv LOW i tillegg til oppsettet fra nivå 2.

Nivå 3 gir et kort pip for hver mynt og tre pip når luken låses opp. Det teller også alt som er puttet inn og lagrer summen i minnet til UNO, så summen blir husket også når strømmen går. Når automaten starter, viser skjermen i tre sekunder hvor mye som ligger i myntskuffen.

Koblingstegning for nivå 3: summermodulen med I/O til D7, VCC til 5 V-skinnen og GND til minusskinnen.
Utsnitt av det samme brettet. I/O går til D7, VCC til 5 V og GND til GND. Summeren piper når I/O er LOW.
  1. Koble I/O på summermodulen til D7, VCC til plusskinnen nederst (5 V) og GND til minusskinnen.
  2. Last opp koden under. Resten av koblingen er som i nivå 2.
Vis hele koden til nivå 3
// Nivå 3: myntautomaten fra nivå 2 med lyd for hver mynt og en sparebøsseteller
// som husker hvor mye som er puttet inn, også etter at strømmen har vært borte.
// Myntakseptoren sender én kort puls for hver 5 kr: 5 kr = 1, 10 kr = 2, 20 kr = 4.
#include <Wire.h>
#include <EEPROM.h>
#include <hd44780.h>
#include <hd44780ioClass/hd44780_I2Cexp.h>

const byte COIN_PIN = 2;    // hvit ledning (COIN), 10 kΩ til 5V
const byte DOOR_PIN = 3;    // magnetkontakten, den andre ledningen til GND
const byte GREEN_LED = 5;   // grønn: betalt, åpne luken
const byte RED_LED = 6;     // rød: sett inn mynt
const byte BUZZER_PIN = 7;  // til I/O på summermodulen (LOW = lyd)
const byte LOCK_PIN = 8;    // til SIG på MOSFET-modulen

const int PRICE_KR = 20;                 // hva det koster
const int KR_PER_PULSE = 5;              // én puls er 5 kr
const unsigned long MIN_PULSE_MS = 5;    // kortere pulser er støy
const unsigned long COIN_DONE_MS = 300;  // stille så lenge: mynten er ferdig talt
const unsigned long UNLOCK_MS = 3000;    // låsen får strøm så lenge om gangen
const unsigned long REST_MS = 3000;      // så lenge spolen hviler etterpå
const byte MAX_TRIES = 5;                // så mange forsøk før vi gir opp
const unsigned long DOOR_STEADY_MS = 50; // prellfilter for magnetkontakten
const unsigned long BEEP_MS = 80;        // ett kort pip
const unsigned long TOTAL_SHOW_MS = 3000; // så lenge totalen vises på skjermen
const int EEPROM_ADDR = 0;               // her ligger totalen i minnet
const unsigned long MAGIC = 0x4D594E54;  // «MYNT»: viser at totalen er lagret fra før

hd44780_I2Cexp lcd;

// Egne tegn for å og ø, fordi skjermen ikke har norske bokstaver.
uint8_t litenAA[8] = {0b00100, 0b01010, 0b00100, 0b01110, 0b00001, 0b01111, 0b10001, 0b01111};
uint8_t litenOE[8] = {0b00000, 0b00000, 0b01110, 0b10011, 0b10101, 0b11001, 0b01110, 0b00000};

volatile byte pulses = 0;
volatile unsigned long lastPulseMs = 0;
volatile unsigned long fallMs = 0;

enum State { READY, UNLOCKED, RESTING, DOOR_OPEN };
State state = READY;
unsigned long stateSince = 0;
byte tries = 0;
int balanceKr = 0;

struct Saved {
  unsigned long magic;
  unsigned long totalKr;
};
Saved saved;

byte beepsLeft = 0;              // pip som gjenstår
unsigned long beepAt = 0;        // når neste endring av summeren skal skje
bool beeping = false;

bool doorClosed = true;          // filtrert verdi
int doorReading = LOW;           // siste rå avlesning
unsigned long doorChangedAt = 0;

// Kjøres av maskinvaren hver gang COIN skifter mellom 5 V og 0 V.
// En puls teller først når den er ferdig og har vart lenge nok.
void coinEdge() {
  unsigned long now = millis();
  if (digitalRead(COIN_PIN) == LOW) {
    fallMs = now;                       // pulsen begynner
  } else if (now - fallMs >= MIN_PULSE_MS) {
    pulses++;                           // pulsen er ferdig og ekte
    lastPulseMs = now;
  }
}

void beep(byte count) {
  beepsLeft = count;
  beepAt = millis();
}

// Summeren styres uten delay(), så myntene telles mens den piper.
void updateBuzzer() {
  if (beepsLeft == 0 || (long)(millis() - beepAt) < 0) {
    return;
  }
  beeping = !beeping;
  digitalWrite(BUZZER_PIN, beeping ? LOW : HIGH);
  beepAt = millis() + BEEP_MS;
  if (!beeping) {
    beepsLeft--;
  }
}

void lock(bool open) {
  digitalWrite(LOCK_PIN, open ? HIGH : LOW);  // HIGH = strøm = bolten trekkes inn
}

void show(const char* line1, const char* line2) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(line1);
  lcd.setCursor(0, 1);
  lcd.print(line2);
}

void showBalance() {
  char line1[17];
  char line2[17];
  snprintf(line1, sizeof line1, "Pris: %d kr", PRICE_KR);
  snprintf(line2, sizeof line2, "Saldo: %d kr", balanceKr);
  show(line1, line2);
}

void enter(State next) {
  state = next;
  stateSince = millis();
  switch (next) {
    case READY:
      lock(false);
      digitalWrite(GREEN_LED, LOW);
      digitalWrite(RED_LED, HIGH);
      showBalance();
      Serial.println("Klar. Sett inn en mynt.");
      break;
    case UNLOCKED:
      lock(true);
      digitalWrite(GREEN_LED, HIGH);
      digitalWrite(RED_LED, LOW);
      show("Takk!", "\001pne luken n\001");
      Serial.print("Låsen er åpen, forsøk ");
      Serial.println(tries + 1);
      break;
    case RESTING:
      lock(false);
      Serial.println("Spolen hviler.");
      break;
    case DOOR_OPEN:
      lock(false);
      digitalWrite(GREEN_LED, HIGH);
      digitalWrite(RED_LED, LOW);
      show("Ta premien og", "lukk luken");
      Serial.println("Luken er åpnet.");
      break;
  }
}

void readDoor() {
  int reading = digitalRead(DOOR_PIN);  // LOW = magneten er nær = luken er lukket
  if (reading != doorReading) {
    doorReading = reading;
    doorChangedAt = millis();
  }
  if (millis() - doorChangedAt >= DOOR_STEADY_MS) {
    doorClosed = (doorReading == LOW);
  }
}

// Legger ferdig talte mynter til saldoen. Gir true når en mynt kom inn.
bool countCoins() {
  noInterrupts();
  byte count = pulses;
  unsigned long last = lastPulseMs;
  interrupts();
  if (count == 0 || millis() - last < COIN_DONE_MS) {
    return false;
  }
  noInterrupts();
  pulses -= count;  // pulser som kom akkurat nå, blir med neste gang
  interrupts();
  int coinKr = count * KR_PER_PULSE;
  balanceKr += coinKr;
  saved.totalKr += coinKr;
  EEPROM.put(EEPROM_ADDR, saved);  // skrives én gang per mynt
  beep(1);
  Serial.print("Mynt: ");
  Serial.print(coinKr);
  Serial.print(" kr, saldo ");
  Serial.print(balanceKr);
  Serial.print(" kr, totalt ");
  Serial.print(saved.totalKr);
  Serial.println(" kr");
  return true;
}

void setup() {
  Serial.begin(9600);
  pinMode(LOCK_PIN, OUTPUT);
  lock(false);
  pinMode(GREEN_LED, OUTPUT);
  pinMode(RED_LED, OUTPUT);
  pinMode(COIN_PIN, INPUT);         // motstanden på 10 kΩ holder pinnen på 5 V
  pinMode(DOOR_PIN, INPUT_PULLUP);  // åpen luke = HIGH, lukket luke = LOW
  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, HIGH);   // HIGH = stille

  EEPROM.get(EEPROM_ADDR, saved);
  if (saved.magic != MAGIC) {       // første gang: start på null
    saved.magic = MAGIC;
    saved.totalKr = 0;
    EEPROM.put(EEPROM_ADDR, saved);
  }

  int status = lcd.begin(16, 2);
  if (status) {
    hd44780::fatalError(status);
  }
  lcd.createChar(1, litenAA);
  lcd.createChar(2, litenOE);

  attachInterrupt(digitalPinToInterrupt(COIN_PIN), coinEdge, CHANGE);  // mynter telles fra nå

  char line2[17];
  snprintf(line2, sizeof line2, "%lu kr", saved.totalKr);
  show("I spareb\002ssen:", line2);
  delay(TOTAL_SHOW_MS);

  doorReading = digitalRead(DOOR_PIN);
  doorClosed = (doorReading == LOW);
  enter(READY);
}

void loop() {
  updateBuzzer();
  readDoor();
  bool newCoin = countCoins();
  unsigned long inState = millis() - stateSince;

  switch (state) {
    case READY:
      // Bare en ny mynt kan starte et kjøp, også når saldoen er stor nok fra før.
      if (newCoin && balanceKr >= PRICE_KR) {
        balanceKr -= PRICE_KR;
        tries = 0;
        beep(3);
        enter(UNLOCKED);
      } else if (newCoin) {
        showBalance();
      }
      break;

    case UNLOCKED:
      if (!doorClosed) {
        enter(DOOR_OPEN);
      } else if (inState >= UNLOCK_MS) {
        enter(RESTING);
      }
      break;

    case RESTING:
      // Grønn lysdiode blinker mens spolen hviler.
      digitalWrite(GREEN_LED, (inState / 250) % 2 ? LOW : HIGH);
      if (!doorClosed) {
        enter(DOOR_OPEN);
      } else if (inState >= REST_MS) {
        tries++;
        if (tries < MAX_TRIES) {
          enter(UNLOCKED);
        } else {
          balanceKr += PRICE_KR;  // ingen åpnet luken: pengene står som saldo
          Serial.println("Ingen åpnet luken. Betalingen står som saldo.");
          enter(READY);  // neste mynt åpner luken igjen
        }
      }
      break;

    case DOOR_OPEN:
      if (doorClosed && inState >= 1000) {
        enter(READY);
      }
      break;
  }
}
  • EEPROM.put() skriver summen til minnet én gang per mynt. Minnet tåler mange tusen skrivinger, og så mange mynter putter du neppe inn.
  • MAGIC er et kjent tall som lagres sammen med summen. Første gang programmet kjører, ligger det ukjente tall i minnet, og da starter telleren på null.
  • updateBuzzer() slår summeren av og på med millis() i stedet for delay(), så myntene telles mens den piper.
Test deg selv: hvordan nullstiller du sparebøssen når du har tømt skuffen?

Endre MAGIC til et annet tall, for eksempel 0x4D594E55, og last opp. Programmet finner ikke lenger det kjente tallet og starter på null. Vil du slippe å laste opp, kan du legge til en knapp som setter saved.totalKr til 0 og lagrer.

Sikkerhet og vettig bruk

  • Bare 12 V. Alt går på en ferdig 12 V-forsyning. Ingenting i automaten skal kobles til 230 V.
  • Dette er ikke noe pengeskap. Myntskuffen trekkes rett ut, og kabinettet er av plast. Bruk automaten til moro med små premier, ikke til å oppbevare penger.
  • Hold spolen kald. Behold pausene i programmet. En lås som står med strøm i flere minutter, kan bli varm nok til å skade seg selv og plasten rundt.
  • Premiene skal tåle å ligge. Godteri og små leker passer. Ikke legg inn noe du trenger raskt, for uten strøm er luken låst.

Typiske feil, og hva som er riktig

Displayet på akseptoren er mørkt

Akseptoren får ikke 12 V. Mål mellom plusskinnen og minusskinnen øverst, og sjekk at den røde ledningen sitter i pluss og den svarte i minus. Lyser lysdioden på DC-kontaktmodulen?

Akseptoren tar imot mynter, men saldoen står stille

Signalet kommer ikke fram. Sjekk at den hvite ledningen og ledningen til D2 står i samme kolonne, at motstanden på 10 kΩ går til 5 V, og at de to minusskinnene er koblet sammen. Mål så som i kontrollpunktet i nivå 1.

En tikrone blir til 5 kr eller 15 kr

Pulsene stemmer ikke med innstillingene. Gå inn i menyen, og se at P1, P2 og P3 er 1, 2 og 4. Husk å trekke ut 12 V-pluggen og sette den i igjen etterpå, ellers lagres ikke endringen.

Skjermen lyser, men viser ingen tegn

Drei på den blå kontrastskruen på I²C-adapteren til tegnene kommer fram. Er skjermen helt mørk, eller blinker lysdioden L på UNO, finner ikke biblioteket adapteren: sjekk SDA, SCL, VCC og GND.

Låsen klikker ikke, og lysdioden på MOSFET-modulen er mørk

Signalet fra D8 kommer ikke fram. Sjekk at SIG går til D8, at pinnen GND på modulen går til minusskinnen, og at du har lastet opp koden fra nivå 2.

lysdioden på MOSFET-modulen lyser, men låsen er død eller modulen blir varm

12 V mangler på VIN, eller dioden står feil vei. Trekk ut pluggen med en gang hvis noe blir varmt. Stripen på dioden skal sitte i V+, og VIN skal ha 12 V.

Luken går ikke igjen, eller bolten treffer ikke hullet

Sjekk at den skrå siden av bolten vender mot luken, og at låsen er skrudd fast så langt fram som de avlange hullene tillater. Henger luken, trykker du den inn til bolten smekker i lås.

Vanlige spørsmål

Kan myntakseptoren ta norske mynter?

Ja, de som er mellom 15 og 29 mm i diameter og 1,8 til 3,0 mm tykke. Det gjelder 5, 10 og 20 kr. Enkronen er for tynn. Akseptoren lærer myntene du putter inn som prøvemynter, så den kan også lære polletter og utenlandske mynter innenfor de samme målene.

Hvor mange mynttyper kan den kjenne igjen?

Tre om gangen. Hver mynttype får sitt eget antall pulser, og det er det programmet bruker til å regne ut verdien.

Hvorfor trenger jeg en motstand på 10 kΩ?

Fordi den hvite ledningen bare kan trekke signalet ned til 0 V. Uten motstanden flyter pinnen fritt mellom pulsene, og programmet teller støy som penger. Motstanden holder pinnen på 5 V til akseptoren trekker den ned.

Kan jeg bruke en ESP32 i stedet for UNO R4?

Ja, men med to endringer. ESP32 tåler bare 3,3 V på pinnene, så motstanden på myntsignalet skal gå til 3,3 V og ikke til 5 V. Og IRF520-modulen leder dårlig med 3,3 V, så du trenger en logikknivå-MOSFET. Begge deler står i guiden om elektromagneter.

Kan jeg ha en annen pris enn 20 kr?

Ja. Endre PRICE_KR i koden. Prisen bør være delelig med 5 kr, siden 5 kr er den minste mynten automaten tar.

Hva gjør automaten hvis jeg putter inn mer enn prisen?

Den trekker prisen fra saldoen og lar resten stå. Putter du inn 20 kr og prisen er 15 kr, viser skjermen 5 kr i saldo etterpå, og den neste tikronen holder til et nytt kjøp.

Hvor går du videre?

Nå har du en automat som teller penger, styrer en lås og passer på at ingen betaling går tapt. Du kan bytte ut myntene med et kort og en RFID-leser, lære mer om skjermen i guiden om LCD 16x2, eller lese mer om koden i Arduino-guiden for nybegynnere.

Fakta her er hentet fra brukerhåndboken til myntakseptoren HX-616, som SparkFun viser til for denne akseptoren (menyen, mål på mynter, 12 V og strømtrekk), databladet til UNO R4 WiFi (VIN 6 til 24 V og 8 mA per pinne) og produktsidene til delene. Koden er kompilert for UNO R4 WiFi og kjørt i en simulering med pulser i alle tre hastighetene akseptoren kan sende, men vi har ikke kjørt den på en fysisk akseptor. Test derfor selv etter stegene over.

Noen bilder i guiden er laget med KI.

Alle guider

Produkter omtalt i denne guiden

Produktene som brukes og sammenlignes i guiden, med pris og lagerstatus.