This controller is our communication point with the rest of the world. It talks to the data storage over a Secure Sockets Layer. Authorization is granted through bearer tokens. This controller itself is password protected.

Our app also communicates with the data storage, through a secured line.

Access to the desk and its information is secured with personal RFID cards.

This blog post is a submission for the Force Field badge

Sometimes when a user has reached a pre set treshold, say 1000 Tickets, We have included an instant celebration device firing of a party popper for the purposes of gamification and general amusement.

We've designed an app to remotely control the bed. Take a look at our beautiful, clean graphical user interface in the pictures below. We've chosen a soothing cool theme in sky blue and white.

So I started looking into the actual code for the "Great Inspector". They talk about [making love, not war], but IT'S ALL FAKE! IT'S JUST BASED ON AGE! It does not matter what kind of skills, occupation or social grade you have, if you are older than 35, you will not get on that space craft!

I have uploaded the entire “Great Inspector Code” to GitHub, to show you that SaaS cannot be trusted! https://github.com/Gullik/Kernel-panic-2.0

Just look at this code from line 13 in
candidateevaluation/confidential/evaluatationalgorithm.py

IT'S JUST BASED ON AGE!

I need to go now… I can hear them coming...

For easy unit administration, IP adress, location descriptions, Define ticket templates and more, we have created a rather smashing Dashboard called "Master of Deviants"

Even though a typical developer desk is cluttered with various items, we wanted to make our desk as smooth and clean as possible. Therefore, we designed a bunch of smooth physical objects that would support our solution.

We have already described two of the smooth objects here and here, so we will not describe these again, but please note that they are definitely also a part of this smooth submission.

Check out the following before and after images to see how smooth our desk have become after utilizing these objects.

First, the micro:bit that we so kindle received, which we decided to turn into a sign to put on your screen that you can turn on to tell people around you that you don't want to be disturbed by displaying a red X.

Before:

After:

Then, we wanted to get rid of the ugly footer for our fan.

Before:

After:

We also had two buttons that we did not know where to place: one for turning the red X sign on and off, and the other one for switching between sitting and standing position. Therefore, we created a case to put the two of them in.

Before:

After:

The final cherry on top (or in this case, the bottom) is the holder for the RFID reader. Instead of having the whole thing on top of the desk, we realized that it could read your card through the desk. Therefore, we printed a holder so that we could mount the reader underneath the desk. We put an ARIoT sticker on the desk over the reader to show the users where to beep their card.

All these smooth objects support our solution and make our desk really smooth, much smoother than it would be without them.

This blog post is our third and final submission attempt for the Smooth object badge.

For the game side of our project all the collected data is securely delivered over https to the cloud, where everything is stored by Microsoft with compliance to the EU GDPR law.

For the wearable part of our workout monitoring solution we used the standard security measurements: our BLE device stores data encrypted, so even if you connect to the device and read the Scratch memory, it won't make any sense unless you have a key.

Feel safe with FitTeam, just train 🙂

The app let's you register a new user, and it's also possible to edit your profile if you are already registered.

read RFID ->

submit ->

This is a submission for Native

We have made our python script available to the world under the MIT License on github:
https://github.com/dizzi90/deviatr-rfid

Wouldn't it be nice to control the bed by just using the face. This could be amusing to some, but a necescitty for others.

Disabled people can active a function just by looking at the camera.

We have used face recognition in Max to detect faces. When one face is present, the lamp is turned on. When the face is not present, the lamp is turned off.

It is a warning light that can be duct taped to the athlete and will warn others about his presense.

Because we are geeks, we did write it in assembler, a language I swore to never touch again seven years ago. Thanks ARIoT.....

#define LEDPORT PORTB    // Arduino pin 13 is bit 5 of port B
#define LEDPORT_DIR DDRB
#define LEDBIT 5

void setup() {  
 asm volatile ("  sbi %[portdir], %[lbit]  \n"    // Set bit direction
      "3: "                                        // main loop label
      "   sbi %[port], %[lbit] \n"                 //  Turn on.
          /*
           * About the delay loop:
           *   The inner loop (dec, brne) is 3 cycles.
           *   For one second, we want 16million cycles, or 16000000/(3*256*256) loops.
           *   This is "about" 81.
           */
      "    clr r16  \n"
      "    clr r17  \n"
      "    ldi r18, 81  \n"   // 100 * 256
      "1:"  // 1st delay loop label
      "    dec r16  \n"
      "    brne 1b  \n"
      "    dec r17  \n"
      "    brne 1b  \n"
      "    dec r18  \n"
      "    brne 1b  \n"

      "    cbi   %[port], %[lbit] \n"             // Turn off.

      "    clr r16  \n"
      "    clr r17  \n"
      "    ldi r18, 81  \n"
      "2:"  // 2nd delay loop label
      "    dec r16  \n"
      "    brne 2b  \n"
      "    dec r17  \n"
      "    brne 2b  \n"
      "    dec r18  \n"
      "    brne 2b  \n"

      "    rjmp 3b  \n"
      :
      : [portdir] "I" (_SFR_IO_ADDR(LEDPORT_DIR)),
        [port] "I" (_SFR_IO_ADDR(LEDPORT)),
     [lbit] "I" (LEDBIT)
      );
}


void loop() {

}

We are approaching production grade quality on our smartbed! But before we can start publishing your pee-statistics to the cloud we must take some time to add some proper security to our solution.

HTTPS

We need a way to ensure that data cannot be read or altered in transit between the server and the smartbed. This is achieved by running all traffic over the TLS encryption protocol. This way, no one can intercept how much you pee pee.

SSH-keys

Our server in Cloud City can be controlled over ssh. In order to restrict admin-access to the server, only individuals with an authorized private ssh-key can connect this way. This is achieved by adding the public key of authorized individuals to the file authorized_keys on the server. Password-authentication has been disabled to prevent users typing insecure passwords.

Database

With an open source project like ours, it is important not to store database credentials in the code. Also, zzzmartbed-hackers will be displeased to know that the database is only accessible from the server localhost though a secure proxy client.

The power consumption data is pulled wirelessly using Z-wave from the wall plug to a Raspberry Pi, and then posted to our API in the Google Cloud, and saved to the CloudSQL database. We added report of the Power Consumption to our Dashboard, making it more visible when Power Consumption is high.

Badge

Having now used this as the 5. sensor in our solution we think we deserve the [This is intense!] badge.

The other 4 sensors we have already used:
1. Nordic Thingy temperature sensor for fever tracking
2. Nordic Thingy pressure sensor for Pressure Endurance Test Chamber
3. Micro:Bit accelerometer for step counting
4. Estimote Bluetooth Beacon tracking distance on Android, for the toilet trip counter

In OL 1994 the official mascot was Kristin and Håkon. These non-intelligent IoT dolls got a huge success. We think an IoT doll that acts after your thoughts could inspire in training. This is especially nice for kids! They love dolls and even better if they interact with them. With the cheers from this doll, young athletes can perform even better!

Our training doll mascot read the Alpha thoughts of the athlete. The alpha thought are the default relaxed and alert' mode of the brain (https://emotiv.zendesk.com/hc/en-us/articles/208378593-Frequency-Bands-what-are-they-and-how-do-I-access-them-) and send a signal to the robot, if they are high (the signals ... not the person). These triggers that the robot waves with a ARIoT flag.

The doll has a battery pack that is included in the body that is possible to change. So this training mascot is possible to bring everywhere.
The robot is built from scratch; cloth, paper, bottle and a lot of tailoring are the main parts. Wires are even sewn into the head, to power the lamps.

It's smart because YOU are the brain!

In the last gif you can see that the robot startes to wave when I am not relaxed!

With this as a starting point, we developed the "Visma PT Dashboard", a dashboard (or HUD depending on the device you're on) that displays all relevant health, tracking and performance data that we record in the cloud for a given person during a workout (or during any activity).

The dashboard is a .Net Web App coded from scratch that runs in Azure. It also has a Web API with endpoints for updating the various data displayed. The API is called by various Azure Functions that on their side pulls data from Azure Data Lake Storage and Nokias Health API. By doing all the data storing and processing in Azure Data Lake Storage and Azure Functions, the Visma PT Dashboard is completely disconnected from any major business logic, and that ensures that the uptime is near 100% and is virtually bug free(/s).

When the Azure Functions has pulled the data they need, they call the Visma PT Dashboard API, and SignalR is used to update the data on the dashboard. This means the user never has to refresh the dashboard manually, it is updated instantly when new data arrives from the Azure Functions.

THE DASHBOARD!

The dashboard contains some basic data about the athlete, as name, weight and height (top row) (ignore the height icon, WIP). The two latter are pulled from the Nokia Health API, and we have a Nokia Body+ Weight scale that automatically synchronizes weight data++ to Nokia Health. The Nokia Health API is called every minute from an Azure Function to get the latest weight and height of the "athlete".

There is also live tracking of the athletes position and altitude (map and bottom row) (and eventually velocity, but this is a feature that comes in Visma PT Dashboard 2.0), and these values are dynamically plotted in to Googles Map API as they come in to the Dashboard via the Visma PT Dashboard API and SignalR.

The athletes body temperature and heart rate is also displayed and dynamically updated (bottom row).

In addition, we display the amount of sweat the "athlete" is currently emitting (read more about that here). (At the top right of the dashboard)

The HUD is of course beautifully engineered to fit any screen (included smart phones), and can therefore be used by athletes as they exercise.

THE STICKMAN aka Jason!

As a revolutionary feature, the dashboard also displays a model of the athletes body as he exercices. The athlete is recorded on camera, and via tensorflow openpose (tf-openpose) a model is generated with the athletes body parts as x- and y-axis coordinates. The coordinates are then live pushed to the Azure Data Lake Storage, and an Azure Function is then pushing that data to the Visma PT Dashboard API. Using canvas-drawing the model is drawed on the screen every time input comes to the javascript-logic used displaying the model. When data comes in, the dashboard is faded out and an overlay of the model covers the screen. When data stops arriving, the overlay is faded out and the dashboard appears again.

With this HUD/dashboard we hope to get the HUD-badge and the Shiny pixels-badge :)