For more information on our project please look back to our earlier blog post 
"Prototyping A Sports Wearable With Microbits" on June 6th 2018
https://www.playfulcomputation.group/blog/prototyping-a-sports-wearable-with-microbits

Purpose
As this project moves forward, we are quickly approaching an important stage of development - implementing machine learning within our ios app. Before we do this, we believe it is important to test out machine learning in general in order to figure out the best ways to implement classifications and general machine learning settings with the microbit.

Process
To test out machine learning with the microbit, we used a mac app created by github user Louismac, which connects to the microbit bluetooth and takes information about the microbit sensors, namely the x,y and z accelerations, three states of the two buttons on the microbit board (not pressed, short press, long press) and pin info. This data is then sent to a mac machine learning application known as wekinator through OSC messages. Wekinator is a platform that works as a median between input and output devices and uses machine learning to classify a variety of different gestures.
​
The gesture we decided to use for this test was a simple throw with a frisbee. More specifically a flick throw. we chose this gesture for two reasons. First, with the way our app will initially operate, it will be more sports focused than anything else so it makes sense to start by testing a sports gesture, and furthermore we know ultimate frisbee very well and know what makes a good throw and what makes a bad throw.

Classification
we thought of three classifications for a flick throw. There are more gestures we could have done, especially if a user wants to look at different trajectories of a single throw, but we focused in on a good straight flick throw to simplify the model. The first classification is a “good throw.” There are two main components that make a good throw. First, is the users arm acceleration as they throw the disc, and second, and more important part, is the wrist acceleration or wrist “snap” as user throws the disc. Again, there are other components as well - tilt, arm distance, stance, finger positioning and more. However, ever flick requires good arm and wrist acceleration and we felt these gestures would be the easiest to view with acceleration sensors.
​
The second gesture is a throw with no wrist acceleration but strong arm velocity and acceleration. This is an extremely common and incorrect way of throwing flick throws, especially for beginners, as the concept of flicking your wrist for power is new to many players and can feel unnatural at first. This throw may go far, but has low accuracy and the user has very little control. These throws tend to be extremely unpredictable.
The third and last gesture is a throw with no arm but a good wrist flick. This is not necessarily a bad throw. In fact many beginners will start with this type of throw, because it can help focus the user on their wrist, which again can be unnatural at first. Still, it is an incomplete throw, as the follow up is still vital. This throw will have better accuracy than the second gesture but poor power and will drop fast.

The Algorithm
 There are a multitude of different machine learning algorithms within wekinator but, we chose to use dynamic time warping or DTW algorithm to classify my throws. The idea for DTW stems from the fact that with many gestures, we may want to classify them even with varied speed, different pauses and more. For instance, in the case of flick throws, if we am throw a huck (A long ball or a hail mary for ultimate frisbee) and a short flick pass, these 2 throws will be very different. However, we still want to define these both as flicks. Dynamic time warping has the ability to classify these actions consistently even though they have variation. It is a very useful algorithm that is seen in a variety of different types of models, especially voice recognition. It will likely be one of our main algorithms within the ios app.

The Results
 There were a few different things we noticed as we was making the flick model. First of all, small actions, namely the poor arm but good wrist gesture, are constantly detected. For a while, every time we did any gesture, including a “good throw” the model would also inform me that we did not have enough arm. In fact, often when we did nothing at all, wekinator classified my action as this gesture. In order to deal with this problem I added in a 4th gesture. This gesture, standby, used data points from when I was doing nothing with the disc, just holding it. This seriously helped with all of the gestures especially the "good wrist" gesture. Furthermore, I added more data points from a variety of different positions, hand gestures and more. After finishing training I would continue on to testing where, in general I found problems with the model and returned to adding or removing training points. At the current moment the "good throw" is registers 19/20 times, the good wrist is register 16/20 times and the good arm is registers 17/20 times. Standby is register 20/20 times as it is a very simple gesture. I have a total of 83 test points, 20 of which are a good throw, 21 are good wrist, 24 are good arm and 18 are standby. I have given good arm the most data points as it is the error that most beginners face and there are a variety of different ways users swing their hands when they are initial running into this error. 
​
For more information please watch the video below. In it, we demonstrate a poor arm throw, a good throw and 2 poor wrist throws. However, the first poor wrist throw is classified as a good throw, showing that the program is not yet perfected. ​​

Please look here to find Louismac's github: https://github.com/Louismac/CBMicroBit
Here is the github to our project: ​https://github.com/LaboratoryForPlayfulComputation/WearableToolKit

Annie Kelly

This tutorial will show you how to modify a pet toy to detect shake using the micro:bit.

1. Computer (laptop or desktop)

You will need to use a computer with internet access and a USB port to program the micro:bit. ​

2. Two micro:bits (2) and at least one microUSB cable (1)

You will need two micro:bits (~$12) and at least one USB cable to complete this tutorial. Many retailers sell starter kits such as this one.

3. Battery pack (at least 1)

You will need one battery for the micro:bit that goes inside of the toy. In this tutorial we are using a rechargeable Lithium Ion battery, but you can also use a AA or AAA battery holder.

4. Pet toy

A pet toy of your choosing, I would recommend a stuffed toy since it will be easiest to insert the micro:bit and battery.

5. Scissors and/or utility knife 

These will be necessary for making an incision in the pet toy.

6. Glue, tape, sewing kit, etc.

This is for closing the incision on the pet toy.

We will be using two micro:bits in this tutorial. One micro:bit will go inside of the toy and do the actual shake detection, and the other micro:bit will be the one that displays us information and/or does something when a shake is detected. In order to do this, we will be using the micro:bit radio features. 

By the end of this tutorial you will have shake sensing code on the micro:bit inside of the toy that sends a message to the other micro:bit that displays "Hi!" on the LED screen when a shake is detected.

​Go to https://makecode.microbit.org/ to use the blocks based programming editor for the micro:bit. If you are unfamiliar with micro:bit programming you may want to visit the official Getting Started page.

Step 2.1: micro:bit sending code (for the micro:bit that goes inside the toy)

First let's write the code for the micro:bit going inside of the toy. Let's call this the SENDER micro:bit since it will be sending messages to the other micro:bit. I recommend labeling each of the micro:bits so you remember which code is on which one. Label this one SENDER, and the other micro:bit RECEIVER.

From the Basic block category select the on start block. The on start block is what runs one time when the micro:bit is turned on.

Now let's look inside the Radio block category. Select the radio set group block and place it inside of the on start block. The radio set group chooses what channel the micro:bit's radio will communicate over. Imagine you had two walkie-talkies and you are trying to talk to your friend -- you have to be on the same channel as each other for it to work. This is the same concept. In this example I set my group to 5, but you can choose any number from 1-255 as long as you make sure to set your group to be the same value on both of your micro:bits!

Now, let's open the Input block category. Select the on shake block. This block will be activated when the micro:bit detects that it has been shaken. Let's open the Radio block category again, but this time select the radio send number block and place it inside the on shake block. Now when you shake the micro:bit it will send a number over the radio. For this tutorial the number you send is arbitrary (it is 0 by default), but in more complicated examples you may want to send a specific number.

Now our micro:bit toy code is complete! You can see the program below and download it there if you'd like. Once you've downloaded the code, upload it to the micro:bit we labeled as the SENDER.

​Step 2.2: micro:bit receiving code 

 Now let's program the second micro:bit that will be receiving messages from the micro:bit inside the toy.

​Like we did in Step 2.1, go to the Basic block category and select the on start block. Now go to the Radio block category and select the radio set group block and place it inside of the on start block. Make sure you set the group number to be the same number that you used in the code from Step 2.1 otherwise this won't work!

Now, go back to the Radio block category and select the on radio received receivedNumber block. This code will run whenever the micro:bit receives a number over the radio. If you recall, in step 2.1 we wrote a program to send a number whenever a shake is detected; this means that whenever a shake is detected on the micro:bit inside the toy, this on radio received code will be run. Go back to the Basic block category and select the show string "Hello!" block. You can change "Hello!" to whatever you like. I recommend keeping it short since it takes a while for the text to scroll across the micro:bit's screen.

​Now our micro:bit receiving code is complete! You can see the program below and download it there if you'd like. Once you've downloaded the code, upload it to the micro:bit we labeled as the RECEIVER.

In this step we'll take the micro:bit labeled "SENDER" and insert it inside the toy. Make an incision either using scissors or a knife on the toy. On mine the best place to do it was on the mouse's belly, on yours it might be different. Once I made the incision, a lot of stuffing started coming out. Instead of pulling it out I cut off the excess with some scissors so that I didn't accidentally remove too much. The toy I used in this tutorial already had a vibrating motor inside of it, so I carefully removed it. Once it looked like there was enough space for the micro:bit and battery I carefully inserted it (make sure you connect the battery first).

You might need to wiggle the micro:bit around to get it to fit nicely. You may want to glue, tape, or sew the toy back together, but I would recommend testing briefly before doing this.

Make sure both micro:bits are powered on and then give the toy a good shake, you should see "Hi!" scroll across the LED screen on the other micro:bit.

Annie Kelly

This tutorial will show you how to build a switch that can be activated by pushing down on it with your hands, feet, pets' paws, etc.

This tutorial will be using a tiny programmable computer called the micro:bit and basic craft and electronics materials.

1. Computer (laptop or desktop)

You will need to use a computer with internet access and a USB port to program the micro:bit. ​

2. micro:bit and a microUSB cable

You will need a micro:bit (~$12) and USB cable to complete this tutorial. Many retailers sell starter kits such as this one.

3. Alligator clips

In this tutorial I simply use alligator clips to connect the servo to the micro:bit, but for a more finished project you may want to consider soldering the connections so that they are more secure.

4. Cardboard and scissors

In this tutorial we are building the switch out of cardboard.

5. Aluminum foil

This will be the main material necessary for detecting pressure on the switch.

6. Tape

Any tape is fine. Glue is also an acceptable substitute.

We will be using 3 pieces of cardboard to create the pressure switch. The two larger pieces will go on the outsides, and the smaller piece will go in the center. This is so that when we push down on the switch the outsides of the two larger pieces will make contact. In this example the two larger pieces are 4 in x 5 in, and the smaller piece is 3.5 in x 3.5 in. Feel free to adjust these sizes to your liking. 

Next we want to cover both of the larger pieces in aluminum foil (leave the smaller center piece alone, it will not​ work if you cover it in foil). We want the inner-facing sides of the pieces to be completely covered in foil. To do this, cut a piece of foil larger than the piece of cardboard and then tape the pieces over the back edge.

This is what the backs of the larger pieces should look like.

And this is what the other side of the large pieces look like. Now we are ready to put all the pieces together.

Tape the smaller piece onto the inside of one of the larger pieces. Then tape the large piece on top. The above right photo is what the switch looks like from the side once it is all together.

We want the switch to be activated when the two pieces of aluminum foil touch. In order to do this, we need to connect one of the sides to the power source (pin 3V on the micro:bit), and the other side to one of the input pins (pin 0 on the micro:bit). This way, when the two pieces of foil are not touching the value of the pin will be 0, and when the two pieces of foil are touching the value of the pin will be 1.

If you are not familiar with programming or using the micro:bit, we recommend visiting the official Getting Started page.

Otherwise, let's start writing some code. This will be a simple program that will show the state of our switch on the LED screen. It will show us a 0 when the switch is not pushed down, and will show us a 1 when the switch is pushed down and activated.

Grab a forever block from the Basic category in the micro:bit programming editor and put a show number block inside of it. Click on the Advanced category dropdown and then click on the Pins category. Place the digital read pin P0 block inside of the show number block.

Download the code and load it onto the micro:bit.

Once you have uploaded the code from Step 4 onto the micro:bit and completed the wiring in Step 3, you can now test to see if your pad works.

​http://www.instructables.com/id/Use-a-DIY-Pressure-Plate-Switch-to-Automate-Your-H/

We're building a create-your-own wearable kit to bring machine learning and statistics concepts to students. We envision students asking questions around sports performance such as, "How can I improve my tennis serve?", "What percentage of my shots are accurate over time?" or "Why doesn't our basketball team ever win?". They would then use wearable sensors to collect data from the body, analyze it using provided tools, and try to draw some conclusion. 

The bulk of this work involves building an app that allows the user to customize data collection and analysis from on-body sensors, and designing curricula to support use in secondary math and gym classes. This post will focus on our work on the application. To build the app, we need to enable four main functionalities:

1. Capturing video and sensor data
2. Allow user to segment gestures, assign labels and classifications
3. Train machine learning algorithms on the segments provided by the user
4. Test trained algorithm on new user input

We're currently prototyping with Micro:bits and iPhones. We just completed work on capturing video and sensor data, and wanted to share some of our demos and next steps!

Our first goal was to make the Micro:bit's accelerometer data available in the app. We connected to the Micro:bit using bluetooth, calculated the magnitude of acceleration at each reading, and graphed the results over time. ​

Signing off,
Abigail Zimmermann-Niefield, Bridget Murphy and Varun Narayanswamy

Annie Kelly

This tutorial will show you how to build your own micro:bit powered automated pet feeder.

This tutorial will be using a tiny programmable computer called the micro:bit, a servo,  and basic craft and electronics materials. A lot of the following materials can be substituted, and doing so may result in your needing more or less than the other materials. This list is mostly suggestions.

1. Computer (laptop or desktop)

You will need to use a computer with internet access and a USB port to program the micro:bit. 

2. micro:bit and a microUSB cable

You will need a micro:bit (~$12) and USB cable to complete this tutorial. Many retailers sell starter kits such as this one.

3. Servo

The servo will be the part of the feeder that is responsible for releasing food. Basically, it will be the mechanism that we can rotate over the opening of the bottle. In this tutorial we are using the Tower Pro MicroServo SG90, but any small ditial servo should do just fine.

4. Wire cutters/strippers

These will come in handy when we need to connect the servo to the micro:bit. If you do not have access to these tools you can use a pair of scissors to cut the wires and to carefully strip the ends.

5. Either alligator clips or soldering materials

In this tutorial I simply use alligator clips to connect the servo to the micro:bit, but for a more finished project you may want to consider soldering the connections so that they are more secure.

6. Bottle

Depending on the pet food you are using, you may want a smaller or larger bottle. Feel free to experiment with different sizes and different types of spouts. You might even find that you want to add a small paper funnel into the opening of the bottle to get better control over how much food is dispensed at any given time. In this tutorial I am using a small plastic spray bottle.

7. Glue and tape

This will be important when attatching all the different components of your pet feeder. In this tutorial I use hot glue to attach the servo directly to the bottle, but you could use tape or other materials instead.

8. Cardboard and scissors

I've found that a small cardboard box is really useful for making the structure of your pet feeder. In addition, I also use cardboard in this tutorial as part of the mechanism that keeps and releases food in the bootle.

9. Pet food!

Either your pet's favorite dry food or some treats.

First you will want to decide how you want to hold up your pet feeder. Since we will be relying on gravity to release the food from the feeder, we want to construct a stand so that the feeder bottle can be placed vertically with the opening facing downward. In addition we will want there to be space between the opening of the bottle and the floor (or table, bowl, etc.) That's why building a stand is useful.

​In this tutorial, my stand is simply a cardboard box turned on its side.

To keep the top lip of the box sturdy for when we attach the rest of the feeder, I put 2 long pieces of masking tape that wrap under the top lip and attach all the way to the back of the box. This helps keep it raised despite having weight placed on it.

If you don't have a cardboard box handy or would prefer to use something else, go for it! You may want to attach your feeder directly to a wall in which case you don't need a stand, or maybe you would prefer to use an old plastic box you have in your garage. Feel free to experiment with different things, as you might find that you need a different type of stand depending on where you want this to go and how much weight you want it to support.

Note: You may decide you want to test the bottle with the servo before doing this step, in which case you can save this until later. 

In this step I used hot glue to attach the bottle to the top lip of my cardboard box stand. I held it in place for about 1 minute as the glue dried to ensure that it didn't slide off while it was still hot.

If you are using the same servo as me you will notice that your servo came with a few accessories. These can be attached to the knob at the top of the servo. I attached the simple one-armed piece to the top of mine (it pops right on, no other assembly necessary).

You will notice that at the end of the wires there is a black plastic attachment. If you have male to male wires you can just stick one end in each of the 3 holes to get access to its connections, or you can snip off the plastic part with some wire cutters or scissors. In this tutorial I snipped off the black plastic piece, stripped off the ends of the wires, and attached alligator clips to each wire.

Below you can see I attempted to color coordinate my clips with the wires to avoid confusion. Each color-coded wire has a different purpose:
Brown (attached to the black alligator clip): Ground
Red (attached to the red alligator clip):  Power
Orange (attached to the yellow alligator clip): Signal
If you have trouble distinguishing the colors of the wires you can use order instead to tell which is which. The center wire (red) is power, and the darker one next to it (brown) is ground, and the remaining one (orange) is signal. 

Now that you have your alligator clips attached and know the role of each wire, you can connect them to the micro:bit. Connect ground (brown/black) to the GND pin
Connect power (red/red) to the 3V pin
Connect signal (orange/yellow) to the 0 pin (you could also use 1 or 2 if you'd like, but you'll want to make a note of this for when we start programming in the next step). 

​See photos below for reference.

Go to ​https://makecode.microbit.org/ to get to the micro:bit programming editor. If this is your first time programming a micro:bit you might want to visit their Getting Started page. Otherwise, let's continue.

To easily test out and play with our servo, let's create a program where the servo returns to its starting position (o degrees) when we push button A on the board, and have the servo rotate 90 degrees when we push button B. The button blocks can be found in the Input category in the programming editor, and the servo blocks can be found in the Advanced --> Pins category. Change the pin number to whichever pin you attached the servo's signal wire to, in this tutorial we are using pin 0 (P0).

Below is what the block program looks like (try clicking the little A and B buttons in the simulation below to see what happens to the servo):

And here is the corresponding JavaScript code (this can be copy and pasted into the editor if you click on the "JavaScript" tab):

​    input.onButtonPressed(Button.A, () => {
        pins.servoWritePin(AnalogPin.P0, 0)
    })
    input.onButtonPressed(Button.B, () => {
        pins.servoWritePin(AnalogPin.P0, 90)
    ​})

Now, plug your micro:bit's USB cable into the computer so that we can put our new program onto it. In the programming editor browser click the big blue "Download" button. You will now have a file in your downloads folder with a name that looks like "microbit-Untitled.hex" (if you changed the name of the project it will look similar except "Untitled" will be replaced with whatever you named it). Now you should be able to drag and drop that file onto your micro:bit. Again, if you are having issues with this step I recommend visiting the Getting Started page.

Once the program is successfully uploaded to the micro:bit you should see the servo turn 90 degrees when you press Button B, and return back to its original position when you press Button A.

In this step we are going to attach some kind of a flap to the top of the servo, and then attach the servo to our bottle.

For my flap I just cut a rectangular piece of cardboard and hot glued it so it is perpendicular to the white plastic piece of the servo when it is in its starting position (0 degrees). I did this so when I attach it to the side of the bottle 0 degrees will mean the bottle opening is closed, and when the servo is at 90 degrees the bottle opening will be open and food will be released. To ensure the servo is in its starting position just press Button A on the micro:bit so that it turns to 0 degrees (assuming you completed Step 5).

 Once the glue dried I started to glue the servo itself onto the plastic bottle. As you can see, the servo is at 0 degrees and the cardboard flap is holding the food inside of the bottle.

Well now you can work on creative ways to trigger the food dispenser. Right now we have it so its controlled by 2 buttons, but you might want to explore working with different sensors and triggers. Have fun!

This tutorial will show you how to use a light sensor to tell an automatic pet feeder that the food bowl needs to be refilled. Basically, the light sensor is at the bottom of the food bowl and when the light sensor detects light that means there is not enough food on top of it -- thus triggering a refill.

The Building an Automated Pet Feeder tutorial will guide you through the process of building the food dispenser itself (not using a light sensor yet). This tutorial can then be extended to be used in several different pet feeder projects. Once you have completed that tutorial, you can come back here to learn how to use the micro:bit's light sensor and connect it with the basic pet dispensing code.

The micro:bit's 5x5 LED board doubles as a light sensor and its value can be accessed by the light level block found in the Input block category. Its value can range from 0 (darkest) to 255 (brightest).

If you'd like to do some testing to see what value the light sensor has when you expose it to different amounts of light you can have the micro:bit constantly print out its light value to the screen using the below code:

You'll also want to test it out by putting it in the bottom of a food bowl and seeing what its light level is when the bowl is full compared to when it is running out of food.

I decided that 10 was a good threshold for my light sensor. When the bowl was full enough the light sensor's value was around 5-7, and when it started to get exposed to the light and it felt like an appropriate time for a refill the sensor would get above 10. You might decide you want a higher value to use as your threshold if you want less frequent refills than I did.

As I mentioned in step 2 I decided to use 10 as my threshold to decide whether or not to refill the bowl. If the light sensor value was getting a reading below 10 then that means there is enough food (because the food is blocking the LEDs from the light), and when the light sensor was over 10 that the bowl needed a refill. So I wrote a program that constantly checks the light levels and if it is >= 10 to move the servo to 90 degrees and dispense more food. Otherwise, it would keep the food bottle shut.

Located in the second basement of the ATLAS building on the CU Boulder campus, the immersive E.coli cell has begun to form. This is a project Annie and myself (Lila) are working on in the lab. We are working on building an immersive experience where the visitor can enter into and manipulate an E.coli cell. We imagine a space where the user transcribes DNA to RNA, then runs that through a ribosome to activate a protein which then can be used in a specific receptor that have different effects on the cell. For example, perhaps one protein will cause the cell walls change their shape, texture or color, where perhaps another protein will send a message to nearby cells which can be viewed through a portal window. 

While much of this still needs to be built, we have constructed the majority of the DNA and the type of user interaction that will occur. There are kinks to work out but the video below shows and describes the plan for the cell and DNA.

Below is also a video showing the fabrication of the DNA and the framing of the room.

Since the completion of the 10 yeast cells - based on different mutants and environmental conditions as studied by Zach Wilson - they have been on tour. Their first stop was Molecular, Cellular, Developmental Biology department retreat where students show their current work during two nights of poster presentation. When the yeast cells made their debut they received a high amount of attention from other graduate students curious about the visual forms and the science behind them. Some viewers stayed for 30 min trying to puzzle their way through the science and what each piece of data was telling them - much like Zach's own research process.

The cells second stop was a joint lab meeting (photo above) where Zach featured the yeast cells as a part of his talk about his research progress. He used them as a way to facilitate conversation amongst the labs and encourage group members to try to recreate a circuit diagram that described interactions between the a vacuole membrane lipid (PI3,5P2), a vacuole ion channel and pump, which helped to understand the lipid's function to regulate the cells water and ion concentrations.

The third stop on the yeast cell tour was the Annual Rocky Mountain Yeast Meeting held at the Coors Brewery. This time we tried a different set-up where the lanterns were hung on the wall instead of splayed out on a table. In part this was to match the format and spacing of the poster presentation. People's interest was peaked by the different display of information and many people stayed to investigate the lanterns and try to once again work through the science to see if they would come to a similar conclusion as Zach.

At the Yeast Meeting event there were several suggestions and questions we encountered which led to some slight redesign of the lantern lighting. For example, Zach's advisor suggested that we time the rates to all start together so that you could compare which rates were longest and shortest. Using the micro:bit radio function this was an easy fix. We also experimented with different color ranges to show high and low potassium concentration rather than brightness. We found viewers had a hard time distinguishing between higher and lower potassium concentrations. ​We implemented these changes and then submitted the yeast cells for a campus wide data visualization contest that the Norlin Library was putting on.

The Luminous Yeast project received second place in the campus wide competition and are currently residing in the 2nd floor of the Norlin Library (as shown above). Patrons of the library are instructed to peer inside and try to figure out the story of Zach's research - and to see what conclusions they arrive at. You can see an article about the competition here.

These are the costume sketches. AS you might notice, there are some fairly significant changes in certain outfits between what I sketched and what I will be creating as of this moment. ​There are also a few costumes missing; mainly the Blues and Hip Hop dancers. For these costumes, I already had a pretty clear idea of what I wanted them to look like, and functionality wasn't as much of a problem as it was for dancers. For example, with the aerialist, I had to think of both how to expose the areas in contact with the trapeze most (so no electronics are there), while also making the costume work for more hip focused styles. 

​These are the costumes from the sketches above. Each design choice has an explanation in the chart below. The yellow dots are LEDs. (; 

​So far, I have done a lot of ordering of stuff. I also made a skirt! I wanted to test a new technique, specifically for the swing dancer costume, but also for future pieces, of creating mesh piping to sew around hems that encase neopixels. Since this is a costume rather than an everyday garment, the LEDs don't need to be quite as obtrusively hidden. In the mesh, they are partially, but not entirely hidden from view. 

THe other part about the real world progress is that I am trying not to sew as many of the garments by hand this time. Some costumes will be mostly hand sewn, but I am trying to find better ways to incorporate electronics into ready-made clothes. 

​This code is supposed to use two Microbits, communicating with radio singles, light neopixels based on their proximity. Right now, this is technically working but will require more fiddling before it is exactly what I want it to be. The signal readings that the brightness respond to are a little in consistent, and I am trying to make the whole thing more smooth.

​For this one, at this point, this is just test code. I was tiring to get the compass to work, and it doesn't work all that well, to fill bars on the MicroBit based on where you are facing when turning in a circle. It didn't work, but after more fiddling, we learned that it is because the Microbit's compass readings are about 30 degrees off in random directions for no apparent reason. We (Kari and I) used an iPhone compass pointing in the same direction as the Microbit, and the Microbit was consistently off. 

On my personal blog, I post weekly updating my progress, click here for the link. 

​

Since early January, Zach Wilson and Lila Finch have been collaborating to think about new ways of communicating with and about science. Zach is a sixth year PhD student in the Molecular, Cellular, and Developmental Biology (MCDB) program and Lila is a second year PhD student in the ATLAS program and a member of the LPC. Zach studies a lipid, called PI(3,5)P2, in the vacuoles of yeast cells. His research is focused on how this lipid controls ion transport at vacuoles to regulate the size, function, and water levels in vacuoles. While his research is performed in yeast, he is currently connecting his discoveries to how plants react to environmental stresses, like high salinity in the soil.

The work together has been about finding new ways to tell the story of Zach's data in ways that have the potential to create new conversations and produce new interactions between the scientist and audience. Through the process of designing and making the artistic representations of the science story, Zach and Lila are examining how knowledge sharing between the two occurs, how it pushes each of them to think about their work in new ways and/or communicate with colleagues, and are curious how the work is used/discussed in different settings (e.g. a scientific poster conference vs. an art gallery vs. a museum space). Below is a little cartoon of the process Zach and Lila went through to arrive at a new representation.

Zach and Lila decided the representational form should be lanterns with which the audience could interact with to make discoveries on their own, whether Zach was there to explain or not. They wanted to have the representations be based in data collected by Zach, so that he could tell the same story he normally does, but in the hopes that the audience would lead themselves through that story by asking him questions. They decided to place a viewing hole in each lantern where a viewer could peer inside of the lantern to get a feel for the types of data that Zach sees and draw conclusions about the relationships between the lights and size; almost being able to explore the correlations Zach has found, without necessarily knowing the meaning. Zach and Lila wanted the lanterns to be able to be used in different contexts, for a scientific presentation or in an art gallery or museum space - where without the context that these are wild type and mutant yeast cells, a viewer could still spend time imagining a story this representation tells.

After deciding on lanterns as the representational form to try out, Lila and Zach have been constructing lanterns that are based in the data Zach has collected for his dissertation. To begin they wanted to make one lantern showing a cell with a vacuole inside that would be able to expand and contract based on different conditions or show different mutant variations. However, because they also wanted the audience to be able to see inside the cell and for there to be multiple cells for more audience members to interact with, they settled on the idea to create one lantern for every mutant Zach has found important to his story, and wild type cells under different conditions. Because the initial idea was to have the lantern expand they settled on latex as the medium to cover the lanterns. Here are some images of a first trial lantern and the process.

Both Zach and Lila felt the latex did not provide any additional purpose besides feeling a bit like skin and did not hold together well, so they decided to instead cover the lanterns in paper, a medium Lila is more familiar with. Below are images of the next trial with paper which they decided was better. The images are from two almost complete lanterns.

These lanterns represent several aspects of Zach's data - including cell size (external size), vacuole size (internal object size), vacuole numbers (nubs on internal structure), lipid number (orange lights), potassium levels in the cell (blue lights), and growth rate (speed of movement of white lights). Each lantern uses a micro:bit to drive the lights. The video below shows the lanterns in a little more detail and the movement of white light indicating growth rate.

Not only do these two lanterns in the video still need to be painted on the outside, when complete there should be a total of 10 lanterns. Only eight more to go!