Gruppemedlemmer: Bjarke Pedersen – bjped12@student.sdu.dk

Introduktion

BBC frigav i 2015 deres egen udviklede mikrocontroller micro:bit, designet med henblik på anvendelse i grundskolen [1]. BBCs micro:bit – på dansk, ultra:bit – er af Danmarks Radio (DR) siden sommeren 2018 blevet udrullet i stor stil i landets grundskoler. Her har alle elever der i sommeren 2018 startede i 4. klasse, fået udleveret en ultra:bit der er tiltænkt af følge dem to år frem, vel og mærke med det forbehold at deres respektive skole har skrevet sig op hertil [2], [3].

micro:bit understøttes officielt af to programmeringssprog, det ene og hvad der samtidigt formodes værende det mest anvendte er Microsofts MakeCode [4], hvilket er et visuelt blog programmeringssprog, der bygger på traditionerne fra Scratch [5]. Det andet er Python Software Fundations Micro Python, hvilket er et tekstbaseret programmeringssprog [6]. 

For at give lærerne i de danske grundskoler bedre mulighed for at anvende micro:bitten som værktøj til matematik, fysik, kemi mm. blev der på SDU i årene 2018/2019 udviklet en datalogger hertil, hvilken blev understøttet af Windows såvel som macOS. Dataloggeren gav lærerne mulighed for gennem seriel kommunikation over usb, at opsamle og logge data fra micro:bitten, med henblik på senere analysering heraf.

Grundet at førnævnte program var baseret på serien kommunikation over usb, var muligheden for logning af live data begrænset af at enhederne skulle være fysisk forbundet.

Oprindelig Datalogger: micro:bit (serial)

Med udgangspunkt i denne begrænsning, vil det derfor være en fordel hvis datalogningen kunne foregå over trådløst gennem micro:bittens indbyggede Bluetooth modul. I den forbindelse har BBC selv udviklet en relativt omfattende app “micro:bit” [7] til monitorering af en forbunden micro:bits interne sensorer, LEDs og pins, samt kontrol over dennes LEDs og pins, samt knapper. Desværre er appen ikke udstyret med muligheden for logning af den opsamlede data.

BBC: micro:bit

Bitty Software har i mellemtiden udviklet en datalogger app til micro:bit, der netop kører over Bluetooth. Desværre er appen “Bitty Data Logger” [8] i skrivende stund, relativt begrænset i dets funktionalitet og inkluderer kun muligheden for at monitorere og opsamle temperatur, accelerometer og magnetometer data fra de interne sensorer, samt eksterne enheder tilsluttet dennes pins, foruden graf monitorering af selvsamme. 

Bitty Software: Bitty Data Logger

Det ville derfor være ideelt, hvis der blev udviklet en app der forenede BBC’s ganske glimrende visualisering og omfattende monitorering, med Bitty Data Loggers mulighed for datalogning. Grundet projektets natur, vil det ikke være muligt at lave en komplet app der forener BBC’s visualisering og omfang med Bitty Data Logger mulighed for datalogning. 

Dette leder derfor til følgende problemformulering: Kan der udvikles en prototype på monitorering af én micro:bittens interne sensorer over Bluetooth, samt muligheden for datalogning af denne, med henblik på danne fundamentet for senere videreudvikling?

Metoder and Materialer

I dette afsnit vil de i projektet anvendte metoder og materialer blive beskrevet.

2.1 Metoder

2.1.1 Brainstorm

Brainstorm blev anvendt som metode til den indledende idegenerering.

2.1.2 Konceptuelt Design

Der blev genereret et konceptuelt design på skitseniveau, til at danne et overblik over det visuelle design, strukturen i appen, brugerens interaktionsmuligheder hermed, samt bagvedliggende processer.

2.1.3 Krav

På baggrund af det konceptuelle design, blev der udfærdiget en liste over nødvendige krav og vigtige krav.

2.1.4 Arkitektur

Som arkitektur for appen blev følgende Model-View-Controller arkitektur [9] anvendt.

Den anvendte Model-View-Controller arkitektur

2.1.4.1 diagrammer

For at holde styr på brugerinteraktionen og de bagvedliggende processer, blev der lavet et Use Case Diagram, mens der for at holde styr på klassernes indbyrdes relationer, properties og metoder blev oprettet et Class Diagram.

2.1.5 Implementering

Implementeringen blev foretaget i XCode 10.3, med deployment target sat til 12.4. Nedenfor ses de anvendte frameworks, samt det anvendte bibliotek.

2.1.5.1 Frameworks

Core Bluetooth [10]: Frameworket blev anvendt til at stå for Bluetooth forbindelsen mellem enheden og micro:bitten.

Core Data [11]: Frameworket blev anvendt til at gemme datalogs, så de senere kunne findes frem igen.

MessageUI [12]: Frameworket blev anvendt til at sende en given datalog til brugerens email.

2.1.5.2 Biblioteker

Charts 3.0 [13]: Biblioteket blev anvendt til visualiseringen af den kommunikerede sensor data fra micro:bitten

2.1.6 Prototyping

For hvert delelement tiltænkt at indgå i appen, har der været oprettet en isoleret prototype for at sikre funktionaliteten af det specifikke element.

Derudover har der løbende været foretaget intern prototyping af den samlede app, som i takt med at den iterative process udvikling skred frem.

2.1.7 Evaluering

Den endelige evaluering blev foretaget på baggrund af en brugerbaseret usability-evaluering.

2.2 Materialer:

2.2.1 Mac

Den anvendte Mac var af typen (Mac mini – late 2012) med software version 10.14.6.

2.2.1 iPad

Den anvendte iPad var af typen (iPad – 6th generation) med software version 12.4.1.

2.2.1 micro:bit

Den anvendte micro:bit var opdateret til firmware version 0253.

3 Resultater

I dette afsnit vil resultaterne af de anvendte metoder samt implementeringen af appen blive beskrevet.

3.1 Brainstorm

Den indledende brainstorm tog sit udgangspunkt i micro:bitten, samt de problemer der er involveret ifm. datalogning fra denne. Efter en kortere afsøgning af eksisterende produkter – som beskrevet i introduktionen – blev det besluttet at der skulle udvikles en ny datalogger der kunne logge data fra micro:bitten over Bluetooth.

3.2 Konceptuelt design

Det konceptuelle design tog sit udgangspunkt i en Bluetooth datalogger til micro:bit. Grundet projektet begrænsede omfang, blev der ikke udviklet et komplet konceptuelt design for en komplet datalogger app, men derimod for et proof of concept. Resultatet blev derfor et design bestående af tre views, hvilke der kunne veksles mellem gennem en implementeret tab bar. I de efterfølgende afsnit, ses en gennemgang af de individuelle views.

3.2.1 Connect

Connect viewet skal stå for interaktionen og håndteringen vedrørende oprettelsen af en Bluetooth forbindelse til en micro:bit enhed, samt indsamlingen af data.

Brugeren skal kunne søge efter enheder, oprette forbindelse til fundne enheder, afbryde forbindelsen til en forbundet enhed.

3.2.2 Monitor

Monitor viewet skal stå at håndtere visualiseringen den indsamlede data.

Brugeren skal kunne gemme den indsamlede data, som en ny datalog såfremt dette ønskes.

3.2.3 Datalogs

Datalogs viewet skal stå for interaktionen og håndteringen vedrørende at hente tidligere gemte datalogs, visualisere deres indhold, samt sletningen og eksporteringen af eksisterende logs.

Brugeren skal kunne vælge en specifik datalog og få dens data visualiseret, slette eller eksportere den i .csv format.

3.2.4 Skitse

Reproduktion af den oprindelige skitse for det konceptuelle design (i miniformat)

3.3 Krav

Med udgangspunkt i det konceptuelle design, blev der udfærdiget en række krav til appen, hvilke kan ses nedenfor. Kravene er opdelt i strengt obligatoriske krav som udgør hjørnestene i projektet og foruden hvilke dette ikke lader sig gøre, samt i vigtige krav der sikrer en flydende bruger interaktion og ikke-vigtige krav der hovedsageligt relaterer sig til den visuelle repræsentation af appen.

3.3.1 Obligatoriske krav

Tab bar:

  • OK1: Der skal være tre views, hvilke der frit kan veksles imellem, gennem interaktionen med en tab bar.

Connect:

  • OK2: Der skal kunne oprettes en Bluetooth forbindelse mellem den anvendte iPad og den anvendte micro:bit.
  • OK3: Gennem Bluetooth forbindelsen, skal der kunne aflæses værdien af mindst én intern sensor på micro:bitten.

Monitor:

  • OK4: Brugeren skal kunne se den senest aflæste værdi i viewet.
  • OK5: Brugeren skal kunne gemme de aflæste værdier i en datalog, så de overlever efter at appen lukkes.

Review:

  • OK6: Brugeren skal kunne se tidligere gemte datalogs.
  • OK7: Brugerne skal kunne se værdierne i en tidligere gemt datalog.
  • OK8: Brugeren skal kunne eksportere en gemt datalog i .csv format.

3.3.2 Vigtige krav

Connect:

  • VK1: Brugeren skal kunne søge efter tilgængelige Bluetooth enheder.
  • VK2: Brugerne skal kunne se og vælge mellem fundne Bluetooth enheder.
  • VK3: Brugeren skal kunne afbryde Bluetooth forbindelsen mellem den anvendte iPad og den anvendte micro:bit.

Monitor:

  • VK4: Brugeren skal kunne se de aflæste værdier i viewet, visualiseret på en hensigtsmæssig måde – gerne som en graf.
  • VK5: Brugeren skal kunne gemme de aflæste værdier i en datalog, så de overlever efter at appen lukkes.

Review:

  • VK6: Brugeren skal kunne slette tidligere gemte datalogs.

3.4 Implementering

Det konceptuelle design blev implementeret, gennem den tiltænkte Model-View-Controller arkitektur og de obligatoriske krav, såvel som de vigtige krav blev alle implementeret. 

Connect:
Brugeren kan søge efter og få vist en liste over tilgængelige Bluetooth enheder, samt oprette og afbryde forbindelsen til disse. Ved oprettelsen af en forbindelse, vil værdierne for micro:bittens interne temperatur, dets accelerometers x-, y-, og z-akse, samt de indbyggede knappers state, løbende blive opfanget. Dette vil ske hver gang micro:bitten (såfremt disse er aktiveret i dennes kode) udsender en notification vedr. disses værdier. For temperaturen og accelerometeret vil disse blive udsendt periodisk, men de for knappernes vedkommende vil blive udsendt hver gang der sker en ændring i deres nuværende state. Værdierne gemmes løbende, sammen med et tidsstempel (målt i millisekunder siden 1970) der identificerer præcist hvornår de enkelte værdier blev gemt.

Monitor:
Forudsat at der er oprettet forbindelse til en micro:bit samt at de respektive sensorer er aktiveret på denne, kan brugeren kan se en visualiseringen af de aflæste temperatur værdier som et linjediagram (y-aksen udgøres af temperaturen, mens x-aksen udgøres af den tid temperaturen blev registreret på, samt aflæse de nyeste værdier for accelerometerets x-, y- og z-akse og knappernes nuværende tilstande. Derudover kan brugeren tildele den nuværende datalog et navn, samt gemme denne.

Datalogs:
Brugeren kan se en liste over tidligere gemte datalogs og få visualiseret disses temperatur data på samme måde som i monitor viewet. Derudover kan brugeren slette eksisterende datalogs, samt eksportere dem til en .csv fil, der herefter sendes fra den anvendte enheds registrere mailkonto, til en ønsket mailadresse. Tidsstemplerne er eksporteret i dataformatet yyyy-MM-dd HH:mm:ss:SSSS, hvilket understøttes af Google Sheet, hvorfor brugeren kan vælge kun at se de for denne relevante dato informationer

Nedenfor ses en video der demonstrerer implementeringen, såvel som et link til bitBucket hvor den samlede kode findes, samt billeder af selve implementeringen som den tager sig ud på den anvendte iPad..

Den komplette kildekode kan ses her: bitBucket

Connect

Monitor


Datalogs


Eksporter en Datalog


Eksporteret Datalog

I de efterfølgende afsnit vil udvalgte dele af implementeringen blive beskrevet.

3.4.1 Connect

Core Bluetooth blev anvendt som framework til at implementere håndteringen af forbindelsen mellem den anvendte iPad og den anvendte micro:bit. I den forbindelse blev der taget udgangspunkt i følgende: Raywenderlich – Core Bluetooth

CBCentralManager objektet står for at håndtere søgningen efter enheder, forbindelsen hertil, samt afbrydelsen.

CBPeripheral objektet er den enhed der er oprettet forbindelse til, objektet står for at identificere de tilgængelige services, læse og skrive til deres characteristics, samt håndteringen af notifikationer herfra.

Følgende funktioner spillede i den forbindelse en central rolle:

func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
    if(peripheral.name != nil) {
        foundPeripherals.append(peripheral)
        updateTableView()
    }
}

func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
    Helper.showToast(controller: self, message: "Connected with \(peripheral.name ?? "Unknown Peripheral")", seconds: 1)
    DataPoints.sharedManager.clearDataPoints()
    peripheral.discoverServices(nil)
}

func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral) {
    Helper.showToast(controller: self, message: "Disconnected from \(peripheral.name ?? "Unknown Peripheral")", seconds: 1)
    foundPeripherals = []
    updateTableView()
}
func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
    guard let services = peripheral.services else { return }
    
    for service in services {
        peripheral.discoverCharacteristics(nil, for: service)
    }
}

func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
    guard let characteristics = service.characteristics else { return }
    
    for characteristic in characteristics {
        if(characteristic.uuid == tempCharacteristicCBUUID) {
            peripheral.readValue(for: characteristic)
            peripheral.setNotifyValue(true, for: characteristic)
        }
        //Checks for other desired characteristic ...
    }
}

func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
    let timeStamp: Double = NSDate().timeIntervalSince1970
    
    switch characteristic.uuid {
    case tempCharacteristicCBUUID:
        let characteristicValue = characteristic.value!
        let temperature: Double = Double(Int16(characteristicValue[0]))
        DataPoints.sharedManager.appendTemperature(timeStamp: timeStamp, temperature: temperature)
    //Checks for other desired characteristics ...
    default:
        print("unhandled characteristic with uuid: \(characteristic.uuid)")
    }
}

3.4.2 Monitor

Charts 3.0 biblioteket blev anvendt til at visualisere temperatur værdierne som et linjediagram, med udgangspunkt i følgende: How to Create Beautiful Chart in Swift

Diagram objektet tilføjes efter initialisering til Monitor klassen som et Subview, første gang denne loades. Selve strukturen for håndteringen af Subviews (diagrammer og andre former for visualisering af data) er baseret på at alle Subviews der ikke er i fokus, skjules. Det er ligeledes kun det Subview der er i fokus, samt relevante label, der opdateres periodisk af Monitor klassen.

override func viewDidLoad() {
    super.viewDidLoad()
    
    chartMeasures = Helper.getChartViewBoundaries(window: UIApplication.shared.keyWindow!, screenSize: UIScreen.main.bounds)
    addLineChartTemperature()
    
    let timer = Timer.scheduledTimer(timeInterval: 0.1, target: self, selector: #selector(self.updateViewData), userInfo: nil, repeats: true)
}

@objc func updateViewData() {
    updateDataLabels()
    
    if(currentChart != previousChart) {
        hideAllCharts()
        previousChart = currentChart
    }
    
    switch currentChart {
    case 0:
        updateLineChartTemperature()
    default:
        print("unrecognized chart")
    }
}

func updateDataLabels() {
    let currentTemperature: Int = Int(DataPoints.sharedManager.getCurrentTemperature())
    let currentButtonA: Int = Int(DataPoints.sharedManager.getCurrentButtonA())
    let currentButtonB: Int = Int(DataPoints.sharedManager.getCurrentButtonB())
    let currentAccelerometer: [Double] = DataPoints.sharedManager.getCurrentAccelerometer()
    var currentAccelerometerX: Int = 0
    var currentAccelerometerY: Int = 0
    var currentAccelerometerZ: Int = 0
    
    if(currentAccelerometer.count != 0) {
        currentAccelerometerX = Int(currentAccelerometer[0])
        currentAccelerometerY = Int(currentAccelerometer[1])
        currentAccelerometerZ = Int(currentAccelerometer[2])
    }
    
    labelTemperature.text = "Temperature: \(currentTemperature)"
    labelButtons.text = "Buttons: A=\(currentButtonA), B=\(currentButtonB)"
    labelAccelerometer.text = "Accelerometer: x=\(currentAccelerometerX), y=\(currentAccelerometerY), z=\(currentAccelerometerZ)"
}

func addLineChartTemperature() {
    lineChartTemperature = CustomLineChart(frame: CGRect(x: chartMeasures[0]+30.0, y: chartMeasures[1]+100.0, width: chartMeasures[2]-80.0, height: chartMeasures[3]-160.0))
    lineChartTemperature.setupChart()
    view.addSubview(lineChartTemperature)
}

func updateLineChartTemperature() {
    let allTemperaturePoints: [[Double]] = DataPoints.sharedManager.getAllTemperaturePoints()
    lineChartTemperature.updateChart(values: allTemperaturePoints)
    
    let autoScroll = lineChartTemperature.getAutoScroll()
    switchAutoScrollTemperature.setOn(autoScroll, animated: false)
    
    lineChartTemperature.isHidden = false
}

func hideAllCharts() {
    lineChartTemperature.isHidden = true
}

3.4.3 Datalogs

MessageUI frameworket blev anvendt til at sende den genererede .csv fil via email. MFMailComposeViewController objektet står for at oprette det fornødne view, mens MFMailComposeViewControllerDelegate objektet står for at lukke det igen efter mailen er sendt.

func exportToCSV() {
    let csvFileName = RetrievedDataPoints.sharedManager.getDataLogName()
    let csvFilePath = NSURL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent(csvFileName)
    let csvContent = generateCSVContent()
    
    do {
        try csvContent.write(to: csvFilePath!, atomically: true, encoding: String.Encoding.utf8)
        
        if MFMailComposeViewController.canSendMail() {
            let emailController = MFMailComposeViewController()
            emailController.mailComposeDelegate = self
            emailController.setToRecipients([])
            emailController.setSubject("micro:bit bluetooth datalogger: \(csvFileName).csv")
            emailController.setMessageBody("Here's your micro:bit data :)", isHTML: false)
            emailController.addAttachmentData(NSData(contentsOf: csvFilePath!)! as Data, mimeType: "text/csv", fileName: "\(csvFileName).csv")
            present(emailController, animated: true)
        }
        else {
            Helper.showToast(controller: self, message: "An Email Client needs to be Activated in Settings", seconds: 1)
        }
    }
    catch {
        print("Failed to create file: \(error)")
    }
}

func mailComposeController(_ controller: MFMailComposeViewController, didFinishWith result: MFMailComposeResult, error: Error?) {
    controller.dismiss(animated: true)
}

3.4.4 DataPoints

Den oprindelige tanke var at implementere DataPoints som på til venstre, hvor hvert entry i DataPoints, bestod af ét enkelt DataPoint objekt, indeholdende de forskellige sensorers med meres værdier, samt et tidstempel. Men grundet at micro:bitten ikke notificerer alle værdier samtidigt og eller notificerer værdierne synkront, var det ikke muligt at følge denne struktur, hvorfor strukturen i diagrammet til højre blev valgt i stedet.

Et resultat af den anvendte struktur er samtidigt, at det med denne er muligt at tilgå den samlede data for én enkelt sensorer, enkeltvis.

3.4.5 Diagrammer over implementeringen

I forbindelse med projektet blev der anvendt et Use Case Diagram, samt et Class Diagram. Begge diagrammer blev igennem projektet anvendt på skitseniveau, men for at øge reproducerbarheden af projektet, er disse blevet formaliseret yderligere.

3.4.5.1 Use Case Diagram

Use Case Diagrammet kan ses nedenfor i dets endelige udgave. Diagrammet beskriver brugerens interaktionsmuligheder med appen, samt de bagved bagvedliggende processer der aktiveres for hver interaktion. Derudover beskrives der ligeledes de processer der udføres uanset brugerens interaktioner. Download diagrammet for at få vist en større udgave.

Use Case Diagram: micro:bit Datalogger

3.4.5.2 Class Diagram

Class Diagrammet kan ses nedenfor i dets endelige udgave. Diagrammet beskriver den endelige implementerings klassers indbyrdes relationer, samt deres properties og metoder. Download diagrammet for at få vist en større udgave.

Class Diagram: micro:bit Datalogger

3.6 Prototyping

Baseret på kravene, blev der identificeret en række delelementer der tilsammen ville udgøre kernen funktionaliteten i appen. For hvert delelement blev der oprettet en selvstændigt prototype, for gennem isolering at højne overskueligheden af delelementet, samt at undgå unødige samspils komplikationer, førend elementet var korrekt implementeret. De identificerede delelementer og konstruerede prototyper var som følgende:

  • Tab bar view
    • Implementer en tab bar med tre tilhørende views, hvilke der frit kan navigeres mellem
  • Core Bluetooth
    • Implementer muligheden for at søge efter tilgængelige Bluetooth enheder.
    • Implementer muligheden for at oprette og afbryde forbindelsen til en valgt Bluetooth enhed.
    • Implementer aflæsningen af værdien af en eller flere af micro:bittens interne sensorer
      – Den interne temperatur sensor blev anvendt hertil, senere kom accelerometeret og knapperne (A/B) til.
  • IO Charts
    • Implementer visualiseringen af et array indeholdende værdier for henholdsvis x- og y-aksen, som et Line Chart.
  • SQLite3 Database
    • Implementer et CRUD eksempel
      – Der blev senere skiftet over til at anvende CoreData frameworket i stedet.
  • Export to .csv
    • Implementer eksporteringen af et array som fil i .csv format.
      – Da det kun er Apple Development Program members, der kan implementere muligheden for at gemme en fil i brugerens iCloud mappe [14], blev der i stedet implementeret muligheden for at sende .csv filen, til en ønsket mail-adresse.

Efter at have fået implementeret samtlige delelementer individuelt, blev de samlet implementeret i et samlet projekt. Dette projekt blev løbende udsat for intern prototyping, for at sikre robustheden heraf.

3.7 Evaluering

Gennem selve udviklingen foregik der udelukkende intern evaluering, efter endt implementering blev der foretaget en enkelt brugerbaseret usability-evaluering (undertegnedes forældre og søster). Evalueringen forløb efter hensigten og der viste sig ikke nogen større udfordringer med implementeringen.

4 Diskussion

Det gav et godt overblik allerede fra starten at skitsere et konceptuelt design for det visuelle, samt brugerens interaktionsmuligheder. Med disse på plads kunne kravene let identificeres og isolerings metoden med et projekt til hvert delelement gav den ønskede overskuelighed.

Med de enkelte delelementer på plads, var det derefter relativt ligetil at implementere de forskellige løsninger i én samlet app. Ved fra starten at have implementeret datastrukturen, samt visualisering strukturen med henblik på fremtidig udvidelse af appen, krævede det ikke meget yderligere arbejde at udvide med det interne accelerometer, samt de indbyggede knapper.

Den visuelle del af projektet har derimod ikke været vægtet højt, hvorfor denne også efterlader meget at ønske. Dertil kommer at evalueringen har været nær ikke eksisterende, samt relativt underordnet projekts formål som værende overvejende funktionalitets orienteret, taget i betragtning.

Strukturen for DataPoints objektet, viste sig senere i udviklingen at have sine fordele, til trods for at det ikke var den oprindeligt tiltænkte struktur. For i og med at værdierne for hver sensor mm. er gemt særskilt, tillader det samtidigt at de kan tilgås særskilt, således at alle værdier ikke behøves hentes hver gang en af dem ønskes aflæst.

5 Konklusion

Der blev udviklet en app med mulighed for at monitorere flere af micro:bittens sensorer over Bluetooth, samt eksportere disse til en fil i .csv format. Den udviklede app er derudover implementeret med henblik på fremtidig videreudvikling, på en måde der muliggøre løbende tilføjelse af nye funktionaliteter (nye sensorer, nye monitorerings muligheder). Projektets mål er derfor blevet nået.

5.1 Fremtidig videreudvikling

Hvis der skal udvikles videre på projektet i fremtiden, vil det særligt være en fordel at se på andre metoder til at opdatere monitor viewet, end den nuværende periodiske. Dette kunne eks. opnås gennem delegation ved ved hjælp af segue, så monitor controlleren kan implementere eventuelle opdaterings-orienterede protokoller fra connect controlleren. En prototype på dette har været oprettet, den kom dog desværre aldrig til at fungere sammen med tab baren, men udelukkende gennem buttons.

6 Referencer

[1] https://en.wikipedia.org/wiki/Micro_Bit

[2] https://www.dr.dk/ligetil/elever-i-4-klasse-skal-laere-programmere

[3] https://www.dr.dk/skole/tilmelding-til-projekt-ultrabit-2019

[4] https://www.microsoft.com/en-us/makecode

[5] https://en.wikipedia.org/wiki/Scratch_(programming_language)

[6] https://en.wikipedia.org/wiki/MicroPython

[7] https://microbit.org/guide/mobile/#og-app

[8] http://bittysoftware.com/index.html

[9] https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller

[10] https://developer.apple.com/documentation/corebluetooth

[11] https://developer.apple.com/documentation/coredata

[12] https://developer.apple.com/documentation/messageui

[13] https://github.com/danielgindi/Charts

[14] https://developer.apple.com/support/app-capabilities/

Leave a Reply