Informatik og sundhed

I dette forløb skal det handle om “sundhedswearables”. På 8 moduler (à 100 min.) skal der fremstilles en enhed, der kan hjælpe patienter med genoptræning efter et slagtilfælde, apopleksi, som er betegnelsen for en blødning eller blodprop i hjernen. Helt konkret skal der udvikles og programmeres et træningsprogram, som patienten kan bruge via et “smartur” – en såkaldt M5StickC, og hvor patienten i højere grad, end hvad tilfældet er i dag, kan forestå egen behandling hjemme – og følge udviklingen.

Med udgangspunkt i den iterative metode (introduceres lidt grundigere i 2. modul) udvikler eleverne således et produkt, som kan kobles til komplikationer forbundet med motoriske udfordringer som følge af en blodprop i hjernen. Eleverne vil få en forståelse af, hvordan deres teoretiske viden kan omsættes til virkelige løsninger for andre mennesker.

Skønt forløbet er tænkt afviklet i sin helhed – og med udgangspunkt i moduloversigten, så skal sidstnævnte endelig ikke tænkes så stram og rigid, at man ikke sagtens kunne udelade visse moduler. Alternativt kan man også nøjes med modulerne 1-7, og f.eks. lade disse indgå i et helt andet forløb med særligt fokus på IoT / embedded computing, dvs. undlade at bruge modul 8, som alene omhandler plot i webinterface (HTML og JavaScript) og et afsnit om arkitekturer.

Endelig er der lagt op til, at forløbet kan danne rammen om en projektrapport.

Didaktiske overvejelser

Der er tilstræbt at undgå for meget af en ”bottom-up” tilgang, særligt til tekstprogrammeringen, da dette – som det efterhånden er almindelig anerkendt – alt for ofte resulterer i for snævre faglige kompetencer og ikke mindst giver udfordringer med motivationen for de elever, der ikke nødvendigvis er voldsomt it-interesserede. I stedet er projektets delmål udformet ud fra en “worked examples“-tilgang.

Endelig er det håbet, at forløbet kan vække en interesse og begejstring ved at være så stærkt løsningsorienteret og ved at tage udgangspunkt i teknologier, f.eks. “smarte” armbåndsurer, som eleverne allerede har et vist kendskab til – alt imens der opdyrkes eller -øves computational thinking / datalogisk tænkning.

Faglige mål:

Forløbet kan bruges på såvel C som B-niveau, idet den enkelte lærer kan justere dybden af opgaveløsningens enkelte dele, og går umiddelbart på tværs af fagets 7 kernestofområder. Foruden programmering og interaktionsdesign dækkes således også:

Konstruktion af it-system som løsning til en problemstilling, herunder at behandle problemer i samspil med andre fag, nærmere bestemt biologi, samt at demonstrere viden om fagets identitet og metode
It-systemers og menneskelig aktivitets gensidige påvirkning
Repræsentation og manipulation af data
Innovation

Endelig skal det bemærkes, at flere af modulerne er forsynet med en “lærernote”, der skal tjene til at gøre det helt klart, hvad der er formålet i det pågældende modul – samt komme med forslag til forskellige måder at gribe eventuelle opgaver an på.

1. Modul

En CASE: Slagtilfælde

M5Stick og MU-Editor

I gang med Python

En CASE: Slagtilfælde

M5Stick og MU-Editor

I gang med Python

2. Modul

IMU og bevægelser

Bevægelser i kode: del I

Bevægelser i kode: del II

Iterativ udvikling, krav og brugsmønstre

IMU og bevægelser

Dette modul forudsætter, at du nu har installeret Mu, fået en tilstrækkelig indføring i programmeringssproget Python samt endelig fuldført de indledende opgaver, som skulle få dig godt i gang med at bruge M5Stick’en. Udover hvad du har lært i 1. modul omkring programmeringsstrukturer mv., så vil dette modul hjælpe med at pege dig i retning af funktioner, som du skal implementere i 3. modul.

Find sammen med din makker – eller overvej e.v.t. at finde en anden for variationens skyld – og gå så ellers i gang med at arbejde med urets bevægelsessensor (IMU). Formålet er at se, hvordan man hensigtsmæssigt repræsenterer fysisk bevægelse – og handler på denne – i kode. Hertil kan 3D-modellen i Processing i næste menupunkt understøtte dit/jeres eksperimentelle arbejde. Softwaren kan hentes her, og man kan for at spare tid nøjes med at installere Processing på én computer. Der er i øvrigt god mening i, at I fordeler arbejdet mellem jer, sådan at én person har Mu åben – og en anden Processing.

3D-model af M5Stick

Start med at åbne et nyt vindue i Mu-editor, skriv følgende kode ind – og tryk “Run“:

from lib import imu
import time
import fusion

myIMU = imu.IMU()
filter = fusion.MahonyFilter()

while True:
   filter.update(myIMU.acceleration, myIMU.gyro)
   print(str(filter.roll)+','+str(filter.pitch))
   time.sleep(0.02)

Ovenstående skriver kontinuerligt værdier i konsollen, som illustreret nedenfor:

Du er nu klar til at bruge urets output, og så snart Processing er installeret, så hentes 3D-modellen af uret her. Importér modellen, ret i serielporten – og tryk på “Play”-ikonet. Du vil nu kunne se urets orientering i rummet afspejlet direkte i vinduet.

Nedenunder selve uret vil man desuden kunne aflæse henholdvis roll og pitch – værdier, som du/I så skal forsøge at eksperimentere jer til tærskelværdier ud fra. Hvordan ser værdierne (intervallerne) f.eks. ud, fra man holder armen strakt ud, vinkelret på kroppen – og til man har armen løftet strakt, lige op i forlængelse af kroppen (strakt op i vejret)?

Jeres træningsprogram skal som bekendt bygge på, hvor meget – og hvor hurtigt – patienten faktisk er i stand til at bevæge de pågældende lemmer.

OBS: Som vist nedenfor, så er det nødvendigt at ændre porten til den rigtige for dit system. Hvis du f.eks. bruger Mac, så kan du gå op i Spotlight – søge på Terminal, og inde i det pågældende Terminal-vindue skriver du \(ls\) \(/dev/tty.usb*\) og trykker Enter.

Materialer og litteratur:

Mathiasen, Ken: Informatik C. Praxis, 2017, ss. 193-226
https://informatik.systime.dk/?id=p939

Bevægelser i kode: del I

I det foregående har I arbejdet med uret ud fra en 3D-model, hvilket gjorde jer i stand til rent grafisk at eksperimentere jer frem til nogle intervaller for visse bevægelser. Dette arbejde fortsættes i det følgende, hvor I direkte i koden skal arbejde med M5Stick’ens orientering i rummet pba. urets accelerometer og gyroskop. Urets bevægelsessensor, eller IMU (Inertial Measurement Unit), har 6 frihedsgrader, og betragtet under ét får man således mulighed for at måle:

hvor hurtigt, man roterer (gyroskop)
hvor hurtigt, man accelererer eller bremser (accelerometer)
tyngdekraften fra jorden, og dermed hvilken retning, der er nedad (accelerometer)

Når man skal finde ud af, i hvilken retning uret peger, så skal accelerometer- og gyroskopværdierne omregnes til vinkler (ift. jordens overflade). Dette sker med hjælp fra én ud af adskillige mulige såkaldt sensor fusion-algoritmer. Det nødvendige Fusion-bibliotek kan eleverne hente her – og overføre til uret vha. af M5-guiden. Men inden I kommer så langt, så forsøg – nu med udgangspunkt i selve koden – at eksperimentere med accelerometret alene:

from lib import imu
import time

myIMU = imu.IMU()

while True:
     time.sleep_ms(10)
     print(myIMU.acceleration)

Læg uret helt fladt på bordet. I får i konsollen kontinuerligt printet tre værdier, (x, y, z) – hvad sker der umiddelbart, dvs. hvilke værdier ændrer sig, når I drejer uret om sin egen akse?

Prøv nu at tage uret på med M5-Knappen tættest på håndleddet, og ændr så programmets \(while\)-løkke til følgende:

while True:
    ax, ay, az = myIMU.acceleration
    print(ay)

Ovenstående skriver en del af outputtet fra accelerometret til en variabel, \(ay\), som I så “printer” til konsollen. Hvad sker der med værdien, når I henholdsvis løfter/sænker armen? Notér jer – ligesom i jeres arbejde med 3D-modellen – nogle passende intervaller, og overvej:

… hvorvidt intervallet kan bruges til at evaluere en øvelses korrekte udførelse?
… hvordan man i så fald skulle implementere dette? (Hint: betingelser/forgreninger)

Materialer og litteratur:

https://m5guide.readthedocs.io/en/latest/accelerometer_gyro.html
https://m5guide.readthedocs.io/en/latest/sensorfusion.html
Variable, udtryk og typer: https://imada.sdu.dk/~sjlarsen/teaching/python/slides/1/1.pdf
Forgreninger og løkker: https://imada.sdu.dk/~sjlarsen/teaching/python/slides/1/2.pdf

Bevægelser i kode: del II

I skal nu prøve at udbygge eksemplet fra det foregående.

1) Importér først yderligere to biblioteker (forudsætter at fusion.py ligger på uret):

import fusion
from m5stack import lcd

2) Tilføj dernæst følgende – ét eller andet sted før \(while\)-løkken:

filter = fusion.MahonyFilter()

count = 0
lcd.orient(lcd.LANDSCAPE)
lcd.clear()

I 1) importerer vi de biblioteker, der gør det muligt at bruge IMU’en mere detaljeret (kombinere accelerometer og gyroskop), ligesom vi får mulighed for at skrive til urets display. I 2) sætter vi to variabler, hhv. \(filter\) og \(count\), hvor førstnævnte kommer til at indeholde de aktuelle værdier fra kombinationen af accelerometer og gyroskop, og sidstnævnte variabel sættes til 0, men vil senere i løkken blive talt op med én. Endelig “nulstiller” vi urets display.

Vi har kun tilbage at udvide \(while\)-løkken en smule – dels med vores \(filter\)-variabel, dels med en forgrening/betingelse, som hele tiden tjekker for, hvorvidt variablen \(count\) er lig med 20. I fald den er, så nulstilles den – og gennemløbet starter forfra:

while True:
    filter.update(myIMU.acceleration, myIMU.gyro)

    if count == 20:
        lcd.print(filter.pitch, 20, 10)
        lcd.print(filter.roll, 20, 30)
        count = 0
    count += 1

Prøv nu i egne ord at gøre rede for, hvad der har ændret sig i outputtet? Hvordan er de data, I får, forskellige, fra øvelsen uden brug af fusion-filtret, dvs. med accelerometret alene – kunne man bruge dem direkte? Modificér og udvid ovenstående kode, så urets display f.eks. skifter farve, så snart man vender uret på hovedet.

Som koden er på nuværende tidspunkt, så får man blot outputtet printet direkte i konsollen – eller i urets display. Man kan i stedet gemme disse lokalt på uret – i eksemplet nedenfor under filnavnet “data.csv”. De kan så efterfølgende flyttes over på din egen computer til videre behandling.

from lib import imu
import time
import fusion

myIMU = imu.IMU()
filter = fusion.MahonyFilter()

f = open('data.csv', 'w')
data = ''
t = 0

for count in range(200):
    filter.update(myIMU.acceleration, myIMU.gyro)
    data += str(filter.roll)+',\n'
    t +=20

    print('('+str(filter.roll)+','+str(filter.pitch)+')')
    time.sleep(0.02)

f.write(data)
f.close

Materialer og litteratur:

https://m5guide.readthedocs.io/en/latest/accelerometer_gyro.html
https://m5guide.readthedocs.io/en/latest/sensorfusion.html

Iterativ udvikling, krav og brugsmønstre

3. Modul

Blodpropper og fysioterapi

Implementering: funktioner

Blodpropper og fysioterapi

Implementering: funktioner

Når du efterhånden har sporet dig ind på nogle tærskeværdier for én eller flere af patientens fysioterapeutiske øvelser, og med viden fra foregående afsnit om vanskelighederne forbundet med motorisk indlæring og behovet for at træne finmotorikken og hastigheden i udførelsen af selv helt basale, fysiske opgaver, så er det tid til at omsætte disse til noget kode, som ikke bare registrerer bevægelserne, men sætter jer i stand til at handle på bestemte værdier, eller intervaller, og give patienten passende feedback. Inden vi gør dette, så kræves imidlertid en kort introduktion til funktioner i Python.

I deres umiddelbare form afviger funktioner i programmering ikke meget fra funktioner, som de kendes fra matematikundervisningen. Hvis man tager \(f(x)=2x+3\) som eksempel, så vil funktionen have et navn, her \(f\), og den siges at “tage” en værdi \(x\), som den så behandler inde i forskriften \(2x+3\). Hvis vi således putter tallet 2 ind i funktionen, så der står altså \(f(2)\), og forskriften fra før bliver da til \(2*2+3\), dvs. variablen \(x\) får simpelthen værdien 2 inde i selve funktionsforskriften.

En funktion har altså et bestemt navn og tager én eller flere såkaldte argumenter (svarende til værdi fra før), sommetider også kaldt parametre, som den så behandler videre inde i selve funktionen. Du har i øvrigt allerede brugt flere funktioner, bl.a. \(lcd.print(…)\) og \(sleep(…)\). En funktion kan således opfattes som en blok kode, der kun eksekveres, når man “kalder”, dvs. bruger, funktionen. De erklæres i Python ved brug af \(def\):

def vis_navn(fornavn):
  print(fornavn + " Turing")

vis_navn("Alan")

Overvej nu, hvad ovenstående funktion gør, og prøv dernæst funktionen med noget andet end “Alan” – hvad sker der? Hvordan kunne man i øvrigt udbygge funktionen, sådan at den kommer med en fejlmeddelelse, hvis ikke argumentet fornavn er lig med “Alan”?

Hvis I nu vender jer mod jeres egne eksperimenter med intervaller for grænseværdier, og lad os sige, at I har fundet følgende for armløft, hhv. pitch = [30, -70] og roll = [-60, -80]. Disse kan vi nu omsætte, eller måske rettere oversætte, i overensstemmelse med det, vi lærte om i 1. modul, nemlig nogle variabler og en forgrening. Med udgangspunkt i eksemplet fra forrige modul (“Bevægelse i kode: del II“), så kunne en funktion se ud som følger:

def armloeft():

    pitch_min = 30
    pitch_max = -70
  
    if (filter.pitch > pitch_max) and (filter.pitch < pitch.min):
        print("Inden for tærskelværdierne.")
    else:
        print("Uden for tærskelværdierne.")

Og funktionen kan vi nu tage i brug ved at “kalde” den – f.eks. i en løkke som nedenfor. Husk at importere relevante biblioteker samt instantiere IMU’en (se “Bevægelse i kode: del II“). Prøv jeres kode af, og se, hvor følsom den er, og om der skal justeres på noget (outputtet skrives i konsollen i Mu-editor):

while True:
    armloeft()

4. Modul

Bevægelse i kode: del III

Brugerfeedback og -grænseflade

Bevægelse i kode: del III

Det er nu tid til at kigge på de standardiserede genoptræningsøvelser, som fysioterapeuten forestår sammen med patienten. Nedenfor er et lille, repræsentativt udpluk, og det forventes ikke nødvendigvis, at man når igennem dem alle. Til gengæld skulle de gerne så småt bevidstgøre om, hvordan der dybest set er tale om samme kodemæssige grundstruktur for mange af øvelserne i genoptræningen (mere herom ifm. “Modellering” i næste modul).

Som det fremgår af det biologifaglige vedrørende blodproppernes påvirkning af hjernen, så resulterer skaderne typisk i fragmenterede, rykvise bevægelser, og det er således øvelsernes formål at genoptræne til mere flydende, hurtigere bevægelser.

Som figurerne ovenfor viser, så vil øvelserne typisk involverer træning i løft af armene: her først i en stilling, hvor man sidder ned og har albuerne helt tæt, parallelt til kroppen, og man løfter så sine underarme, så langt man nu kan. I den anden øvelse står man oprejst og foretager så en slags “fingergang” op ad væggen, nogenlunde fra samme højde som hoften – og så ellers så højt, som det er muligt.

Ovenstående 4 træningsøvelser bruges til at opøve og genvinde tabt styrke eller behændighed/fingerfærdighed i fingre og hænder. Prøv at udføre ovenstående, idet du – eller din makker – har EMG-sensoren på. Hvilke værdier kan i læse, dvs. hvor følsom er sensoren? Kan man skelne øvelserne fra hinanden ud fra sensoraflæsning alene?

Og endelig:

I øvelserne ovenfor trænes, hvad man kalder “indadrotation” samt “abduktion” og “adduktion” i skulderled, og som bidrager til skuldrenes styrke og stabilitet. Som ved de øvrige øvelser, så skal I gå eksperimentelt til værks – og brug så funktionen \(armloeft(…)\) i det foregående (“Implementering: funktioner“) som skabelon for en specifik træningsøvelse.

Nedenstående er en lidt mere avanceret funktion (bruger dog kun accelerometret), som kan tjene til at inspirere ift. brugerfeedback: foruden at display’et lyser grønt, så der bippes der også en enkelt gang, når man løfter eller sænker armen for hurtigt:

from m5stack import lcd
from flowlib import hat
from lib import imu
import time

myIMU = imu.IMU()
hat_spk0 = hat.get(hat.SPEAKER)

def bipBevaeg(tid, delay, tone):

    ay_prev = 0
    t = 0

    lcd.clear()
    lcd.print('Klar til bip.', 20, 30)


    while t < tid:
        ax, ay, az = myIMU.acceleration

        if ay > ay_prev:
            hat_spk0.sing(tone, 0.3)
            lcd.clear(0xFFAA00)

        ay_prev = ay+delay
        lcd.clear()

        time.sleep(0.3)
        t+=5

    lcd.clear()
    lcd.print('Faerdig.', 20, 30)

Husk at eksekvere funktionen, f.eks. inden i en løkke – og justér på funktionens parametre, \(tone\) og \(delay\). Prøv med \(bipBevaeg(200, 0.025, 1500)\). Hvordan ville man i øvrigt gøre, hvis nu tonen skulle stige afhængigt af, hvor hurtigt man løfter armen (frem for i intervaller à \(delay=0.025\))? Kunne det måske være en idé at have en tone, som angav den stigning i hastighed, man som patient skal forsøge at efterstræbe, i stedet for det enkelte (0.3) bip i den faste tone (\(tone=1500\)).

Materialer og litteratur:

Region Midtjylland: Standardiseret fysioterapeutisk genoptræningsintervention
https://informatik.systime.dk/index.php?id=1083

Brugerfeedback og -grænseflade

Indtil nu har fokus været på funktionaliteten i selve løsningen, dvs. at få omsat de konkrete, fysioterapeutiske øvelser til bidder af kode, som der kan handles på – hvad enten dette var at give patienten feedback eller gemme resultaterne på uret til videre behandling. I det følgende skal det handle om selve brugergrænsefladen (UI), altså selve bindeleddet mellem bruger og system, og hvordan man udvikler et ordentligt og hensigtsmæssigt interaktionsdesign (IxD) – særligt i betragtning af urets beskedne, fysiske dimensioner – og bare to knapper.

For at komme hurtigt i gang med at arbejde med et menusystem, så anbefales det at tage udgangspunkt i “M5StickMenu”-biblioteket, der er udviklet særligt til formålet. Følg linket, og klik dernæst på den grønne knap (“Code“) på websitet – og vælg “Download Zip“:

Filen menu.py overføres nu til uret (brug e.v.t. M5Guiden). Nedenfor ses et eksempel på, hvad der som minimum kræves for at komme i gang, hvor kommentarerne gerne skulle tydeliggøre de enkelte trin:

# Initialiser menuen
test_menu = M5StickMenu()
	    
# Definer punkter
punkt1 = MenuElement("1. Haender", tryk, [1])
punkt2 = MenuElement("2. Ben", tryk, [2])
punkt3 = MenuElement("3. Fingre", tryk, [3])
	    
# Føj punkterne til menuen
test_menu.add_element(punkt1)
test_menu.add_element(punkt2)
test_menu.add_element(punkt3)
	    
test_menu.start()

Grafisk kan processen også illustreres som nedenfor:

Ovenstående kan passende placeres i \(main()\). Det er vigtigt at pointere, at \(MenuElement()\) i udgangspunktet tager tre parametre, nemlig 1) en titel, 2) en brugerdefineret funktion og 3) parametre til den brugerdefinerede funktion. I dette eksempel har vi funktionen \(tryk()\), som kunne se ud som nedenfor, hvor nummeret på det pågældende menupunkt blot skrives ud i MU-editors konsol:

# Brugerdefinerede funktioner
def tryk(nummer):
    print('Du valgte ' + str(nummer))

Tilbage er at hægte menusystemet op på M5Stick’ens to fysiske knapper, hvilket man kan gøre med en løkke, hvor to forgreninger/betingelser “lytter” efter tryk:

while True:
    if btnA.wasPressed():
	    test_menu = test_menu.down()
    if btnB.wasPressed():
	    test_menu = test_menu.enter()

    time.sleep(0.01)

Funktionen, som blev vist i det foregående afsnit (“Brugerfeedback og -grænseflade“) kunne i øvrigt implementeres med følgende:

punkt = MenuElement("1. Ben m. bip", bipBevaeg, [200, 0.025, 1500])
test_menu.add_element(punkt)

Materialer og litteratur:

Mathiasen, Ken: Informatik C. Praxis 2017, ss. 180-2.
https://informatik.systime.dk/?id=p939

5. Modul

Interaktionsdesign: del I

Tilpas menuen

Modellering

Interaktionsdesign: del I

Tilpas menuen

Modellering

6. Modul

Interaktionsdesign: del II

Indarbejd ændringer

Dokumentation

Interaktionsdesign: del II

Indarbejd ændringer

Dokumentation

7. Modul

Evaluering af løsning

Innovationsvurdering

Evaluering af løsning

Innovationsvurdering

8. Modul

Plot data i webinterface

Arkitekturer

Plot data i webinterface

Datastruktur og repræsentation

Data i sig selv, hvad enten det er kostregistreringer, sportsresultater eller løbende logning af en given patients behandlingsforløb, er ikke meget bevendte, medmindre de gives en struktur, som gør det nemt og effektivt at arbejde med dem. Dertil kommer den måde, hvorpå selve strukturen repræsenteres. Bl.a. JSON (JavaScript Object Notation) er en måde at repræsentere struktureret data på og er utrolig udbredt i webapplikationer og IoT-enheder. En anden udbredt struktur er CSV (eng. “Comma-separated values“), som der er blevet brugt i modul 2, hvor værdier adskilles af f.eks. komma – og hvor én linje f.eks. repræsenterer ét koordinatsæt.

Man har indtil flere muligheder for at få visualiseret sine data, når man eksporterer disse i CSV-format. Udover ganske enkelt at importere dem i Excel, så kunne man også lave et simpelt webinterface, der gør det endnu nemmere for brugeren. Tag udgangspunkt i skabelonen nederst på siden under “Resources“. Denne kunne nu udbygges med muligheden for at uploade *.csv-filer – illustreret ovenfor.

Du får i din HTML som minimum brug for et \(file\)-element og en enkelt \(button\):

<input type="file">
<button id="minKnap">Visualisér data</button>

.. og så kan følgende JavaScript uden videre bruges:

document.getElementById("minKnap").addEventListener("click", function() {

  var file = document.querySelector('input').files[0];
  graphContents(file)

});

Ovenstående gør, at brugeren nu kan uploade sine data i CSV-format til webinterfacet, som så tegner grafen. Men hvad nu, hvis man i stedet ønsker at kunne overføre flere filer ad gangen (yderligere inspiration kan hentes her)? Og at de hver især endda genererer deres egen graf, så patienten bedre kan følge sin udvikling over tid? Det er opgaven nu, og vi er umiddelbart interesseret i følgende fra filen “graph.js”:

data: {
  labels: [],
  datasets: [{
    label: '...',
    fill: false,
    backgroundColor: ...,
    borderColor: ...,
    data: [],
  },
    ...
  ]
}

Hvert nyt dataset, forstået som hver ny “logning” eller *.csv-fil, skal ind i array’et \(datasets[…]\) – og i krøllede parenteser { … }. Dette kan man opnå programmatisk med følgende funktion. Kig den grundigt igennem med din sidemakker og prøv med egne ord at forklare, hvad der sker:

function graphContents(file) {

    let reader = new FileReader()
    reader.readAsText(file)
    reader.onloadend = function() {
        lastModified = new Date(file.lastModified);

        var colorName = colorNames[num]
        var newColor = window.chartColors[colorName];

        var newDataset = {
            label: 'Dataset',
            backgroundColor: newColor,
            borderColor: newColor,
            data: [],
            fill: false
        }

        data = this.result.split('\n');
        newDataset.label = lastModified;
        data.forEach((item, i) => {
            item_splitted = item.split(',');
            config.data.labels.push(item_splitted[0]);
            newDataset.data.push(item_splitted[1]);
        });

        config.data.datasets.push(newDataset);
        window.myLine.update();

        num += 1
    }
}

Som løsningen er skruet sammen på nuværende tidspunkt, så dannes y-aksen ud fra første “kolonne” af værdier i *.csv-filen – og x-aksen dannes ud fra anden kolonne. I det pågældende program på M5Stick’en forudsættes det således, at f.eks. pitch-værdien logges for hvert sekund (i ét eller andet antal sekunder). Sæt dig sammen med din makker og overvej, hvorvidt dette er hensigtsmæssigt? Ændr så i koden i overenstemmelse med jeres egen idé.

En anden problematik er endelig, at koden på nuværende tidspunkt kun kan håndtere 4 tekstfiler ad gangen – hvad sker der, hvis man tilføjer flere? Overvej med din sidemakker, hvordan man hensigtsmæssigt kunne kommunikere dette til brugeren. HINT: brug JavaScripts \(len\) til at tjekke antallet af elementer i array’et \(files\) (se funktionen \(handleFiles(files)\) i filen “drop.js” – og brug så \(alert()\) til at meddele brugeren noget meningsfuldt.

Materialer og litteratur:

https://www.chartjs.org/
https://informatik.systime.dk/?id=950

Ressourcer

drop(html)

Arkitekturer

Didaktiske overvejelser

1. Modul

Genoptræning

Wearable-teknologi har potentiale

Materialer og litteratur:

Materialer og litteratur:

2. Modul

3D-model af M5Stick

Materialer og litteratur:

Materialer og litteratur:

Materialer og litteratur:

Kravspecifikation – og brugsmønstre (“use cases“)

Materialer og litteratur:

3. Modul

Blodprop i hjernen

Lillehjernen

Genoptræning

Genoptræningsprogram

4. Modul

Materialer og litteratur:

Materialer og litteratur:

5. Modul

Materialer og litteratur:

Materialer og litteratur:

6. Modul

Generelle overvejelser ved små displays:

Materialer og litteratur:

Materialer og litteratur:

7. Modul

Materialer og litteratur:

8. Modul

Datastruktur og repræsentation

Materialer og litteratur:

Materialer og litteratur:

By Morten Aagaard Schultz

Andre forløb af samme forfatter