Programmering og koding

Reaksjonsspill med Arduino: tre store knapper og lysring

En hånd trykker på den blå knappen på reaksjonsspillet, mens lysringen lyser blått og skjermen viser 438 ms.

Ringen lyser blått. Hvor fort klarer du å trykke på den blå knappen? Her bygger du et reaksjonsspill med tre store arcade-knapper, en lysring med 16 RGB-lysdioder og en liten OLED-skjerm midt i ringen. Spillet teller ned fra tre, gir deg 30 sekunder med farger i tilfeldig rekkefølge og regner ut poeng, treff, feil og snittet ditt i millisekunder. Du bruker en Arduino UNO R4 WiFi, får koden i tre nivåer og en konsoll du kan 3D-printe, og nivå 3 gjør spillet til et ferdig skoleprosjekt om reaksjonstid.

Reaksjonsspillet sett ovenfra: rød, blå og gul knapp rundt en blå lysring med OLED-skjerm i midten som viser 438 ms.
Slik skal det virke. Dette er en tegning. Ringen i midten lyser i en av de tre fargene, og du trykker på knappen med samme farge. Skjermen inne i ringen viser tiden fra forrige runde, her 438 ms.
Nivå
Nybegynner, nivå 3 passer som skoleprosjekt
Tid
Rundt 3 timer, pluss konsollen
Lodding
Tre ledninger på lysringen og to på hver knapp
Spenning
5 V fra USB, lader eller powerbank
Du lærer
Knapper med INPUT_PULLUP, WS2812B-lysdioder, OLED over SPI, tidtaking med micros() og en tilstandsmaskin
Kort forklartEt reaksjonsspill måler hvor fort du ser et signal og svarer på det. Her lyser en LED-ring rødt, blått eller gult etter en tilfeldig pause, og du trykker på den store knappen med samme farge. Arduino starter en stoppeklokke med micros() i samme øyeblikk som ringen tennes, og stopper den når kontakten i mikrobryteren sluttes. Riktig knapp gir 1000 poeng minus antall millisekunder, men aldri under 100. Feil farge og tyvstart koster 250 poeng. Etter 30 sekunder viser OLED-skjermen poeng, treff, feil, snittid og beste tid, og en ny rekord lagres i minnet til UNO.

Slik spiller du reaksjonsspillet

Spillet har én regel: trykk på den knappen som har samme farge som ringen, så fort du kan. Resten handler om å gjøre det rettferdig og spennende. Pausen før hver farge er tilfeldig, så du kan ikke telle deg fram til den. Ringen tennes aldri før alle knappene er sluppet, så det hjelper ikke å holde en knapp inne. Og du får aldri den samme fargen tre ganger på rad.

  1. Ringen viser en regnbue mens spillet venter, og skjermen viser rekorden. Trykk på en hvilken som helst knapp. Spillet starter når du slipper den.
  2. Skjermen teller 3, 2, 1, og en hvit bue på ringen krymper jevnt. Et kort pip følger hvert tall.
  3. Ved «SLÅ!» starter klokken. Ringen blir mørk, og etter en pause på mellom 0,7 og 1,8 sekunder lyser den rødt, blått eller gult.
  4. Trykk på knappen med samme farge. Ringen blinker grønt, og skjermen viser tiden din og poengene du fikk.
  5. Slipp knappen. Ringen blir mørk, og en ny pause begynner. Slik fortsetter det i 30 sekunder.
  6. En fanfare og en regnbue forteller at tiden er ute. Skjermen blar gjennom fire sider med resultatet til du trykker på en knapp. I de første 1,5 sekundene reagerer ikke spillet på knappene, så et sent slag ikke får deg forbi resultatet.
Det som skjerPoengSkjermen viserLyd
Riktig knapp1000 minus tiden i ms, minst 100Tiden og poengene, for eksempel «438 ms» og «+562»Kort, lys tone
Feil fargeMinus 250«FEIL FARGE»Dyp tone
Trykk før ringen lyserMinus 250«TYVSTART!»Dyp tone og hvitt blink
Ingen trykk på 1,5 sekunderIngen«FOR SENT»Dyp tone

Poengene går aldri under null. Feil farge, tyvstart og for sent telles alle som feil i resultatet. Snittiden regnes bare ut fra treffene. Tiden din gir deg også en tittel, fra skilpadde til lyn:

Snittid per treffTittel
Under 400 msLyn
400 til 499 msGaupe
500 til 599 msRev
600 til 749 msGrevling
750 ms eller merSkilpadde
Graf over poeng per treff: 1000 minus reaksjonstiden i millisekunder, som flater ut ved 100 poeng fra 900 ms, og minus 250 for feil farge og tyvstart.
Poeng per treff. Linjen faller ett poeng for hvert millisekund, fra 1000 poeng ved 0 ms til 100 poeng ved 900 ms, og blir liggende der. Et treff gir derfor alltid poeng, mens feil farge og tyvstart koster 250.

Hva er reaksjonstid, og hva måler spillet?

Reaksjonstid er tiden fra et signal dukker opp til du svarer på det. Den består av flere ledd. Øyet må oppdage lyset, hjernen må kjenne igjen fargen og velge riktig knapp, og så må signalet ut til musklene, som flytter hånden og trykker. Spillet måler hele kjeden, fra lyset tennes til kontakten i mikrobryteren sluttes.

Tidslinje for én runde: ringen tennes, øyet oppdager lyset, hjernen velger knapp, hånden beveger seg og kontakten i mikrobryteren sluttes.
Det spillet måler, fra lyset tennes til kontakten sluttes. Lengden på feltene er bare et eksempel. Hvor lang tid hvert ledd tar, varierer fra person til person og fra runde til runde.

Forskere skiller mellom enkel reaksjonstid og valgreaksjonstid. Ved enkel reaksjonstid finnes det bare ett signal og ett svar: du trykker så fort noe lyser. I en stor studie med nesten 1500 voksne fra 18 til 65 år, som trykket på knappen på en datamus så fort et signal dukket opp på skjermen, fant David Woods og kolleger et snitt på rundt 230 ms. Når forsinkelsen i skjermen og musen ble trukket fra, var snittet rundt 213 ms.

Reaksjonsspillet ditt er en valgoppgave. Du må først se hvilken farge det er, og så velge én av tre knapper. Det tar lengre tid. Allerede på 1950-tallet viste psykologene William Hick og Ray Hyman at valgtiden øker med antall valgmuligheter, men ikke like mye for hvert nytt alternativ. Fra ett til to alternativer øker tiden mer enn fra to til tre. Det kalles Hicks lov. I tillegg kommer tiden det tar å flytte hånden til en knapp som er 100 mm bred. Derfor blir tidene i dette spillet klart lengre enn i en enkel reaksjonstest på nett, og grensene for titlene er satt etter det.

Hvorfor er tiden så forskjellig fra runde til runde? Oppmerksomheten svinger. En runde der du blunket eller så bort, kan ta dobbelt så lang tid som de andre. Derfor viser spillet både snittid og beste tid, og derfor regner nivå 3 også ut medianen, som ikke blir dratt opp av én treg runde.

Test deg selv: hvorfor er tiden i spillet lengre enn i en vanlig reaksjonstest på nett?

Fordi spillet måler mer. En vanlig test har bare ett signal, og fingeren ligger allerede på knappen. Her må du velge mellom tre farger, og hånden må flytte seg til riktig knapp. Begge deler tar tid. En lengre tid betyr derfor ikke at du reagerer dårligere enn på en nettest. Spillet måler bare en annen og vanskeligere oppgave.

Dette trenger du

Alle delene kobles først løst på bordet. Når alt virker, flytter du dem over i konsollen. Lysringen leveres uten ledninger, så der må du lodde, og mikrobryterne i knappene har flate tunger, og på hver av dem lodder du én ledning. Resten kobles med koblingsledninger.

  • Stor rød trykknapp med kuppel og svart ring
    Stor rød trykknapp, 100 mm1 stk, med utskiftbar mikrobryter
    kr 225,00
    På lager
  • Stor blå trykknapp med kuppel
    kr 199,00
    På lager
  • Stor gul trykknapp med kuppel
    kr 199,00
    På lager
  • LED-ring med 16 RGB-lysdioder av typen WS2812B
    LED-ring WS2812B, 16 lysdioder, 68 mm1 stk, viser fargen spilleren skal treffe
    kr 119,00
    På lager
  • Blå OLED-skjerm på 1,3 tommer med åtte pinner
    OLED-skjerm 1,3" 128x64, SH11061 stk, viser nedtelling, tider og resultat
    kr 259,00
    På lager
  • Arduino UNO R4 WiFi sett på skrå
    Arduino UNO R4 WiFi1 stk, styrer spillet og tar tiden
    kr 599,00
    På lager
  • Svart innkapslet piezosummer med to ledninger og monteringsører
    Piezosummer uten generator, 23 mm1 stk, pip, nedtelling og fanfare
    kr 99,00
    På lager
  • Hvitt loddefritt koblingsbrett med 400 hull
    Koblingsbrett, 400 hull1 stk, samler 5 V og jord, og blir med inn i konsollen
    kr 75,00
    På lager
  • Fargerike koblingsledninger på 20 cm med hann- og hunnkontakter
    Koblingsledninger 20 cm, 120 stk16 hann-hunn og 4 hann-hann brukes
    kr 169,00
    På lager
  • Motstandssett med 16 verdier på papirremser
    Motstandssett, 16 verdier1 x 470 Ω til ringen og 1 x 100 Ω til summeren
    kr 149,00
    På lager
  • Elektrolyttkondensatorer på 100 µF med to bein
    Elektrolyttkondensator 100 µF, 10 stk1 stk mellom 5 V og jord ved ringen
    kr 29,00
    På lager
  • Svart USB-kabel fra USB-A til USB-C med av/på-bryter
    USB-C-kabel med av/på-bryter, 0,9 mValgfri, av/på-bryter for det ferdige spillet
    kr 95,00
    På lager

I tillegg trenger du en loddebolt, loddetinn, en avbiter og en USB-C-kabel som kan overføre data, for å laste opp koden. Kabelen med av/på-bryter i listen gir bare strøm, så den passer til det ferdige spillet med en USB-lader eller en powerbank, men ikke til opplasting. Til konsollen trenger du skruer og gummiføtter, se avsnittet om den. Flere knapper finner du under brytere og knapper, og andre brett og ledninger under koblingsbrett og prototyping og koblingsledninger.

Slik kobler du delene

Alt går på 5 V fra USB-kontakten på UNO. Koblingsbrettet fordeler strømmen: pinnen 5V på UNO går til plusskinnen, en GND-pinne til minusskinnen, og alle delene henter strøm derfra. Fire ledninger hann-hann går fra UNO til koblingsbrettet: 5V, GND, D5 og D6. Hver knapp får sin egen pinne, ringen én pinne og summeren én. Skjermen trenger fem pinner, fordi den bruker SPI, en rask buss med egne ledninger for klokke og data.

UNO-pinneKobles tilMerknad
D2Rød knapp, NOCOM på knappen går til jord
D3Blå knapp, NOCOM til jord
D4Gul knapp, NOCOM til jord
D5Summeren, rød ledningGjennom 100 Ω. Svart ledning til jord
D6Ringen, DINGjennom 470 Ω
D8Skjermen, RESTilbakestilling
D9Skjermen, D/CData eller kommando
D10Skjermen, CSVelger skjermen
D11Skjermen, DINData (MOSI)
D13Skjermen, CLKKlokke (SCK)
5V og GNDSkinnene på koblingsbrettetRingen, skjermen og kondensatoren henter strøm herfra
Koblingstegning: knapper på D2, D3 og D4, summer på D5 gjennom 100 Ω, OLED på D8 til D11 og D13, og LED-ring på D6 gjennom 470 Ω med kondensator.
Hele koblingen. Knappene går fra D2, D3 og D4 til jord, summeren fra D5 gjennom 100 Ω, og ringen fra D6 gjennom 470 Ω. Kondensatoren står mellom 5 V og jord ved ringen, med minusstripen mot jord. Skjermen får 5 V, jord og fem signaler.

Knappene og mikrobryteren

Under hver kuppel sitter en mikrobryter i en holder som vris av med en kvart omdreining. Når du trykker på kuppelen, presser den ned en liten stift på bryteren, og kontakten sluttes. Bryteren har en tunge merket COM og en merket NO, som betyr normalt åpen. Har bryteren en tredje tunge merket NC, lar du den være ukoblet.

Mikrobryteren i knappen med COM til jord og NO til D2, og den innebygde pull-up-motstanden i UNO som holder D2 høy til knappen trykkes.
Slik leser UNO en knapp. Den innebygde motstanden holder D2 på 5 V. Når du trykker, kobler bryteren D2 til jord, og pinnen blir lav. NC brukes ikke.

Programmet slår på den innebygde motstanden med pinMode(2, INPUT_PULLUP). Den holder pinnen høy når knappen er sluppet. Trykker du, kobler bryteren pinnen til jord, og digitalRead(2) gir LOW. Det kan virke bakvendt at et trykk gir lav, men du sparer tre motstander, og en løs ledning gir aldri falske trykk, bare et trykk som ikke kommer fram. Mer om bryterens tunger og hva NO og NC betyr, står i guiden om brytere og trykknapper.

Trygg lodding: Spissen på loddebolten er rundt 350 °C. Sett den alltid i holderen når du legger den fra deg, og bruk vernebriller, for tinn kan sprute, og ledningsbiter kan fly når du klipper. Lodd i et rom med god lufting, og ikke pust inn røyken. Inneholder loddetinnet bly, vasker du hendene når du er ferdig. Barn lodder med en voksen ved siden av.
  1. Vri bryterholderen under knappen en kvart omdreining og trekk den ut. Da kommer du til bryteren uten å skru opp noe.
  2. Klipp hunnenden av to ledninger hann-hunn på 20 cm, og avisoler 5 mm på de avklipte endene.
  3. Lodd den ene ledningen på COM og den andre på NO. Varm opp tungen og ledningen samtidig, og la tinnet flyte inn. Ikke hold bolten der lenger enn et par sekunder, for plasten i bryteren tåler ikke mye varme.
  4. Merk de to ledningene med en bit tape i knappens farge, så vet du senere hvilket par som hører til hvilken knapp.
  5. Gjør det samme med de to andre knappene.

LED-ringen

Ringen har 16 lysdioder av typen WS2812B. Hver av dem har sin egen lille brikke som tar imot en farge og sender resten av beskjeden videre til neste lysdiode. Derfor trenger hele ringen bare én signalledning. Ringen har fire loddeflater: GND, 5V, DIN og DOUT. DOUT er til en ring nummer to, og den lar du være.

  1. Klipp hunnenden av tre ledninger hann-hunn på 20 cm i forskjellige farger: rød til 5V, svart til GND og en tredje farge til DIN. Fjern 3 mm isolasjon og fortinn endene.
  2. Lodd ledningene på flatene fra baksiden av ringen, så de ikke lager skygge foran lysdiodene.
  3. Sett motstanden på 470 Ω i koblingsbrettet mellom D6 og ledningen til DIN. Motstanden demper små spenningstopper på signalet. Adafruit anbefaler å sette den så nær ringen som mulig. Her sitter den på koblingsbrettet, fordi ledningen videre til ringen bare er 20 cm lang. Blinker den første lysdioden i feil farge, kan du flytte motstanden til ringen og lodde den inn i DIN-ledningen rett ved loddeflaten.
  4. Sett kondensatoren på 100 µF i koblingsbrettet mellom plusskinnen og minusskinnen, nær der ringen får strøm. Det korte beinet og den lyse stripen på siden skal mot minus. Kondensatoren er et lite lager som jevner ut strømmen når alle lysdiodene skifter farge samtidig.
  5. Koble 5V-ledningen til plusskinnen og GND-ledningen til minusskinnen.

En WS2812B kan trekke opptil 60 mA ved full styrke i hvitt, så 16 av dem kan trekke nesten 1 A. Det er for mye for USB-porten på en datamaskin. Programmet setter derfor lysstyrken til 60 av 255. Da trekker hele ringen rundt 230 mA på det meste, og mindre i én farge: rundt en tredel i rødt eller blått og litt over halvparten i gult. Det er mer enn nok, for ringen sitter rett under øynene dine.

OLED-skjermen

Skjermen har 128 x 64 blå piksler og styres av brikken SH1106. Den kan bruke både I²C og SPI, og den kommer innstilt på SPI. Det er den raskeste måten, og den passer bra her, fordi skjermen skal kunne skrive tiden din kort tid etter at du har trykket. Pinnene er loddet på fra fabrikken, så du bruker sju ledninger hann-hunn på 20 cm: hunnenden på skjermen og hannenden i UNO eller koblingsbrettet. De lange ledningene gjør at du kan åpne konsollen senere uten å trekke dem ut.

  1. VCC til plusskinnen (5 V) og GND til minusskinnen. Skjermen tåler 3,3 til 5 V.
  2. DIN til D11 og CLK til D13. Det er de faste SPI-pinnene på UNO.
  3. CS til D10, D/C til D9 og RES til D8.
  4. Pinnen NC skal ikke kobles til noe.

Står skjermen på I²C fordi noen har flyttet de små motstandene merket BS0 og BS1 på baksiden, viser den ingenting med denne koden. Se etter på baksiden: for SPI med fire ledninger skal både BS0 og BS1 stå på 0. Står BS1 på 1, er skjermen satt til I²C.

Summeren

Summeren er en piezo uten egen tonegenerator. Den lager lyd bare når Arduino slår spenningen av og på mange ganger i sekundet, og det gjør funksjonen tone(). Fordelen er at du selv velger tonehøyden, så spillet kan pipe lyst for riktig og dypt for feil, og spille en liten fanfare til slutt. Summeren er sterkest rundt 4 kHz. Spillet bruker nettopp den tonen når du treffer, så riktig svar høres best. Feil gir en dyp tone på 400 Hz.

  1. Sett motstanden på 100 Ω mellom D5 og den røde ledningen på summeren. Den beskytter pinnen når piezoen lades opp og ut.
  2. Den svarte ledningen går til minusskinnen.
Ledningene på summeren er for tynne til koblingsbrettet

Vri de tynne trådene stramt sammen og fortinn dem med litt loddetinn. Da blir de stive nok til å stå i brettet. Du kan også lodde dem på hannenden av en koblingsledning og trekke krympestrømpe over skjøten.

Nivå 1: test knappene, ringen og skjermen

Nivå 1: nybegynner. Tid: rundt 30 minutter. Du trenger oppsettet fra avsnittet over: knappene, ringen, skjermen og summeren koblet til kortet. Koden har ingen tidtaking ennå. Den viser bare at hver del er koblet riktig.

Før du laster opp selve spillet, er det lurt å sjekke at alle delene virker. Når du har lastet opp koden, lyser ringen rødt, blått og gult etter hverandre med en tone for hver farge. Da vet du at ringen, skjermen og summeren virker. Deretter gjør testprogrammet tre ting når du trykker på en knapp: ringen lyser i knappens farge, summeren spiller en tone for den fargen, og skjermen skriver fargen og pinnen. Slik ser du med en gang om en knapp sitter på feil pinne.

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, og installer to biblioteker: «Adafruit NeoPixel» av Adafruit og «U8g2» av oliver (olikraus).
  3. Koble UNO til datamaskinen med en USB-C-kabel som overfører data. Velg «Arduino UNO R4 WiFi» og porten som dukker opp.
  4. Lim inn koden under, og trykk på pilen Upload.
  5. Åpne Serial Monitor, og velg 9600 baud.
// Nivå 1: koblingstest for reaksjonsspillet.
// Ved start lyser ringen rødt, blått og gult med en tone hver: da vet du at ringen,
// skjermen og piezoen virker. Trykk så på en knapp: ringen lyser i knappens farge,
// piezoen spiller fargens tone, og skjermen viser fargen og pinnen.
// Ingen tidtaking ennå. Stemmer farge og pinne for alle tre knappene, er koblingene riktige.
// Biblioteker fra Library Manager: Adafruit NeoPixel og U8g2.
#include <Adafruit_NeoPixel.h>
#include <U8g2lib.h>
#include <SPI.h>

// ---- Koblinger ----
const byte BUTTON_PINS[3] = {2, 3, 4};  // rød, blå og gul knapp; COM på knappen går til GND
const byte PIEZO_PIN = 5;               // piezo + gjennom 100 Ω, piezo - til GND
const byte RING_PIN = 6;                // DIN på LED-ringen gjennom 470 Ω
const byte OLED_CS = 10;                // CS på skjermen
const byte OLED_DC = 9;                 // D/C på skjermen
const byte OLED_RES = 8;                // RES på skjermen
// DIN og CLK på skjermen går til D11 og D13: kortets maskinvare-SPI.
// Ringen får 5V og GND fra kortet, med en kondensator på 100 µF mellom 5V og GND ved ringen.

#define OLED_ROTATION U8G2_R0  // bytt til U8G2_R2 hvis teksten står opp ned

const byte RING_LEDS = 16;  // lysdioder i ringen
// Lysstyrke 60 av 255. En lysdiode bruker opptil 60 mA på full hvit, så hele ringen
// trekker høyst 16 x 60 mA x 60/255 = ca. 230 mA. Det tåler USB godt.
const byte BRIGHTNESS = 60;

const unsigned long RELEASE_MS = 30;  // alle knapper oppe så lenge = sluppet
const unsigned long SELFTEST_MS = 400;  // hver farge i starttesten

// Farger som 0xRRGGBB, og én tone per farge: C, E og G.
const uint32_t COLORS[3] = {0xFF0000, 0x0000FF, 0xFFA000};  // rød, blå, gul
const unsigned int TONES_HZ[3] = {523, 659, 784};
const char* COLOR_WORDS[3] = {"RØD", "BLÅ", "GUL"};

// Skrifter. Begge har Æ, Ø og Å. Ikke alle skrifter i U8g2 har dem, så sjekk før du bytter.
#define FONT_SMALL u8g2_font_6x13_tf      // 13 piksler høy
#define FONT_BIG u8g2_font_helvB14_tf     // 14 piksler høy

Adafruit_NeoPixel ring(RING_LEDS, RING_PIN, NEO_GRB + NEO_KHZ800);
// «_1_» betyr at bildet tegnes én stripe (8 linjer) om gangen. Det bruker bare 128 byte RAM,
// så spillet får plass også på en UNO R3. Derfor står tegningen i en firstPage/nextPage-løkke.
U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI oled(OLED_ROTATION, OLED_CS, OLED_DC, OLED_RES);

// Gir nummeret på knappen som er nede (0 rød, 1 blå, 2 gul), eller -1 når ingen er nede.
int readButton() {
  for (byte i = 0; i < 3; i++) {
    if (digitalRead(BUTTON_PINS[i]) == LOW) {  // INPUT_PULLUP: nede = LOW
      return i;
    }
  }
  return -1;
}

// Gir true når ingen knapp har vært nede på RELEASE_MS. Bryteren preller (kontakten åpner og
// lukker seg) noen millisekunder når den slippes, og det skal ikke telle som et nytt trykk.
bool allReleased() {
  unsigned long start = millis();
  while (millis() - start < RELEASE_MS) {
    if (readButton() >= 0) {
      return false;
    }
  }
  return true;
}

void ringFill(uint32_t color) {
  ring.fill(color);
  ring.show();
}

void ringOff() {
  ring.clear();
  ring.show();
}

// Skriver teksten midt på skjermen. y er grunnlinjen, altså bunnen av bokstavene.
void centerText(const char* text, int y) {
  int x = (oled.getDisplayWidth() - oled.getUTF8Width(text)) / 2;
  if (x < 0) {
    x = 0;
  }
  oled.drawUTF8(x, y, text);
}

// Tre linjer: liten tekst øverst, stor tekst i midten, liten tekst nederst.
void showPage(const char* top, const char* big, const char* bottom) {
  oled.firstPage();
  do {
    oled.setFont(FONT_SMALL);
    centerText(top, 12);
    oled.setFont(FONT_BIG);
    centerText(big, 40);
    oled.setFont(FONT_SMALL);
    centerText(bottom, 60);
  } while (oled.nextPage());
}

// Fargen, pinnen og tonen for én knapp.
void showButton(byte i) {
  char text[20];
  snprintf(text, sizeof text, "Knapp på D%d", BUTTON_PINS[i]);
  ringFill(COLORS[i]);
  tone(PIEZO_PIN, TONES_HZ[i], 200);
  showPage("Koblingstest", COLOR_WORDS[i], text);
}

void setup() {
  Serial.begin(9600);
  for (byte i = 0; i < 3; i++) {
    pinMode(BUTTON_PINS[i], INPUT_PULLUP);  // knappen kobler pinnen til GND
  }
  pinMode(PIEZO_PIN, OUTPUT);
  ring.begin();
  ring.setBrightness(BRIGHTNESS);
  oled.begin();
  oled.enableUTF8Print();  // trengs for oled.print(); drawUTF8() forstår Æ, Ø og Å uansett

  // Starttest: alle tre fargene etter hverandre, uten knapper.
  for (byte i = 0; i < 3; i++) {
    showButton(i);
    delay(SELFTEST_MS);
  }
  ringOff();
  showPage("Koblingstest", "Trykk!", "rød, blå eller gul");
  Serial.println(F("Koblingstest klar. Trykk på en knapp."));
}

void loop() {
  int button = readButton();
  if (button < 0) {
    return;  // ingen knapp er nede
  }
  showButton(button);
  Serial.print(F("Knapp "));
  Serial.print(COLOR_WORDS[button]);
  Serial.print(F(" på D"));
  Serial.println(BUTTON_PINS[button]);
  // Ringen lyser så lenge knappen holdes nede.
  while (!allReleased()) {
  }
  ringOff();
}

Det viktigste i koden:

  • U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI forteller biblioteket at skjermen har brikken SH1106 og bruker SPI med fire ledninger. CS, D/C og RES står i parentesen. _1_ betyr at bildet tegnes i striper på 8 linjer. Det bruker lite minne, så koden får plass også på en UNO R3, og derfor står all tegning i en løkke med firstPage() og nextPage().
  • INPUT_PULLUP slår på motstanden inne i UNO, så knappene trenger ingen egne motstander.
  • ring.setBrightness() holder lysstyrken nede, så ringen ikke trekker mer strøm enn USB gir.
  • drawUTF8() skriver tekst med æ, ø og å. De to skriftene koden bruker til tekst, 6x13_tf og helvB14_tf, har æ, ø og å, men ikke alle _tf-skrifter har dem, se typiske feil.

Trykk på de tre knappene én etter én. Serial Monitor skal vise omtrent dette:

Koblingstest klar. Trykk på en knapp.
Knapp RØD på D2
Knapp BLÅ på D3
Knapp GUL på D4

Nivå 2: hele reaksjonsspillet

Nivå 2: nybegynner til viderekommen. Tid: rundt 30 minutter. Den samme koblingen som i nivå 1. Du laster bare opp ny kode.

Nå blir testprogrammet et spill. Koden er bygd som en tilstandsmaskin: spillet er alltid i én av noen få tilstander, og hver tilstand vet hva den venter på og hvilken tilstand som kommer etterpå. Det gjør koden lett å lese og lett å endre.

Tilstandene i spillet: meny, nedtelling, vent, signal med treff, feil farge eller for sent, tyvstart, og slutt med resultat.
Spillets gang. Vent og signal går i ring helt til de 30 sekundene er ute. Et trykk i ventetiden er tyvstart, og et trykk under signalet er enten treff eller feil farge.
TilstandRingenVenter påNeste
MENYRegnbueEt trykk på en knappNEDTELLING
NEDTELLINGHvit bue som krymperTre sekunderVENT
VENTMørkEn tilfeldig pause, og at alle knapper er sluppetSIGNAL, eller tyvstart
SIGNALRød, blå eller gulFørste trykk, høyst 1,5 sekunderVENT
SLUTTRegnbueEt nytt trykk, tidligst etter 1,5 sekunderMENY
// Nivå 2: reaksjonsspillet. Nedtelling, 30 sekunder spill og en resultattavle.
// En farge lyser i ringen. Trykk på knappen med samme farge så fort du kan.
// Raskt og riktig gir mange poeng. Feil farge og tyvstart koster poeng.
// Hver runde skrives også i Serial Monitor (9600 baud).
// Biblioteker fra Library Manager: Adafruit NeoPixel og U8g2.
#include <Adafruit_NeoPixel.h>
#include <U8g2lib.h>
#include <SPI.h>
#include <EEPROM.h>

// ---- Koblinger ----
const byte BUTTON_PINS[3] = {2, 3, 4};  // rød, blå og gul knapp; COM på knappen går til GND
const byte PIEZO_PIN = 5;               // piezo + gjennom 100 Ω, piezo - til GND
const byte RING_PIN = 6;                // DIN på LED-ringen gjennom 470 Ω
const byte OLED_CS = 10;                // CS på skjermen
const byte OLED_DC = 9;                 // D/C på skjermen
const byte OLED_RES = 8;                // RES på skjermen
// DIN og CLK på skjermen går til D11 og D13: kortets maskinvare-SPI.
// Ringen får 5V og GND fra kortet, med en kondensator på 100 µF mellom 5V og GND ved ringen.

#define OLED_ROTATION U8G2_R0  // bytt til U8G2_R2 hvis teksten står opp ned

const byte RING_LEDS = 16;  // lysdioder i ringen
// Lysstyrke 60 av 255. En lysdiode bruker opptil 60 mA på full hvit, så hele ringen
// trekker høyst 16 x 60 mA x 60/255 = ca. 230 mA. Det tåler USB godt.
const byte BRIGHTNESS = 60;

// ---- Spillets regler ----
const unsigned long GAME_MS = 30000;     // så lenge spillet varer
const unsigned long WAIT_MIN_MS = 700;   // korteste mørke pause før fargen
const unsigned long WAIT_MAX_MS = 1800;  // lengste mørke pause
const unsigned long TIMEOUT_MS = 1500;   // så lenge fargen venter på et trykk
const long MAX_POINTS = 1000;            // et treff gir 1000 minus tiden i ms ...
const long MIN_POINTS = 100;             // ... men minst 100
const long PENALTY = 250;                // trekk for feil farge og tyvstart

// Titler etter snittiden. Tiden omfatter også håndbevegelsen, ikke bare reaksjonen i hodet.
const unsigned long LYN_MS = 400;       // under 400 ms: Lyn
const unsigned long GAUPE_MS = 500;     // under 500 ms: Gaupe
const unsigned long REV_MS = 600;       // under 600 ms: Rev
const unsigned long GREVLING_MS = 750;  // under 750 ms: Grevling, ellers Skilpadde

// ---- Tider for lys, lyd og skjerm ----
const unsigned long RELEASE_MS = 30;   // alle knapper oppe så lenge = sluppet
const unsigned long STEP_MS = 1000;    // hvert tall i nedtellingen
const unsigned long FLASH_MS = 120;    // grønt eller hvitt blink
const unsigned long IGNORE_MS = 1500;  // knappene teller ikke så lenge etter slutt
const unsigned long PAGE_MS = 2500;    // hver resultatside vises så lenge
const byte RESULT_PAGES = 4;           // poeng, treff og feil, tider, tittel
const unsigned int BEEP_HZ = 2000;     // pip i nedtellingen
const unsigned int GO_HZ = 3000;       // «SLÅ!»
const unsigned int RIGHT_HZ = 4000;    // riktig farge
const unsigned int WRONG_HZ = 400;     // feil, tyvstart og for sent

// Farger som 0xRRGGBB. Grønt betyr «riktig» og er ikke en spillfarge.
const uint32_t COLORS[3] = {0xFF0000, 0x0000FF, 0xFFA000};  // rød, blå, gul
const uint32_t GREEN = 0x00FF00;
const uint32_t WHITE = 0xFFFFFF;
const char* COLOR_NAMES[3] = {"rød", "blå", "gul"};

// Skrifter. De to første har Æ, Ø og Å (ikke alle skrifter i U8g2 har dem, så sjekk før du bytter).
// Slutten _tn betyr bare tall.
// Få skrifter, så alt får plass i flashminnet på en UNO R3 også.
#define FONT_SMALL u8g2_font_6x13_tf         // 13 piksler høy
#define FONT_BIG u8g2_font_helvB14_tf        // 14 piksler høy
#define FONT_DIGITS u8g2_font_logisoso32_tn  // 32 piksler høye tall

// Rekorden ligger i EEPROM, så den er der også etter at strømmen har vært borte.
const int EEPROM_ADDR = 0;
const unsigned long MAGIC = 0x52454132;  // viser at rekorden er skrevet av dette spillet
struct Saved {
  unsigned long magic;
  long record;
};

Adafruit_NeoPixel ring(RING_LEDS, RING_PIN, NEO_GRB + NEO_KHZ800);
// «_1_» betyr at bildet tegnes én stripe (8 linjer) om gangen. Det bruker bare 128 byte RAM,
// så spillet får plass også på en UNO R3. Derfor står tegningen i en firstPage/nextPage-løkke.
U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI oled(OLED_ROTATION, OLED_CS, OLED_DC, OLED_RES);

long record = 0;              // beste poengsum
long points = 0;              // poeng i spillet som pågår
int hits = 0;                 // treff
int errors = 0;               // feil: feil farge, tyvstart og for sent
int falseStarts = 0;          // tyvstarter (er også med i errors)
int late = 0;                 // for sent (er også med i errors)
unsigned long sumMs = 0;      // summen av trefftidene, til snittet
unsigned long bestMs = 0;     // raskeste treff (0 = ingen ennå)
unsigned long gameStart = 0;  // når «SLÅ!» kom
bool newRecord = false;       // ble rekorden slått i dette spillet?
byte lastColor = 255;         // forrige farge (255 = ingen)
byte colorBefore = 255;       // fargen før den igjen
unsigned long rainbowAt = 0;  // når regnbuen sist ble tegnet

// ===================== Knapper =====================

// Gir nummeret på knappen som er nede (0 rød, 1 blå, 2 gul), eller -1 når ingen er nede.
// Den første kontakten teller som trykket. At bryteren preller etterpå (kontakten åpner og
// lukker seg noen ganger), spiller ingen rolle: spillet venter uansett til knappen er sluppet.
int readButton() {
  for (byte i = 0; i < 3; i++) {
    if (digitalRead(BUTTON_PINS[i]) == LOW) {  // INPUT_PULLUP: nede = LOW
      return i;
    }
  }
  return -1;
}

// Gir true når ingen knapp har vært nede på RELEASE_MS. Da er prellingen over.
bool allReleased() {
  unsigned long start = millis();
  while (millis() - start < RELEASE_MS) {
    if (readButton() >= 0) {
      return false;
    }
  }
  return true;
}

// ===================== Ringen =====================

void ringFill(uint32_t color) {
  ring.fill(color);
  ring.show();
}

void ringOff() {
  ring.clear();
  ring.show();
}

// Tenner de første «count» lysdiodene hvite: buen i nedtellingen.
void ringArc(int count) {
  ring.clear();
  for (int i = 0; i < count; i++) {
    ring.setPixelColor(i, WHITE);
  }
  ring.show();
}

// Regnbue som vandrer rundt. Kan kalles så ofte du vil; den tegner hvert 20. ms.
// speed: hvor fort fargene vandrer.
void rainbowStep(unsigned int speed) {
  if (millis() - rainbowAt >= 20) {
    rainbowAt = millis();
    ring.rainbow(millis() * speed);  // fargetonen (0 til 65535) går rundt av seg selv
    ring.show();
  }
}

// ===================== Skjermen =====================

// Skriver teksten midt på skjermen. y er grunnlinjen, altså bunnen av bokstavene.
void centerText(const char* text, int y) {
  int x = (oled.getDisplayWidth() - oled.getUTF8Width(text)) / 2;
  if (x < 0) {
    x = 0;
  }
  oled.drawUTF8(x, y, text);
}

// Én tekst midt på skjermen med valgt skrift.
void showBig(const char* text, const uint8_t* font, int y) {
  oled.firstPage();
  do {
    oled.setFont(font);
    centerText(text, y);
  } while (oled.nextPage());
}

// Tre linjer: liten tekst øverst, stor tekst i midten, liten tekst nederst.
void showPage(const char* top, const char* big, const char* bottom) {
  oled.firstPage();
  do {
    oled.setFont(FONT_SMALL);
    centerText(top, 12);
    oled.setFont(FONT_BIG);
    centerText(big, 40);
    oled.setFont(FONT_SMALL);
    centerText(bottom, 60);
  } while (oled.nextPage());
}

void showMenu() {
  char text[24];
  snprintf(text, sizeof text, "Rekord: %ld", record);
  oled.firstPage();
  do {
    oled.setFont(FONT_SMALL);
    centerText("REAKSJONSSPILL", 12);
    oled.drawHLine(0, 16, oled.getDisplayWidth());
    centerText("Trykk og slipp", 36);
    centerText(text, 58);
  } while (oled.nextPage());
}

// Etter en runde: poeng og sekunder igjen øverst, beskjeden stort, detaljen under.
// Kalles bare når ringen ikke viser en spillfarge.
void showRound(const char* big, const char* small) {
  char left[16];
  char right[8];
  unsigned long used = millis() - gameStart;
  unsigned long secondsLeft = 0;
  if (used < GAME_MS) {
    secondsLeft = (GAME_MS - used + 999) / 1000;  // rund opp: 0,2 s igjen vises som 1 s
  }
  snprintf(left, sizeof left, "Poeng %ld", points);
  snprintf(right, sizeof right, "%lu s", secondsLeft);
  oled.firstPage();
  do {
    oled.setFont(FONT_SMALL);
    oled.drawUTF8(0, 11, left);
    oled.drawUTF8(oled.getDisplayWidth() - oled.getUTF8Width(right), 11, right);
    oled.setFont(FONT_BIG);
    centerText(big, 40);
    oled.setFont(FONT_SMALL);
    centerText(small, 60);
  } while (oled.nextPage());
}

// Tittel etter snittiden. Uten treff (snitt 0) blir det Skilpadde.
const char* titleFor(unsigned long avgMs) {
  if (avgMs == 0) return "Skilpadde";
  if (avgMs < LYN_MS) return "Lyn";
  if (avgMs < GAUPE_MS) return "Gaupe";
  if (avgMs < REV_MS) return "Rev";
  if (avgMs < GREVLING_MS) return "Grevling";
  return "Skilpadde";
}

unsigned long averageMs() {
  if (hits == 0) {
    return 0;
  }
  return sumMs / hits;
}

// Side 0: poengene. Side 1: treff og feil. Side 2: tidene. Side 3: tittel og rekord.
void showResultPage(byte page) {
  char line1[20];
  char line2[20];
  if (page == 0) {
    snprintf(line1, sizeof line1, "%ld", points);
    oled.firstPage();
    do {
      oled.setFont(FONT_SMALL);
      centerText("POENG", 12);
      oled.setFont(FONT_DIGITS);
      centerText(line1, 52);
    } while (oled.nextPage());
  } else if (page == 1) {
    snprintf(line1, sizeof line1, "Treff %d", hits);
    snprintf(line2, sizeof line2, "Feil %d", errors);
    oled.firstPage();
    do {
      oled.setFont(FONT_BIG);
      centerText(line1, 28);
      centerText(line2, 58);
    } while (oled.nextPage());
  } else if (page == 2) {
    if (hits > 0) {
      snprintf(line1, sizeof line1, "%lu ms", averageMs());
      snprintf(line2, sizeof line2, "Beste %lu ms", bestMs);
    } else {
      snprintf(line1, sizeof line1, "-");
      snprintf(line2, sizeof line2, "Ingen treff");
    }
    showPage("Snitt", line1, line2);
  } else {
    if (newRecord) {
      snprintf(line2, sizeof line2, "NY REKORD!");
    } else {
      snprintf(line2, sizeof line2, "Rekord: %ld", record);
    }
    showPage("Du er en", titleFor(averageMs()), line2);
  }
}

// ===================== Rekord i EEPROM =====================

void loadRecord() {
  Saved saved;
  EEPROM.get(EEPROM_ADDR, saved);
  if (saved.magic == MAGIC) {
    record = saved.record;
  } else {
    record = 0;  // tomt minne, eller skrevet av et annet program
  }
}

// Skrives bare ved ny rekord, så minnet ikke slites.
void saveRecord() {
  Saved saved;
  saved.magic = MAGIC;
  saved.record = record;
  EEPROM.put(EEPROM_ADDR, saved);
}

// ===================== Spillet =====================

bool timeIsUp() {
  return millis() - gameStart >= GAME_MS;
}

// Trekker fra poeng, men aldri under 0.
void penalty() {
  points -= PENALTY;
  if (points < 0) {
    points = 0;
  }
}

// Velger rød, blå eller gul tilfeldig, men aldri samme farge tre ganger på rad.
byte pickColor() {
  byte color = random(3);
  if (color == lastColor && color == colorBefore) {
    color = (color + 1 + random(2)) % 3;  // en av de to andre
  }
  colorBefore = lastColor;
  lastColor = color;
  return color;
}

// 3, 2, 1 med pip og en hvit bue som krymper. Så «SLÅ!» og spillet starter.
void countdown() {
  unsigned long start = millis();
  int shownDigit = 0;
  int shownLeds = -1;
  while (millis() - start < 3 * STEP_MS) {
    unsigned long elapsed = millis() - start;
    int digit = 3 - elapsed / STEP_MS;
    if (digit != shownDigit) {
      shownDigit = digit;
      tone(PIEZO_PIN, BEEP_HZ, 100);
      char text[4];
      snprintf(text, sizeof text, "%d", digit);
      showBig(text, FONT_DIGITS, 48);
    }
    int leds = RING_LEDS - (elapsed * RING_LEDS) / (3 * STEP_MS);
    if (leds != shownLeds) {  // tegn ringen bare når buen endrer seg
      shownLeds = leds;
      ringArc(leds);
    }
  }
  ringOff();
  tone(PIEZO_PIN, GO_HZ, 400);
  showBig("SLÅ!", FONT_BIG, 42);
}

// Mørk pause med tilfeldig lengde, så ingen kan gjette når fargen kommer.
// Gir false ved tyvstart eller når tiden er ute.
bool darkPause() {
  char text[8];
  ringOff();
  unsigned long waitMs = random(WAIT_MIN_MS, WAIT_MAX_MS + 1);
  unsigned long start = millis();
  while (millis() - start < waitMs) {
    if (timeIsUp()) {
      return false;
    }
    if (readButton() >= 0) {  // trykk før fargen: tyvstart
      falseStarts++;
      errors++;
      penalty();
      tone(PIEZO_PIN, WRONG_HZ, 300);
      ringFill(WHITE);
      snprintf(text, sizeof text, "-%ld", PENALTY);
      showRound("TYVSTART!", text);
      Serial.print(F("Tyvstart: -"));
      Serial.print(PENALTY);
      Serial.println(F(" poeng"));
      delay(FLASH_MS);
      ringOff();
      return false;
    }
  }
  return true;
}

// Én runde: vent til knappene er sluppet, mørk pause, fargen, så svaret.
void playRound() {
  char big[12];
  char small[8];

  // Neste farge kommer først når alle knapper er sluppet.
  while (!allReleased()) {
    if (timeIsUp()) {
      return;
    }
  }
  if (!darkPause()) {
    return;  // tyvstart eller tiden er ute: en ny runde begynner med en ny pause
  }

  // Fargen tennes. Klokken startes rett etter show(), for da lyser ringen.
  // Skjermen tegnes ikke nå: det ville forsinket avlesningen av knappene.
  byte color = pickColor();
  ringFill(COLORS[color]);
  unsigned long t0 = micros();
  int pressed = -1;
  unsigned long elapsedUs = 0;
  while (pressed < 0 && elapsedUs < TIMEOUT_MS * 1000) {
    if (timeIsUp()) {
      ringOff();
      return;  // spillet er slutt midt i runden: den teller ikke
    }
    pressed = readButton();
    elapsedUs = micros() - t0;
  }
  unsigned long ms = elapsedUs / 1000;

  if (pressed == color) {
    long gained = MAX_POINTS - (long)ms;
    if (gained < MIN_POINTS) {
      gained = MIN_POINTS;
    }
    points += gained;
    hits++;
    sumMs += ms;
    if (bestMs == 0 || ms < bestMs) {
      bestMs = ms;
    }
    ringFill(GREEN);
    tone(PIEZO_PIN, RIGHT_HZ, 80);
    snprintf(big, sizeof big, "%lu ms", ms);
    snprintf(small, sizeof small, "+%ld", gained);
    showRound(big, small);
    Serial.print(F("Treff på "));
    Serial.print(COLOR_NAMES[color]);
    Serial.print(F(": "));
    Serial.print(ms);
    Serial.print(F(" ms, +"));
    Serial.print(gained);
    Serial.println(F(" poeng"));
    delay(FLASH_MS);
    ringOff();
  } else if (pressed >= 0) {
    errors++;
    penalty();
    ringOff();
    tone(PIEZO_PIN, WRONG_HZ, 300);
    snprintf(small, sizeof small, "-%ld", PENALTY);
    showRound("FEIL FARGE", small);
    Serial.print(F("Feil farge: ringen var "));
    Serial.print(COLOR_NAMES[color]);
    Serial.print(F(", du trykket på "));
    Serial.print(COLOR_NAMES[pressed]);
    Serial.print(F(": -"));
    Serial.print(PENALTY);
    Serial.println(F(" poeng"));
  } else {
    late++;
    errors++;
    ringOff();
    tone(PIEZO_PIN, WRONG_HZ, 300);
    showRound("FOR SENT", "");
    Serial.print(F("For sent: "));
    Serial.print(COLOR_NAMES[color]);
    Serial.println(F(" ventet i 1,5 s"));
  }
}

void playGame() {
  points = 0;
  hits = 0;
  errors = 0;
  falseStarts = 0;
  late = 0;
  sumMs = 0;
  bestMs = 0;
  lastColor = 255;
  colorBefore = 255;
  countdown();
  gameStart = millis();
  Serial.println(F("SLÅ! Spillet varer i 30 sekunder."));
  while (!timeIsUp()) {
    playRound();
  }
  ringOff();
}

// Fanfare med regnbuen i full fart: spillet er slutt.
void fanfare() {
  const unsigned int notes[4] = {523, 659, 784, 1047};  // C, E, G og høy C
  const unsigned long lengths[4] = {150, 150, 150, 500};
  for (byte i = 0; i < 4; i++) {
    tone(PIEZO_PIN, notes[i], lengths[i]);
    unsigned long start = millis();
    while (millis() - start < lengths[i] + 30) {
      rainbowStep(40);
    }
  }
}

void printResult() {
  Serial.print(F("Slutt! Poeng: "));
  Serial.println(points);
  Serial.print(F("Treff: "));
  Serial.print(hits);
  Serial.print(F(", feil: "));
  Serial.print(errors);
  Serial.print(F(" (tyvstart "));
  Serial.print(falseStarts);
  Serial.print(F(", for sent "));
  Serial.print(late);
  Serial.println(F(")"));
  Serial.print(F("Snitt: "));
  Serial.print(averageMs());
  Serial.print(F(" ms, beste: "));
  Serial.print(bestMs);
  Serial.println(F(" ms"));
  Serial.print(F("Du er en "));
  Serial.println(titleFor(averageMs()));
  if (newRecord) {
    Serial.println(F("NY REKORD!"));
  }
}

// Resultatsidene vises etter hverandre til noen trykker. I de første 1,5 sekundene reagerer
// ikke spillet på knappene, så et sent slag ikke får deg forbi resultatet.
void showResults() {
  fanfare();
  newRecord = points > record;
  if (newRecord) {
    record = points;
    saveRecord();
  }
  printResult();
  unsigned long shownAt = millis();
  unsigned long pageAt = shownAt;
  byte page = 0;
  bool ready = false;
  showResultPage(page);
  while (true) {
    rainbowStep(6);
    if (millis() - pageAt >= PAGE_MS) {
      page = (page + 1) % RESULT_PAGES;
      pageAt = millis();
      showResultPage(page);
    }
    if (millis() - shownAt >= IGNORE_MS) {
      if (!ready) {
        ready = allReleased();  // først må alle knapper være sluppet
      } else if (readButton() >= 0) {
        return;  // et nytt trykk: tilbake til menyen
      }
    }
  }
}

// ===================== setup og loop =====================

void setup() {
  Serial.begin(9600);
  for (byte i = 0; i < 3; i++) {
    pinMode(BUTTON_PINS[i], INPUT_PULLUP);  // knappen kobler pinnen til GND
  }
  pinMode(PIEZO_PIN, OUTPUT);
  ring.begin();
  ring.setBrightness(BRIGHTNESS);
  ringOff();
  oled.begin();
  oled.enableUTF8Print();  // trengs for oled.print(); drawUTF8() forstår Æ, Ø og Å uansett
  loadRecord();
}

void loop() {
  showMenu();
  Serial.print(F("Reaksjonsspill. Rekord: "));
  Serial.println(record);
  // Vent på et nytt trykk mens regnbuen går. Først må alle knapper være sluppet.
  bool ready = false;
  while (true) {
    rainbowStep(6);
    if (!ready) {
      ready = allReleased();
    } else if (readButton() >= 0) {
      break;
    }
  }
  randomSeed(micros());  // tidspunktet for trykket er tilfeldig nok til å blande fargene
  while (!allReleased()) {
    rainbowStep(6);  // spillet starter når knappen slippes
  }
  playGame();
  showResults();
}

Slik tar spillet tiden

Det viktigste i hele programmet er at tiden måles riktig. Tre ting sørger for det:

  • Klokken starter etter ring.show(). Ringen får fargene sine over én ledning, og det tar rundt et halvt millisekund for 16 lysdioder. Programmet leser micros() rett etter at beskjeden er sendt, altså når ringen faktisk lyser.
  • Skjermen står stille mens ringen lyser. Å tegne et nytt bilde på skjermen tar noen millisekunder, og i den tiden ville programmet ikke sett knappene. Derfor skriver spillet til skjermen bare mellom rundene.
  • micros() og ikke millis(). Funksjonen teller mikrosekunder. Spillet regner om til hele millisekunder til slutt, så tiden på skjermen blir nøyaktig til millisekundet.

Mikrobryteren preller litt når kontakten sluttes: den åpner og lukker seg noen ganger i løpet av et par millisekunder før den blir liggende i ro. Det betyr ingenting for tiden, for spillet stopper klokken ved den første kontakten. Etterpå venter programmet til knappen har vært sluppet en liten stund, så prellingen ikke blir tolket som et nytt trykk.

Åtte skjermbilder på OLED: meny med rekord, nedtelling, SLÅ, et treff med tid og poeng, FEIL FARGE, TYVSTART og to resultatsider.
Skjermbildene i et spill, i rekkefølge. Menyen er fra et senere spill, derfor viser den allerede en rekord. Bildene er laget i en simulering med det samme skjermbiblioteket og de samme skriftene som programmet bruker, piksel for piksel.

Slik kan Serial Monitor se ut etter et spill. Tidene er fra en simulering. Spillet skriver én linje per runde, så du kan se hva som skjedde, også når skjermen allerede har gått videre:

Reaksjonsspill. Rekord: 0
SLÅ! Spillet varer i 30 sekunder.
Treff på blå: 438 ms, +562 poeng
Treff på gul: 466 ms, +534 poeng
Feil farge: ringen var rød, du trykket på blå: -250 poeng
Treff på gul: 451 ms, +549 poeng
For sent: blå ventet i 1,5 s
Treff på rød: 423 ms, +577 poeng
Tyvstart: -250 poeng
Treff på rød: 539 ms, +461 poeng
...
Slutt! Poeng: 6335
Treff: 13, feil: 3 (tyvstart 1, for sent 1)
Snitt: 474 ms, beste: 423 ms
Du er en Gaupe
NY REKORD!

Konsollen: et kabinett du kan 3D-printe

Løse knapper på et bord er morsomt en stund, men de glir rundt når du trykker hardt på dem. Vi har derfor tegnet en konsoll som holder alt på plass: en avrundet trekant med én knapp i hvert hjørne og lysringen med skjermen i midten, der alle ser likevel. Knappene sitter like langt fra midten og like langt fra hverandre, og skjermen leses fra den flate forkanten, der du står. Målene er hentet fra databladene og produktbildene og sjekket i 3D-modellen, men konsollen er ikke printet og satt sammen.

3D-gjengivelse av den grå trekantede konsollen med blå, rød og gul knapp og lysspalten med skjermvinduet i midten.
3D-gjengivelse av konsollen med de tre knappene. Ringen sitter under lokket og lyser gjennom spalten, skjermen ses gjennom vinduet i midten, og de sju små hullene til venstre er for summeren.

Konsollen er 277 mm bred, 256 mm dyp og 83 mm høy, 135 mm med knappene. Den består av et skall og en bunnplate. Knappene sitter i hull på 25 mm, og under knapperingene er lokket 4 mm tykt, så mutteren får godt tak. Under lokket er det 80 mm fri høyde til bryterholderne. I midten lyser ringen gjennom en spalte med åtte smale stag, og skjermen ses gjennom et skrått vindu inne i ringen. Ringen og skjermen sitter i en egen printet holder som skrus fast under lokket. Summeren ligger under sju små hull bak til venstre, og USB-kabelen går ut gjennom et spor bak til høyre. UNO og koblingsbrettet sitter på bunnplaten. Skallet printes opp ned, uten støttemateriale, og hele konsollen veier rundt 0,9 kg med knappene, så den står stille når noen slår hardt.

Til monteringen trenger du ni senkehodeskruer M3 x 8 fra skruesettet, ni skruer M3 x 8 med rundt hode fra M3-monteringssettet og fire selvklebende gummiføtter på 12 x 12 mm. I tillegg trenger du et buntebånd og litt varmlim eller dobbeltsidig tape.

Konsollen sett ovenfra med mål, plassen til knappene, lysringen, skjermen, UNO, koblingsbrettet og summeren.
Konsollen sett ovenfra, mål i millimeter. Knappene står 92 mm fra midten og 159 mm fra hverandre. De stiplede delene sitter inne i konsollen: UNO og koblingsbrettet på bunnplaten, summeren under lokket.

Monter i denne rekkefølgen:

  1. Skyv de tre knappene ned gjennom hullene, og skru mutterne på fra innsiden: rød bak, blå foran til venstre og gul foran til høyre. Du kan også velge en annen plassering, for koden bryr seg bare om hvilken pinne hver knapp sitter på.
  2. Lodd ledningene på mikrobryterne og på ringen, som i avsnittet om koblingen, og sett bryterne tilbake i knappene.
  3. Legg ringen i holderen med lysdiodene opp og loddeflatene over et av de tre hakkene, med litt varmlim eller tape under. Sett skjermen på de fire tappene med glasset opp og stiftlisten bakerst, mot den røde knappen. Pinnene peker ned, og på dem setter du hunnendene.
  4. Skru holderen fast på de tre stolpene under midten av lokket med tre skruer M3 x 8 med rundt hode.
  5. Legg summeren mellom de fire ribbene under de sju hullene, med ledningene innover, og skru den printede klemlisten fast over den med to skruer.
  6. Skru UNO fast på de fire stolpene på bunnplaten med fire skruer, og fest koblingsbrettet mellom merkene ved siden av med tapen på baksiden.
  7. Still skallet på høykant langs den bakre venstre kanten, ved siden av bunnplaten. Med ledninger på 20 cm kan det stå åpent i en vinkel på rundt 60 grader mens du kobler. Koble alt som i koblingstegningen.
  8. Sett datakabelen i UNO, så du kan laste opp koden mens skallet står åpent.

Til slutt legger du kabelen over festet på bunnplaten og strammer et buntebånd rundt. Så senker du skallet ned, så kabelen ligger i sporet og kanten på bunnplaten går inn i skallet. Skru i de ni senkehodeskruene fra undersiden, og sett de fire gummiføttene i merkene.

Uten 3D-printer

Konsollen kan også lages av en kraftig eske eller av kryssfiner. Kryssfiner på 4 mm er et godt valg, for lokket må ikke bøye seg når noen slår hardt, og mutterne holder knappene best på et lokk som er 4 til 6 mm tykt. Hver knapp trenger et hull på 24 til 25 mm. Under lokket må det være minst 80 mm fri høyde, for bryterholderen og ledningene stikker langt ned. Sett knappene med minst 120 mm mellom sentrene, så hendene ikke kolliderer. Til ringen borer du 16 hull på 5 mm i en sirkel med en diameter på 63 mm, rett over lysdiodene, og sager ut et vindu på 32 x 17 mm i midten til skjermen. Ringen festes rett under lokket med dobbeltsidig tape. Skjermmodulen er litt for stor til å ligge inne i ringen, så skru den fast under lokket med fire avstandsstykker på minst 5 mm. Da sitter den lavere enn ringen.

Nivå 3: Stroop-test og forsøk til skoleprosjektet

Nivå 3: viderekommen, eller et skoleprosjekt. Tid: rundt 30 minutter å laste opp, og så lenge forsøket tar. Den samme koblingen. Til forsøket trenger du også en datamaskin med Serial Monitor eller et regneark.

Nivå 3 gir spillet tre moduser. Du velger med den første knappen du trykker på i menyen:

Knapp i menyenModusHva du gjør
RødKlassiskDet samme spillet som i nivå 2
BlåStroopSkjermen viser et fargeord. Du trykker på knappen med ringens farge, ikke den ordet sier
GulForsøk20 runder uten tidsgrense. Hver runde skrives som en linje i Serial Monitor

Hver modus har sin egen rekord i minnet, så en rask runde i klassisk modus ødelegger ikke rekorden i Stroop.

Hva er Stroop-effekten?

I 1935 publiserte den amerikanske psykologen John Ridley Stroop en studie som siden er blitt en av de mest kjente i psykologien. Forsøkspersonene skulle si fargen på blekket i trykte ord. Når ordet var navnet på en annen farge, for eksempel «rød» skrevet med blått blekk, tok det lengre tid og ga flere feil enn når de skulle si fargen på ensfargede felt. Lesing går så automatisk at hjernen ikke klarer å la være å lese ordet, og det forstyrrer når ordet og fargen ikke stemmer.

To eksempler på Stroop-modusen: ordet RØD i en rød ring, der ord og farge stemmer, og ordet BLÅ i en gul ring, der riktig svar er den gule knappen.
Til venstre stemmer ordet og fargen. Til høyre står det BLÅ, men ringen er gul, så riktig knapp er den gule.

Spillet bruker en variant av den samme ideen. Skjermen er blå uansett, så ordet og fargen kommer fra to forskjellige steder: ordet fra skjermen og fargen fra ringen rundt. I omtrent hver fjerde runde stemmer ordet og ringen, ellers er de forskjellige. Når du spiller, kjenner du effekten selv: hånden vil mot den knappen ordet sier.

Vis hele koden til nivå 3
// Nivå 3: tre spill i ett. Velg i menyen med knappene:
//   RØD  Klassisk: som nivå 2.
//   BLÅ  Stroop: skjermen viser et fargeord som oftest IKKE er fargen i ringen.
//        Trykk på knappen med ringens farge. Hjernen leser ordet av seg selv, og det koster tid.
//   GUL  Forsøk: 20 runder uten tidsgrense. Hver runde blir en CSV-linje i
//        Serial Monitor (9600 baud), klar for et regneark. Til slutt kommer snitt og median.
// Hver modus har sin egen rekord i EEPROM.
// Biblioteker fra Library Manager: Adafruit NeoPixel og U8g2.
#include <Adafruit_NeoPixel.h>
#include <U8g2lib.h>
#include <SPI.h>
#include <EEPROM.h>

// ---- Koblinger ----
const byte BUTTON_PINS[3] = {2, 3, 4};  // rød, blå og gul knapp; COM på knappen går til GND
const byte PIEZO_PIN = 5;               // piezo + gjennom 100 Ω, piezo - til GND
const byte RING_PIN = 6;                // DIN på LED-ringen gjennom 470 Ω
const byte OLED_CS = 10;                // CS på skjermen
const byte OLED_DC = 9;                 // D/C på skjermen
const byte OLED_RES = 8;                // RES på skjermen
// DIN og CLK på skjermen går til D11 og D13: kortets maskinvare-SPI.
// Ringen får 5V og GND fra kortet, med en kondensator på 100 µF mellom 5V og GND ved ringen.

#define OLED_ROTATION U8G2_R0  // bytt til U8G2_R2 hvis teksten står opp ned

const byte RING_LEDS = 16;  // lysdioder i ringen
// Lysstyrke 60 av 255. En lysdiode bruker opptil 60 mA på full hvit, så hele ringen
// trekker høyst 16 x 60 mA x 60/255 = ca. 230 mA. Det tåler USB godt.
const byte BRIGHTNESS = 60;

// ---- Spillene: knappen du trykker på i menyen ----
const byte CLASSIC = 0;     // RØD
const byte STROOP = 1;      // BLÅ
const byte EXPERIMENT = 2;  // GUL
const char* MODE_NAMES[3] = {"Klassisk", "Stroop", "Forsøk"};

// ---- Regler for Klassisk og Stroop ----
const unsigned long GAME_MS = 30000;     // så lenge spillet varer
const unsigned long WAIT_MIN_MS = 700;   // korteste mørke pause før fargen
const unsigned long WAIT_MAX_MS = 1800;  // lengste mørke pause
const unsigned long TIMEOUT_MS = 1500;   // så lenge fargen venter på et trykk
const long MAX_POINTS = 1000;            // et treff gir 1000 minus tiden i ms ...
const long MIN_POINTS = 100;             // ... men minst 100
const long PENALTY = 250;                // trekk for feil farge og tyvstart
const byte STROOP_MATCH_PERCENT = 25;    // så ofte ordet er det samme som fargen i Stroop

// ---- Regler for Forsøk ----
const byte TRIALS = 20;               // runder
const byte TRIAL_MATCH_PERCENT = 50;  // omtrent halvparten der ordet og fargen stemmer

// Titler etter snittiden. Tiden omfatter også håndbevegelsen, ikke bare reaksjonen i hodet.
const unsigned long LYN_MS = 400;       // under 400 ms: Lyn
const unsigned long GAUPE_MS = 500;     // under 500 ms: Gaupe
const unsigned long REV_MS = 600;       // under 600 ms: Rev
const unsigned long GREVLING_MS = 750;  // under 750 ms: Grevling, ellers Skilpadde

// ---- Tider for lys, lyd og skjerm ----
const unsigned long RELEASE_MS = 30;   // alle knapper oppe så lenge = sluppet
const unsigned long STEP_MS = 1000;    // hvert tall i nedtellingen
const unsigned long FLASH_MS = 120;    // grønt eller hvitt blink
const unsigned long IGNORE_MS = 1500;  // knappene teller ikke så lenge etter slutt
const unsigned long PAGE_MS = 2500;    // hver resultatside vises så lenge
const byte RESULT_PAGES = 4;           // fire resultatsider i alle spillene
const unsigned int BEEP_HZ = 2000;     // pip i nedtellingen
const unsigned int GO_HZ = 3000;       // «SLÅ!»
const unsigned int RIGHT_HZ = 4000;    // riktig farge
const unsigned int WRONG_HZ = 400;     // feil, tyvstart og for sent

// Farger som 0xRRGGBB. Grønt betyr «riktig» og er ikke en spillfarge.
const uint32_t COLORS[3] = {0xFF0000, 0x0000FF, 0xFFA000};  // rød, blå, gul
const uint32_t GREEN = 0x00FF00;
const uint32_t WHITE = 0xFFFFFF;
const char* COLOR_WORDS[3] = {"RØD", "BLÅ", "GUL"};  // på skjermen
const char* COLOR_NAMES[3] = {"rød", "blå", "gul"};  // i Serial Monitor
const char* GROUP_NAMES[3] = {"alle", "like", "ulike"};

// Skrifter. De to første har Æ, Ø og Å (ikke alle skrifter i U8g2 har dem, så sjekk før du bytter).
// Slutten _tn betyr bare tall.
// Få skrifter, så alt får plass i flashminnet på en UNO R3 også.
#define FONT_SMALL u8g2_font_6x13_tf         // 13 piksler høy
#define FONT_BIG u8g2_font_helvB14_tf        // 14 piksler høy
#define FONT_DIGITS u8g2_font_logisoso32_tn  // 32 piksler høye tall

// Rekordene ligger i EEPROM, så de er der også etter at strømmen har vært borte.
const int EEPROM_ADDR = 0;
const unsigned long MAGIC = 0x52454133;  // viser at rekordene er skrevet av dette spillet
struct Saved {
  unsigned long magic;
  long records[3];  // Klassisk og Stroop: poeng. Forsøk: beste median i ms. 0 = ingen ennå
};

Adafruit_NeoPixel ring(RING_LEDS, RING_PIN, NEO_GRB + NEO_KHZ800);
// «_1_» betyr at bildet tegnes én stripe (8 linjer) om gangen. Det bruker bare 128 byte RAM,
// så spillet får plass også på en UNO R3. Derfor står tegningen i en firstPage/nextPage-løkke.
U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI oled(OLED_ROTATION, OLED_CS, OLED_DC, OLED_RES);

byte mode = CLASSIC;          // spillet som er valgt
long records[3];              // rekord per spill
long points = 0;              // poeng i spillet som pågår
int hits = 0;                 // treff
int errors = 0;               // feil farge (i Klassisk og Stroop også tyvstart og for sent)
int falseStarts = 0;          // tyvstarter
int late = 0;                 // for sent
unsigned long sumMs = 0;      // summen av trefftidene, til snittet
unsigned long bestMs = 0;     // raskeste treff (0 = ingen ennå)
unsigned long gameStart = 0;  // når «SLÅ!» kom
bool newRecord = false;       // ble rekorden slått denne gangen?
byte lastColor = 255;         // forrige farge (255 = ingen)
byte colorBefore = 255;       // fargen før den igjen
unsigned long rainbowAt = 0;  // når regnbuen sist ble tegnet
unsigned long reactionMs = 0; // tiden fra siste runde

// Forsøk: én plass per runde
byte trialNumber = 0;           // runden som pågår, 1 til 20
unsigned long trialMs[TRIALS];  // reaksjonstid
bool trialRight[TRIALS];        // riktig knapp?
bool trialSame[TRIALS];         // var ordet det samme som fargen?
byte groupCount[3];             // oppsummering: antall riktige i alle, like og ulike
unsigned long groupMean[3];     // snitt i ms
unsigned long groupMedian[3];   // median i ms

// ===================== Knapper =====================

// Gir nummeret på knappen som er nede (0 rød, 1 blå, 2 gul), eller -1 når ingen er nede.
// Den første kontakten teller som trykket. At bryteren preller etterpå (kontakten åpner og
// lukker seg noen ganger), spiller ingen rolle: spillet venter uansett til knappen er sluppet.
int readButton() {
  for (byte i = 0; i < 3; i++) {
    if (digitalRead(BUTTON_PINS[i]) == LOW) {  // INPUT_PULLUP: nede = LOW
      return i;
    }
  }
  return -1;
}

// Gir true når ingen knapp har vært nede på RELEASE_MS. Da er prellingen over.
bool allReleased() {
  unsigned long start = millis();
  while (millis() - start < RELEASE_MS) {
    if (readButton() >= 0) {
      return false;
    }
  }
  return true;
}

// ===================== Ringen =====================

void ringFill(uint32_t color) {
  ring.fill(color);
  ring.show();
}

void ringOff() {
  ring.clear();
  ring.show();
}

// Tenner de første «count» lysdiodene hvite: buen i nedtellingen.
void ringArc(int count) {
  ring.clear();
  for (int i = 0; i < count; i++) {
    ring.setPixelColor(i, WHITE);
  }
  ring.show();
}

// Regnbue som vandrer rundt. Kan kalles så ofte du vil; den tegner hvert 20. ms.
// speed: hvor fort fargene vandrer.
void rainbowStep(unsigned int speed) {
  if (millis() - rainbowAt >= 20) {
    rainbowAt = millis();
    ring.rainbow(millis() * speed);  // fargetonen (0 til 65535) går rundt av seg selv
    ring.show();
  }
}

// ===================== Skjermen =====================

// Skriver teksten midt på skjermen. y er grunnlinjen, altså bunnen av bokstavene.
void centerText(const char* text, int y) {
  int x = (oled.getDisplayWidth() - oled.getUTF8Width(text)) / 2;
  if (x < 0) {
    x = 0;
  }
  oled.drawUTF8(x, y, text);
}

// Én tekst midt på skjermen med valgt skrift.
void showBig(const char* text, const uint8_t* font, int y) {
  oled.firstPage();
  do {
    oled.setFont(font);
    centerText(text, y);
  } while (oled.nextPage());
}

// Tre linjer: liten tekst øverst, stor tekst i midten, liten tekst nederst.
void showPage(const char* top, const char* big, const char* bottom) {
  oled.firstPage();
  do {
    oled.setFont(FONT_SMALL);
    centerText(top, 12);
    oled.setFont(FONT_BIG);
    centerText(big, 40);
    oled.setFont(FONT_SMALL);
    centerText(bottom, 60);
  } while (oled.nextPage());
}

// Menyen: fargen på knappen, navnet på spillet og rekorden.
void showMenu() {
  char recordText[3][12];
  for (byte m = 0; m < 3; m++) {
    if (records[m] == 0) {
      snprintf(recordText[m], sizeof recordText[m], "-");
    } else if (m == EXPERIMENT) {
      snprintf(recordText[m], sizeof recordText[m], "%ld ms", records[m]);
    } else {
      snprintf(recordText[m], sizeof recordText[m], "%ld", records[m]);
    }
  }
  oled.firstPage();
  do {
    oled.setFont(FONT_SMALL);
    centerText("REAKSJONSSPILL", 12);
    oled.drawHLine(0, 16, oled.getDisplayWidth());
    for (byte m = 0; m < 3; m++) {
      int y = 31 + m * 15;
      oled.drawUTF8(0, y, COLOR_WORDS[m]);
      oled.drawUTF8(28, y, MODE_NAMES[m]);
      oled.drawUTF8(oled.getDisplayWidth() - oled.getUTF8Width(recordText[m]), y, recordText[m]);
    }
  } while (oled.nextPage());
}

// Etter en runde: poeng og sekunder igjen (i Forsøk: runden) øverst,
// beskjeden stort, detaljen under. Kalles bare når ringen ikke viser en spillfarge.
void showRound(const char* big, const char* small) {
  char left[16];
  char right[8];
  if (mode == EXPERIMENT) {
    snprintf(left, sizeof left, "Runde %d/%d", trialNumber, TRIALS);
    snprintf(right, sizeof right, " ");
  } else {
    unsigned long used = millis() - gameStart;
    unsigned long secondsLeft = 0;
    if (used < GAME_MS) {
      secondsLeft = (GAME_MS - used + 999) / 1000;  // rund opp: 0,2 s igjen vises som 1 s
    }
    snprintf(left, sizeof left, "Poeng %ld", points);
    snprintf(right, sizeof right, "%lu s", secondsLeft);
  }
  oled.firstPage();
  do {
    oled.setFont(FONT_SMALL);
    oled.drawUTF8(0, 11, left);
    oled.drawUTF8(oled.getDisplayWidth() - oled.getUTF8Width(right), 11, right);
    oled.setFont(FONT_BIG);
    centerText(big, 40);
    oled.setFont(FONT_SMALL);
    centerText(small, 60);
  } while (oled.nextPage());
}

// Tittel etter snittiden. Uten treff (snitt 0) blir det Skilpadde.
const char* titleFor(unsigned long avgMs) {
  if (avgMs == 0) return "Skilpadde";
  if (avgMs < LYN_MS) return "Lyn";
  if (avgMs < GAUPE_MS) return "Gaupe";
  if (avgMs < REV_MS) return "Rev";
  if (avgMs < GREVLING_MS) return "Grevling";
  return "Skilpadde";
}

unsigned long averageMs() {
  if (hits == 0) {
    return 0;
  }
  return sumMs / hits;
}

// Klassisk og Stroop. Side 0: poengene. Side 1: treff og feil. Side 2: tidene.
// Side 3: tittel og rekord.
void showGamePage(byte page) {
  char line1[20];
  char line2[20];
  if (page == 0) {
    snprintf(line1, sizeof line1, "%ld", points);
    oled.firstPage();
    do {
      oled.setFont(FONT_SMALL);
      centerText(mode == STROOP ? "POENG I STROOP" : "POENG", 12);
      oled.setFont(FONT_DIGITS);
      centerText(line1, 52);
    } while (oled.nextPage());
  } else if (page == 1) {
    snprintf(line1, sizeof line1, "Treff %d", hits);
    snprintf(line2, sizeof line2, "Feil %d", errors);
    oled.firstPage();
    do {
      oled.setFont(FONT_BIG);
      centerText(line1, 28);
      centerText(line2, 58);
    } while (oled.nextPage());
  } else if (page == 2) {
    if (hits > 0) {
      snprintf(line1, sizeof line1, "%lu ms", averageMs());
      snprintf(line2, sizeof line2, "Beste %lu ms", bestMs);
    } else {
      snprintf(line1, sizeof line1, "-");
      snprintf(line2, sizeof line2, "Ingen treff");
    }
    showPage("Snitt", line1, line2);
  } else {
    if (newRecord) {
      snprintf(line2, sizeof line2, "NY REKORD!");
    } else {
      snprintf(line2, sizeof line2, "Rekord: %ld", records[mode]);
    }
    showPage("Du er en", titleFor(averageMs()), line2);
  }
}

// Forsøk. Side 0: median og snitt. Side 1: like mot ulike ord. Side 2: Stroop-effekten.
// Side 3: rekorden.
void showExperimentPage(byte page) {
  char big[16];
  char bottom[24];
  if (page == 0) {
    snprintf(big, sizeof big, "%lu ms", groupMedian[0]);
    snprintf(bottom, sizeof bottom, "Snitt %lu ms", groupMean[0]);
    showPage("Median, treff", big, bottom);
  } else if (page == 1) {
    snprintf(big, sizeof big, "%lu ms", groupMedian[1]);
    snprintf(bottom, sizeof bottom, "Ulike ord: %lu ms", groupMedian[2]);
    showPage("Like ord", big, bottom);
  } else if (page == 2) {
    long effect = (long)groupMedian[2] - (long)groupMedian[1];
    snprintf(big, sizeof big, "%s%ld ms", effect >= 0 ? "+" : "", effect);
    snprintf(bottom, sizeof bottom, "Feil %d", errors);
    showPage("Stroop-effekt", big, bottom);
  } else {
    if (records[EXPERIMENT] > 0) {
      snprintf(big, sizeof big, "%ld ms", records[EXPERIMENT]);
    } else {
      snprintf(big, sizeof big, "-");
    }
    showPage("Rekord, median", big, newRecord ? "NY REKORD!" : "");
  }
}

// ===================== Rekorder i EEPROM =====================

void loadRecords() {
  Saved saved;
  EEPROM.get(EEPROM_ADDR, saved);
  for (byte m = 0; m < 3; m++) {
    if (saved.magic == MAGIC) {
      records[m] = saved.records[m];
    } else {
      records[m] = 0;  // tomt minne, eller skrevet av et annet program
    }
  }
}

// Skrives bare ved ny rekord, så minnet ikke slites.
void saveRecords() {
  Saved saved;
  saved.magic = MAGIC;
  for (byte m = 0; m < 3; m++) {
    saved.records[m] = records[m];
  }
  EEPROM.put(EEPROM_ADDR, saved);
}

// ===================== Felles for alle spillene =====================

// Forsøk har ingen tidsgrense; de to andre slutter etter GAME_MS.
bool timeIsUp() {
  if (mode == EXPERIMENT) {
    return false;
  }
  return millis() - gameStart >= GAME_MS;
}

// Trekker fra poeng, men aldri under 0.
void penalty() {
  points -= PENALTY;
  if (points < 0) {
    points = 0;
  }
}

// Velger rød, blå eller gul tilfeldig, men aldri samme farge tre ganger på rad.
byte pickColor() {
  byte color = random(3);
  if (color == lastColor && color == colorBefore) {
    color = (color + 1 + random(2)) % 3;  // en av de to andre
  }
  colorBefore = lastColor;
  lastColor = color;
  return color;
}

// Velger ordet på skjermen. matchPercent av gangene er ordet det samme som fargen,
// ellers et av de to andre.
byte pickWord(byte color, byte matchPercent) {
  if (random(100) < matchPercent) {
    return color;
  }
  return (color + 1 + random(2)) % 3;
}

// 3, 2, 1 med pip og en hvit bue som krymper. Så «SLÅ!» og spillet starter.
void countdown() {
  unsigned long start = millis();
  int shownDigit = 0;
  int shownLeds = -1;
  while (millis() - start < 3 * STEP_MS) {
    unsigned long elapsed = millis() - start;
    int digit = 3 - elapsed / STEP_MS;
    if (digit != shownDigit) {
      shownDigit = digit;
      tone(PIEZO_PIN, BEEP_HZ, 100);
      char text[4];
      snprintf(text, sizeof text, "%d", digit);
      showBig(text, FONT_DIGITS, 48);
    }
    int leds = RING_LEDS - (elapsed * RING_LEDS) / (3 * STEP_MS);
    if (leds != shownLeds) {  // tegn ringen bare når buen endrer seg
      shownLeds = leds;
      ringArc(leds);
    }
  }
  ringOff();
  tone(PIEZO_PIN, GO_HZ, 400);
  showBig("SLÅ!", FONT_BIG, 42);
}

// Mørk pause med tilfeldig lengde, så ingen kan gjette når fargen kommer.
// Gir false ved tyvstart eller når tiden er ute.
bool darkPause() {
  char text[12];
  ringOff();
  unsigned long waitMs = random(WAIT_MIN_MS, WAIT_MAX_MS + 1);
  unsigned long start = millis();
  while (millis() - start < waitMs) {
    if (timeIsUp()) {
      return false;
    }
    if (readButton() >= 0) {  // trykk før fargen: tyvstart
      falseStarts++;
      if (mode == EXPERIMENT) {
        snprintf(text, sizeof text, "Ny pause");  // runden tas på nytt, uten trekk
      } else {
        errors++;
        penalty();
        snprintf(text, sizeof text, "-%ld", PENALTY);
        Serial.print(F("Tyvstart: -"));
        Serial.print(PENALTY);
        Serial.println(F(" poeng"));
      }
      tone(PIEZO_PIN, WRONG_HZ, 300);
      ringFill(WHITE);
      showRound("TYVSTART!", text);
      delay(FLASH_MS);
      ringOff();
      return false;
    }
  }
  return true;
}

// Tenner fargen og venter på et trykk. Gir knappen, -1 når fargen ventet for lenge
// eller -2 når spillet er slutt. Tiden havner i reactionMs.
// limitMs = 0 betyr ingen tidsgrense (Forsøk).
int waitForAnswer(byte color, unsigned long limitMs) {
  // Klokken startes rett etter show(), for da lyser ringen.
  // Skjermen tegnes ikke nå: det ville forsinket avlesningen av knappene.
  ringFill(COLORS[color]);
  unsigned long t0 = micros();
  int pressed = -1;
  unsigned long elapsedUs = 0;
  while (pressed < 0 && (limitMs == 0 || elapsedUs < limitMs * 1000)) {
    if (timeIsUp()) {
      ringOff();
      return -2;  // spillet er slutt midt i runden: den teller ikke
    }
    pressed = readButton();
    elapsedUs = micros() - t0;
  }
  reactionMs = elapsedUs / 1000;
  return pressed;
}

// ===================== Klassisk og Stroop =====================

// Én runde: vent til knappene er sluppet, mørk pause, fargen, så svaret.
void playRound() {
  char big[12];
  char small[8];

  // Neste farge kommer først når alle knapper er sluppet.
  while (!allReleased()) {
    if (timeIsUp()) {
      return;
    }
  }
  if (!darkPause()) {
    return;  // tyvstart eller tiden er ute: en ny runde begynner med en ny pause
  }

  byte color = pickColor();
  if (mode == STROOP) {
    // Ordet tegnes rett før ringen tennes. Tiden måles fra ringen, ikke fra ordet.
    showBig(COLOR_WORDS[pickWord(color, STROOP_MATCH_PERCENT)], FONT_BIG, 42);
  }
  int pressed = waitForAnswer(color, TIMEOUT_MS);
  if (pressed == -2) {
    return;
  }
  unsigned long ms = reactionMs;

  // Bare ringens farge teller, også i Stroop.
  if (pressed == color) {
    long gained = MAX_POINTS - (long)ms;
    if (gained < MIN_POINTS) {
      gained = MIN_POINTS;
    }
    points += gained;
    hits++;
    sumMs += ms;
    if (bestMs == 0 || ms < bestMs) {
      bestMs = ms;
    }
    ringFill(GREEN);
    tone(PIEZO_PIN, RIGHT_HZ, 80);
    snprintf(big, sizeof big, "%lu ms", ms);
    snprintf(small, sizeof small, "+%ld", gained);
    showRound(big, small);
    Serial.print(F("Treff på "));
    Serial.print(COLOR_NAMES[color]);
    Serial.print(F(": "));
    Serial.print(ms);
    Serial.print(F(" ms, +"));
    Serial.print(gained);
    Serial.println(F(" poeng"));
    delay(FLASH_MS);
    ringOff();
  } else if (pressed >= 0) {
    errors++;
    penalty();
    ringOff();
    tone(PIEZO_PIN, WRONG_HZ, 300);
    snprintf(small, sizeof small, "-%ld", PENALTY);
    showRound("FEIL FARGE", small);
    Serial.print(F("Feil farge: ringen var "));
    Serial.print(COLOR_NAMES[color]);
    Serial.print(F(", du trykket på "));
    Serial.print(COLOR_NAMES[pressed]);
    Serial.print(F(": -"));
    Serial.print(PENALTY);
    Serial.println(F(" poeng"));
  } else {
    late++;
    errors++;
    ringOff();
    tone(PIEZO_PIN, WRONG_HZ, 300);
    showRound("FOR SENT", "");
    Serial.print(F("For sent: "));
    Serial.print(COLOR_NAMES[color]);
    Serial.println(F(" ventet i 1,5 s"));
  }
}

void resetScore() {
  points = 0;
  hits = 0;
  errors = 0;
  falseStarts = 0;
  late = 0;
  sumMs = 0;
  bestMs = 0;
  lastColor = 255;
  colorBefore = 255;
}

void playGame() {
  resetScore();
  countdown();
  gameStart = millis();
  Serial.print(F("SLÅ! "));
  Serial.print(MODE_NAMES[mode]);
  Serial.println(F(": spillet varer i 30 sekunder."));
  while (!timeIsUp()) {
    playRound();
  }
  ringOff();
}

// ===================== Forsøk =====================

// Median: sorter tidene og ta den midterste. Én treg runde drar snittet med seg,
// men ikke medianen. Sorteringen flytter hver tid bakover til den står riktig.
unsigned long median(unsigned long values[], byte count) {
  for (byte i = 1; i < count; i++) {
    unsigned long value = values[i];
    byte j = i;
    while (j > 0 && values[j - 1] > value) {
      values[j] = values[j - 1];
      j--;
    }
    values[j] = value;
  }
  if (count == 0) {
    return 0;
  }
  if (count % 2 == 1) {
    return values[count / 2];
  }
  return (values[count / 2 - 1] + values[count / 2]) / 2;
}

// Antall, snitt og median for riktige trykk i én gruppe:
// 0 = alle, 1 = like (ordet er fargen), 2 = ulike.
void summarize(byte group) {
  unsigned long list[TRIALS];
  byte count = 0;
  unsigned long sum = 0;
  for (byte i = 0; i < TRIALS; i++) {
    bool inGroup = (group == 0) || (group == 1 && trialSame[i]) || (group == 2 && !trialSame[i]);
    if (trialRight[i] && inGroup) {
      list[count] = trialMs[i];
      sum += trialMs[i];
      count++;
    }
  }
  groupCount[group] = count;
  groupMean[group] = 0;
  if (count > 0) {
    groupMean[group] = sum / count;
  }
  groupMedian[group] = median(list, count);
}

// Én runde i Forsøk. Gir false ved tyvstart: da tas runden på nytt.
bool playTrial() {
  char big[12];
  while (!allReleased()) {
    // vent til alle knapper er sluppet
  }
  if (!darkPause()) {
    return false;
  }
  byte i = trialNumber - 1;  // plassen i tabellene
  byte color = pickColor();
  byte shownWord = pickWord(color, TRIAL_MATCH_PERCENT);
  // Ordet tegnes rett før ringen tennes. Tiden måles fra ringen, ikke fra ordet.
  showBig(COLOR_WORDS[shownWord], FONT_BIG, 42);
  int pressed = waitForAnswer(color, 0);  // ingen tidsgrense
  trialMs[i] = reactionMs;
  trialRight[i] = (pressed == color);
  trialSame[i] = (shownWord == color);

  // CSV-linje: runde;ring;ord;trykket;ms;like
  Serial.print(trialNumber);
  Serial.print(';');
  Serial.print(COLOR_NAMES[color]);
  Serial.print(';');
  Serial.print(COLOR_NAMES[shownWord]);
  Serial.print(';');
  Serial.print(COLOR_NAMES[pressed]);
  Serial.print(';');
  Serial.print(reactionMs);
  Serial.print(';');
  Serial.println(trialSame[i] ? 1 : 0);

  snprintf(big, sizeof big, "%lu ms", reactionMs);
  if (trialRight[i]) {
    hits++;
    ringFill(GREEN);
    tone(PIEZO_PIN, RIGHT_HZ, 80);
    showRound(big, "riktig");
    delay(FLASH_MS);
    ringOff();
  } else {
    errors++;
    ringOff();
    tone(PIEZO_PIN, WRONG_HZ, 300);
    showRound(big, "feil farge");
  }
  return true;
}

void runExperiment() {
  resetScore();
  // F() lar teksten ligge i flash i stedet for RAM. Det sparer plass på en UNO R3.
  Serial.println(F("runde;ring;ord;trykket;ms;like"));
  countdown();
  trialNumber = 1;
  while (trialNumber <= TRIALS) {
    if (playTrial()) {
      trialNumber++;
    }
  }
  trialNumber = TRIALS;
  ringOff();

  Serial.println();
  Serial.println(F("oppsummering;n;snitt_ms;median_ms"));
  for (byte g = 0; g < 3; g++) {
    summarize(g);
    Serial.print(GROUP_NAMES[g]);
    Serial.print(';');
    Serial.print(groupCount[g]);
    Serial.print(';');
    Serial.print(groupMean[g]);
    Serial.print(';');
    Serial.println(groupMedian[g]);
  }
  Serial.print(F("feil;"));
  Serial.println(errors);
  Serial.print(F("tyvstarter;"));
  Serial.println(falseStarts);
}

// ===================== Slutt og resultat =====================

// Fanfare med regnbuen i full fart: spillet er slutt.
void fanfare() {
  const unsigned int notes[4] = {523, 659, 784, 1047};  // C, E, G og høy C
  const unsigned long lengths[4] = {150, 150, 150, 500};
  for (byte i = 0; i < 4; i++) {
    tone(PIEZO_PIN, notes[i], lengths[i]);
    unsigned long start = millis();
    while (millis() - start < lengths[i] + 30) {
      rainbowStep(40);
    }
  }
}

// Ny rekord? Klassisk og Stroop: flere poeng. Forsøk: lavere median.
void checkRecord() {
  if (mode == EXPERIMENT) {
    long result = groupMedian[0];
    newRecord = groupCount[0] > 0 && (records[EXPERIMENT] == 0 || result < records[EXPERIMENT]);
    if (newRecord) {
      records[EXPERIMENT] = result;
    }
  } else {
    newRecord = points > records[mode];
    if (newRecord) {
      records[mode] = points;
    }
  }
  if (newRecord) {
    saveRecords();
  }
}

void printResult() {
  if (mode == EXPERIMENT) {
    if (newRecord) {
      Serial.println(F("NY REKORD!"));
    }
    return;  // oppsummeringen er skrevet allerede, som CSV
  }
  Serial.print(F("Slutt! Poeng: "));
  Serial.println(points);
  Serial.print(F("Treff: "));
  Serial.print(hits);
  Serial.print(F(", feil: "));
  Serial.print(errors);
  Serial.print(F(" (tyvstart "));
  Serial.print(falseStarts);
  Serial.print(F(", for sent "));
  Serial.print(late);
  Serial.println(F(")"));
  Serial.print(F("Snitt: "));
  Serial.print(averageMs());
  Serial.print(F(" ms, beste: "));
  Serial.print(bestMs);
  Serial.println(F(" ms"));
  Serial.print(F("Du er en "));
  Serial.println(titleFor(averageMs()));
  if (newRecord) {
    Serial.println(F("NY REKORD!"));
  }
}

void showResultPage(byte page) {
  if (mode == EXPERIMENT) {
    showExperimentPage(page);
  } else {
    showGamePage(page);
  }
}

// Resultatsidene vises etter hverandre til noen trykker. I de første 1,5 sekundene reagerer
// ikke spillet på knappene, så et sent slag ikke får deg forbi resultatet.
void showResults() {
  fanfare();
  checkRecord();
  printResult();
  unsigned long shownAt = millis();
  unsigned long pageAt = shownAt;
  byte page = 0;
  bool ready = false;
  showResultPage(page);
  while (true) {
    rainbowStep(6);
    if (millis() - pageAt >= PAGE_MS) {
      page = (page + 1) % RESULT_PAGES;
      pageAt = millis();
      showResultPage(page);
    }
    if (millis() - shownAt >= IGNORE_MS) {
      if (!ready) {
        ready = allReleased();  // først må alle knapper være sluppet
      } else if (readButton() >= 0) {
        return;  // et nytt trykk: tilbake til menyen
      }
    }
  }
}

// ===================== setup og loop =====================

void setup() {
  Serial.begin(9600);
  for (byte i = 0; i < 3; i++) {
    pinMode(BUTTON_PINS[i], INPUT_PULLUP);  // knappen kobler pinnen til GND
  }
  pinMode(PIEZO_PIN, OUTPUT);
  ring.begin();
  ring.setBrightness(BRIGHTNESS);
  ringOff();
  oled.begin();
  oled.enableUTF8Print();  // trengs for oled.print(); drawUTF8() forstår Æ, Ø og Å uansett
  loadRecords();
}

void loop() {
  showMenu();
  // Vent på et nytt trykk mens regnbuen går. Knappen du trykker på, velger spillet.
  bool ready = false;
  int pressed = -1;
  while (pressed < 0) {
    rainbowStep(6);
    if (!ready) {
      ready = allReleased();
    } else {
      pressed = readButton();
    }
  }
  mode = pressed;
  randomSeed(micros());  // tidspunktet for trykket er tilfeldig nok til å blande fargene
  while (!allReleased()) {
    rainbowStep(6);  // spillet starter når knappen slippes
  }
  if (mode == EXPERIMENT) {
    runExperiment();
  } else {
    playGame();
  }
  showResults();
}

Forsøk: reagerer vi tregere når ordet og fargen ikke stemmer?

Forsøksmodusen er laget for et skoleprosjekt eller et forsøk i naturfag. Den kjører 20 runder i Stroop-oppsettet, der ordet og fargen stemmer i omtrent halvparten av rundene, og skriver hver runde som en linje med semikolon mellom feltene. En tyvstart gir ingen trekk her: runden tas bare på nytt. Kolonnene er runde, fargen i ringen, ordet på skjermen, knappen du trykket på, tiden i ms og «like», som er 1 når ordet og fargen stemmer, og 0 ellers. Til slutt skriver den snittet og medianen for alle riktige trykk, for runder der ordet og fargen stemte («like»), og for runder der de ikke stemte («ulike»). På skjermen heter de to gruppene «Like ord» og «Ulike ord». Lim linjene inn i et regneark og del dem i kolonner med semikolon som skilletegn: i Excel heter det «Tekst til kolonner», i Google Regneark «Del teksten i kolonner». Du kan også lagre linjene i en fil med endelsen .csv og åpne den. Bare riktige trykk er med i tidene. Rekorden i forsøksmodusen er den laveste medianen.

Eksempelet under kommer fra en simulering og viser ikke målte tider. Det viser bare hvordan linjene ser ut:

runde;ring;ord;trykket;ms;like
1;gul;gul;gul;395;1
2;rød;rød;rød;432;1
3;blå;rød;blå;484;0
4;rød;rød;blå;446;1
5;gul;rød;gul;498;0
...
20;blå;blå;blå;438;1

oppsummering;n;snitt_ms;median_ms
alle;19;456;442
like;10;422;428
ulike;9;495;489
feil;1
tyvstarter;1
NY REKORD!
  1. Still et spørsmål. For eksempel: Tar det lengre tid å trykke riktig når ordet og fargen ikke stemmer?
  2. Lag en hypotese. Skriv ned hva du tror, før du måler. For eksempel: Vi tror medianen blir minst 50 ms lengre når ordet og fargen ikke stemmer.
  3. Gjør alle forsøk likt. Samme stol, samme avstand til konsollen, samme startstilling for hendene og samme lys i rommet. La alle forsøkspersonene prøve én runde først, så de vet hvordan spillet virker.
  4. Mål. Kjør forsøksmodusen med flere personer. Kopier linjene fra Serial Monitor til et regneark, én fane per person. Ikke skriv navn, bare et nummer.
  5. Regn ut. Sammenlign medianen for de to typene runder hos hver person. Medianen er den midterste tiden når alle tidene står i rekkefølge, og den blir ikke dratt opp av én runde der noen ble forstyrret.
  6. Konkluder. Ble hypotesen styrket eller svekket? Hvor mange personer viste effekten? Hva kunne gjort forsøket bedre?
Test deg selv: hvorfor bruker forsøket medianen og ikke bare snittet?

Fordi én veldig treg runde kan dra opp snittet mye. Har du nitten runder på rundt 500 ms og én på 1400 ms fordi noen ropte i gangen, blir snittet rundt 545 ms, mens medianen fortsatt er rundt 500 ms. Medianen viser derfor bedre hvordan personen vanligvis reagerer.

Typiske feil, og hva som er riktig

Skjermen er helt svart

Sjekk VCC og GND først, og deretter at CLK sitter på D13 og DIN på D11. Er de to byttet om, får skjermen ingen data. Står skjermen på I²C, viser den heller ingenting, se avsnittet om skjermen. Ser du fortsatt ingenting, kan du prøve å bytte SH1106 med SSD1306 i den lange linjen øverst i koden: noen skjermer ser like ut, men har en annen brikke.

Bildet på skjermen er forskjøvet to piksler, eller har en stripe i kanten

Da er koden satt opp for SSD1306, men skjermen har SH1106. Bruk linjen med U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI, som i koden over.

Ringen lyser i feil farge, for eksempel grønt i stedet for rødt

Ringer fra forskjellige produsenter sender fargene i forskjellig rekkefølge. Koden bruker NEO_GRB, som er vanlig for WS2812B. Blir rødt til grønt og grønt til rødt, bytter du til NEO_RGB i linjen der ringen opprettes.

Ringen er mørk

Sjekk at ledningen fra D6 og motstanden går til DIN og ikke til DOUT. Signalet går bare én vei gjennom ringen. Mål så at ringen har rundt 5 V mellom 5V og GND. Er bare den første lysdioden tent i en tilfeldig farge, mangler det felles jord mellom ringen og UNO.

En knapp gir trykk hele tiden, eller aldri

Gir den trykk hele tiden, sitter ledningen på NC i stedet for NO. Gir den aldri trykk, har en ledning løsnet, eller COM går ikke til jord. Last opp nivå 1 og test knappen alene.

Spillet starter på nytt når ringen blir hvit eller blinker

Spenningen faller et øyeblikk. Sjekk at kondensatoren sitter mellom 5 V og jord, og bruk en USB-lader eller en annen port. Ikke skru opp lysstyrken i koden over det som står der.

Summeren er nesten stille

Sjekk motstanden på 100 Ω. Er den på 100 kΩ, blir det nesten ingen lyd. Fargebåndene skal være brun, svart, brun. Summeren har en nominell spenning på 12 V og virker fra 1 til 40 V, så på 5 V lyder den svakere, men den bør være godt hørbar i et rom.

Æ, ø og å vises ikke på skjermen

Skriften må slutte på _tf, og teksten må skrives med drawUTF8(). Skrifter som slutter på _tr, har bare de engelske bokstavene. Men ikke alle _tf-skrifter har dem heller: de store skriftene logisoso20_tf og logisoso18_tf har tomme tegn for Ø og Å, så «SLÅ!» blir til «SL !». Derfor bruker koden helvB14_tf til stor tekst. Bytter du skrift, må du sjekke ordene RØD, BLÅ og SLÅ! på skjermen.

Vanlige spørsmål

Hva er en god reaksjonstid?

I en enkel test, der du trykker så fort noe lyser, har voksne i snitt rundt 200 til 250 ms. I dette spillet må du også velge farge og flytte hånden, så tidene blir lengre. I spillet regnes et snitt under 500 ms som raskt, og et snitt under 400 ms gir tittelen Lyn. Tiden blir lengre med trøtthet og med alderen, og den blir kortere med øvelse.

Kan jeg bruke en vanlig Arduino UNO R3 i stedet?

Ja. Koden kan også kompileres for UNO R3, og pinnene er de samme. Velg «Arduino Uno» i Arduino IDE. UNO R3 har en USB-B-kontakt, så du trenger en annen kabel.

Kan knappene lyse?

Knappene har plass til en lysdiode under kuppelen, men den er laget for 12 V. På 5 V blir den svak eller mørk. Vil du ha lys i knappene, trenger du 12 V og en transistor per knapp. I dette spillet er det ringen som viser fargen, og knappene er farget fra før, så vi bruker ikke lysene.

Kan to spillere konkurrere samtidig?

Ikke med denne koden. Spillet er laget for én spiller om gangen, og rekorden viser hvem som er best. Vil dere spille mot hverandre, kan dere bytte på og sammenligne poeng, eller bygge to konsoller og la hver spiller ha sin egen.

Hvorfor brukes ikke grønt som spillfarge?

Grønt betyr riktig i spillet. Ringen blinker grønt når du treffer, og da kan ikke grønt også være en av fargene du skal svare på. De tre fargene er dessuten lette å skille fra hverandre, også i sidesynet.

Er spillet egnet for fargeblinde?

Det kan by på problemer. Den vanligste formen for fargeblindhet gjør det vanskelig å skille rødt og grønt, og noen kan også blande sammen rødt og gult. Det som hjelper, er å vise et symbol for hver farge på skjermen. Det kan du legge til i koden.

Hvor mye strøm bruker spillet?

Lite nok til at en vanlig USB-lader klarer det godt, og en powerbank holder lenge. Ringen trekker mest: med lysstyrken i koden bruker den rundt 230 mA på det meste i hvitt, og mindre i én farge. Med UNO og skjermen i tillegg er det fortsatt under de 500 mA som en vanlig USB-port gir.

Hvor går du videre?

Nå har du et ferdig reaksjonsspill med tidtaking, poeng og rekord, og en konsoll som holder det sammen. Vil du lage flere spill, viser guiden om å lage ditt eget spill både enkle reaksjonsspill med micro:bit og spill på skjerm. Bygg en elektronisk terning med arcade-knapp til familiekvelden, eller en myntautomat med den samme UNO R4. Er programmering nytt for deg, er Arduino-guiden for nybegynnere et godt sted å starte.

Tallene om reaksjonstid er hentet fra studien til Woods og kolleger i Frontiers in Human Neuroscience. Hicks lov bygger på artiklene til William Hick fra 1952 og Ray Hyman fra 1953, og Stroop-effekten på artikkelen til John Ridley Stroop fra 1935. Pinner og mål er hentet fra produktsidene, fra databladet til UNO R4 WiFi og fra dokumentasjonen til bibliotekene U8g2 og Adafruit NeoPixel. Koden er kompilert for UNO R4 WiFi og UNO R3 og kjørt i en simulering på en datamaskin, men vi har ikke bygd spillet fysisk. Test derfor hvert steg selv, slik kontrollpunktene viser.

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.