Detta projekt är ett exempel på hur man kan visa sensordata i realtid som en graf, och även hur det kan bli mer stabilt med genomsnittliga värden.  Projektet är lite mer avancerat, mer resultatet är värt det.

Ladda ner Arduino IDE

För ett enkelt sätt att rita grafer ska vi använda Arduino mjukvaran. Följ denna länk för att ladda ner den. Scroll ner till ”Download the Arduino IDE” och välj ditt operativsystem. Sen frågas om en donation, men det finns också en möjlighet att klicka på det gråa ”Just Download” om du inte vill donera. Installera mjukvaran när nerladdningen är färdigt.

Första graf

Nu ska vi rita en graf på datorn med live data som kommer från micro:bit. Det gör vi genom att få micro:bit och datorn att prata med varandra via usb sladden. Det sättet att prata (så kallade protokoll) heter Seriell (Serial på engelska). I vårt fall använder vi det bara i en riktning, micro:bit pratar mot datorn. Dom block eller kodbitar vi använder finns i kategorin Seriell, som man hittar efter att först ha öppnad Avancerad.

Koden börjar med en slumpmässig animering för att enkelt se när programmet är igång. Sen skriver vi ut vår data, vilket i detta exempel är accelerationskraften i x-riktningen. Du kan välja att testa med andra sensordata också. Våra värden ska skrivas ut på nya rader, så vi lägger till en ”ny rad tecken” efter värdet. Allt detta upprepas för alltid.

basic.forever(() => {
 // liten animering så att vi vet att programmet körs
 led.toggle(Math.random(5), Math.random(5))
 // skriva ut värden
 // över serial (via usb sladden till din dator)
 serial.writeNumber(input.acceleration(Dimension.X))
 // lägg till en "ny rad tecken" för att avsluta raden
 serial.writeLine("")
})

Länk till koden.

Nu när vi skriver ett värde på detta sätt över seriella porten dyker det upp en knapp under micro:bit simulatorn där vi kan se en graf av datan som kommer från simulatorn. Tryck på ”Show data simulator”-knappen och rör din mus över micro:bit.

Nu ska vi se om vi kan visa riktigt data från en riktig micro:bit! Ladda ner koden till din micro:bit. Öppna Arduino mjukvaran som du har installerat. I menyn ”Tools” gå till ”Port” och välj den ”COM..” som finns där. Oftast visas det bara en där.

Nu I samma ”Tools” meny kan vi öppna ”Serial Monitor” för att se värdena som skriven text. Se till att selektera ”115200 baud” i nedre höger hörna. Detta handlar om med vilken hastighet micro.bit och datorn pratar och lyssnar. Du borde se något sånt här. (Skaka din micro:bit)

Stäng Serial Monitor igen. I samma meny ”Tools” välj nu ”Serial Plotter. Här ska baud inställningen också vara 115200. Om allt går bra ska du se en blå graf som ritas upp. Rör på din micro:bit för att ändra datan som ritas.

Jämnare data

Nu kan vi bygga vidare på vår kod. Nästa steg är att få grafen att röra sig lite mjukare. Det kan vi få till genom att räkna ut genomsnittet på de senaste värden, och visa det som en graf.

Först skapar vi en lista (array) som vi kallar för list. Den ska innehålla de senaste värden som vi vill räkna ut genomsnittet på. Varje gång ”för alltid”-loopen körs lägger vi in ett ny värde och slänger den som är äldst. I början innehåller list bara nollor, men dom ersätts på detta sätt av riktig data. Hur många nollor vi skapar listan med bestämmer hur många senaste värden vi använder för att räkna ut genomsnittet på. I detta fall är det tio stycken, men experimentera själv med att ändra det och se hur det påverkas grafen.

Loopen börjar med samma slumpmässiga animering för att visa att programmet är igång (och för att det är lite kul). Sen sparar vi ett nytt värde i listan, på plats 0, vilket betyder att den kommer längst fram innan alla värden som redan finns. Nästa steg är att ta bort det värdet som ligger sist, eftersom det är den som är äldst. Här använder vi längden på listan minskat med ett, vilket kanske känns konstigt. Men när vi pratar om värden som finns i en lista används deras så kallade index, vilket är en numrering som börjar med 0 på det första, 1 på det andra, osv tills längden-1 på den sista. I vårt fall är det 10-1 = index 9.

Efter detta ska vi räkna ut vad genomsnittet är på dom tio värden som vi har just nu. Detta ska sparas i en variabel som heter average, så vi börjar med att sätta den till 0. Sen används en for-loop för att gå genom alla värden med hjälp av deras index. Index börjar på 0, och slutar i den sista loop genomgång med 9 (eftersom det är det sista som är < list.length). Efter att alla värden är räknat ihop ska det delas med hur många värden som finns (list.length) för att få genomsnittet. Sen skriver vi ut båda det vanliga accelerationsvärdet och det genomsnittet vi just beräknade, med en komma och mellanslag emellan. Detta gör att vi kan få två grafer samtidigt, och se skillnaden. (Micro:bit editorn kan inte visa två grafer, så det går inte att testa detta med simulatorn.)

let average = 0
let list: number[] = []
list = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
basic.forever(() => {
    // liten animering så att vi vet att programmet körs
    led.toggle(Math.random(5), Math.random(5))
    // lägg till nytt värde innan alla värden i listan
    // (längden på listan ökar med 1)
    list.insertAt(0, input.acceleration(Dimension.X))
    // ta bort sista värdet på listan
    // (längden på listan minskar med 1)
    list.removeAt(list.length-1)
    // räkna ihop alla värden i listan
    average = 0
    for (let index = 0; index < list.length; index++) {
        average += list.get(index)
    }
    // dela med längden på listan för att få genomsnitt
    average = average / list.length
    // skriva ut båda den vanliga och den genomsnittliga värden
    // på en rad, över serial (via usb sladden till din dator)
    serial.writeNumber(input.acceleration(Dimension.X))
    // med en komma och mellanslag imellan
    serial.writeString(", ")
    serial.writeNumber(average)
    // lägg till en "ny rad tecken" för att avsluta raden
    serial.writeLine("")
})

Länk till koden.

Ladda ner koden till din micro:bit, och öppna Serial plotter på nytt. Då ska det se ut någonting som det här. Blåa grafen är vanliga datan, röda grafen är genomsnittet. Det visas tydligt att den röda grafen är mer jämn, och har en liten fördröjning innan den reagerar. Vilken som är bättre beror på vad datan ska användas till.