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.
- 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
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.
- 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.
- Skjermen teller 3, 2, 1, og en hvit bue på ringen krymper jevnt. Et kort pip følger hvert tall.
- 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.
- Trykk på knappen med samme farge. Ringen blinker grønt, og skjermen viser tiden din og poengene du fikk.
- Slipp knappen. Ringen blir mørk, og en ny pause begynner. Slik fortsetter det i 30 sekunder.
- 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 skjer | Poeng | Skjermen viser | Lyd |
|---|---|---|---|
| Riktig knapp | 1000 minus tiden i ms, minst 100 | Tiden og poengene, for eksempel «438 ms» og «+562» | Kort, lys tone |
| Feil farge | Minus 250 | «FEIL FARGE» | Dyp tone |
| Trykk før ringen lyser | Minus 250 | «TYVSTART!» | Dyp tone og hvitt blink |
| Ingen trykk på 1,5 sekunder | Ingen | «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 treff | Tittel |
|---|---|
| Under 400 ms | Lyn |
| 400 til 499 ms | Gaupe |
| 500 til 599 ms | Rev |
| 600 til 749 ms | Grevling |
| 750 ms eller mer | Skilpadde |
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.
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, 100 mm1 stk, med utskiftbar mikrobryterStor rød trykknapp med 100 mm ytre diameterPå lagerkr 225,00
Stor blå trykknapp med diameter 100 mmPå lagerkr 199,00
Monostabil gul trykknapp med diameter 100 mmPå lagerkr 199,00
LED-ring WS2812B, 16 lysdioder, 68 mm1 stk, viser fargen spilleren skal treffeLED ring WS2812B 5050 RGB 16 dioder 68 mmPå lagerkr 119,00
OLED-skjerm 1,3" 128x64, SH11061 stk, viser nedtelling, tider og resultatBlå OLED-skjerm 1,3" 128x64px med SPI og I2C - Arduino-kompatibelPå lagerkr 259,00
Arduino UNO R4 WiFi1 stk, styrer spillet og tar tidenUtviklingskort Arduino Uno R4 WiFi med 12 x 8 LED-matrisePå lagerkr 599,00
Piezosummer uten generator, 23 mm1 stk, pip, nedtelling og fanfarePiezo-buzzer uten generator, 23 mm, 1-40 V, 85dB, innkapsletPå lagerkr 99,00
Koblingsbrett, 400 hull1 stk, samler 5 V og jord, og blir med inn i konsollenLoddefritt koblingsbrett med 400 hull og 2,54mm rasterPå lagerkr 75,00
Koblingsledninger 20 cm, 120 stk16 hann-hunn og 4 hann-hann brukesKoblingskabler 20 cm - M/M, F/F, M/F - Sett med 120 stk.På lagerkr 169,00
Motstandssett, 16 verdier1 x 470 Ω til ringen og 1 x 100 Ω til summerenMotstandssett med 160 THT-motstander i 16 verdier, 0,25 WPå lagerkr 149,00
Elektrolyttkondensator 100 µF, 10 stk1 stk mellom 5 V og jord ved ringenElektrolyttkondensator 100 µF 35V THT, 10 stk.På lagerkr 29,00
USB-C-kabel med av/på-bryter, 0,9 mValgfri, av/på-bryter for det ferdige spilletUSB-A til USB-C Kabel med Av/På bryter - 0,9 meter - SvartPå lagerkr 95,00
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-pinne | Kobles til | Merknad |
|---|---|---|
| D2 | Rød knapp, NO | COM på knappen går til jord |
| D3 | Blå knapp, NO | COM til jord |
| D4 | Gul knapp, NO | COM til jord |
| D5 | Summeren, rød ledning | Gjennom 100 Ω. Svart ledning til jord |
| D6 | Ringen, DIN | Gjennom 470 Ω |
| D8 | Skjermen, RES | Tilbakestilling |
| D9 | Skjermen, D/C | Data eller kommando |
| D10 | Skjermen, CS | Velger skjermen |
| D11 | Skjermen, DIN | Data (MOSI) |
| D13 | Skjermen, CLK | Klokke (SCK) |
| 5V og GND | Skinnene på koblingsbrettet | Ringen, skjermen og kondensatoren henter strøm herfra |
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.
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.
- Vri bryterholderen under knappen en kvart omdreining og trekk den ut. Da kommer du til bryteren uten å skru opp noe.
- Klipp hunnenden av to ledninger hann-hunn på 20 cm, og avisoler 5 mm på de avklipte endene.
- 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.
- Merk de to ledningene med en bit tape i knappens farge, så vet du senere hvilket par som hører til hvilken knapp.
- 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.
- 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.
- Lodd ledningene på flatene fra baksiden av ringen, så de ikke lager skygge foran lysdiodene.
- 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.
- 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.
- 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.
- VCC til plusskinnen (5 V) og GND til minusskinnen. Skjermen tåler 3,3 til 5 V.
- DIN til D11 og CLK til D13. Det er de faste SPI-pinnene på UNO.
- CS til D10, D/C til D9 og RES til D8.
- 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.
- Sett motstanden på 100 Ω mellom D5 og den røde ledningen på summeren. Den beskytter pinnen når piezoen lades opp og ut.
- 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
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
- Installer Arduino IDE 2 fra arduino.cc. Åpne Boards Manager, søk etter «UNO R4» og installer «Arduino UNO R4 Boards».
- Åpne Library Manager, og installer to biblioteker: «Adafruit NeoPixel» av Adafruit og «U8g2» av oliver (olikraus).
- Koble UNO til datamaskinen med en USB-C-kabel som overfører data. Velg «Arduino UNO R4 WiFi» og porten som dukker opp.
- Lim inn koden under, og trykk på pilen Upload.
- Å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_SPIforteller 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 medfirstPage()ognextPage().INPUT_PULLUPslå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_tfoghelvB14_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
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.
| Tilstand | Ringen | Venter på | Neste |
|---|---|---|---|
| MENY | Regnbue | Et trykk på en knapp | NEDTELLING |
| NEDTELLING | Hvit bue som krymper | Tre sekunder | VENT |
| VENT | Mørk | En tilfeldig pause, og at alle knapper er sluppet | SIGNAL, eller tyvstart |
| SIGNAL | Rød, blå eller gul | Første trykk, høyst 1,5 sekunder | VENT |
| SLUTT | Regnbue | Et nytt trykk, tidligst etter 1,5 sekunder | MENY |
// 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 lesermicros()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 ikkemillis(). 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.
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.

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.
Monter i denne rekkefølgen:
- 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å.
- Lodd ledningene på mikrobryterne og på ringen, som i avsnittet om koblingen, og sett bryterne tilbake i knappene.
- 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.
- Skru holderen fast på de tre stolpene under midten av lokket med tre skruer M3 x 8 med rundt hode.
- Legg summeren mellom de fire ribbene under de sju hullene, med ledningene innover, og skru den printede klemlisten fast over den med to skruer.
- Skru UNO fast på de fire stolpene på bunnplaten med fire skruer, og fest koblingsbrettet mellom merkene ved siden av med tapen på baksiden.
- 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.
- 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 gir spillet tre moduser. Du velger med den første knappen du trykker på i menyen:
| Knapp i menyen | Modus | Hva du gjør |
|---|---|---|
| Rød | Klassisk | Det samme spillet som i nivå 2 |
| Blå | Stroop | Skjermen viser et fargeord. Du trykker på knappen med ringens farge, ikke den ordet sier |
| Gul | Forsøk | 20 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.
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!
- Still et spørsmål. For eksempel: Tar det lengre tid å trykke riktig når ordet og fargen ikke stemmer?
- 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.
- 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.
- 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.
- 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.
- 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.



