Annie Kelly

Me playing bass and controlling a light show in real-time using cardboard foot pedals to trigger different lighting effects that I programmed ahead of time.
​Song credit: "Swamp Pussy" by Babes in Toyland
​

      Let me start off by telling you what I'm all about. I have a B.S. in Computer Science and also like to play bass guitar and make music in my spare time. Both of these interests are what led me to where I am today— wanting to create better computing technologies for artists and musicians to mess around with. Often times (not always of course) when you go to a venue the sound and the lighting are both being run by white dudes. You may have even heard the phrase "lighting guy" or "sound guy." There is no reason why these technologies and spaces need to be monopolized solely by tech-y white guy, but it has now become ingrained in our culture. In addition, there's no reason that these technologies can't be adapted to be more usable as DIY tools for the performers' themselves. I want to convince more people that they are capable of doing these kinds of things.
​      By adapting and remixing some popular DIY maker technologies, I have built the first iteration of what I hope to be an accessible toolkit for programming light shows and controlling them with custom built tangible interfaces. The micro:bit is commonly discussed as a computer science educational tool for children and adolescents. It is less commonly discussed as a useful tool for adult artists and musicians, and even for seasoned programmers like myself. I love using it. The Raspberry Pi on the other hand has typically been touted as a low-cost computer alternative for everyday use, or a playground for hackers to create all sorts of cool projects. Developing software for the Pi is not a beginner-friendly activity— however in this project I will describe how the Pi can be easily equipped with software to make it a powerful tool for allowing people to interface professional level hardware and more beginner-friendly microcontrollers. In particular, I will focus on stage lighting production tools and hardware.

      In the above diagram you can see that there are a few different components working together to make this all work. The micro:bit writes over serial to the Raspberry Pi, the Pi parses the serial data and wraps it into properly formatted DMX512 commands which are then sent to the Enttec OpenDMX USB interface, which in turn updates the two lighting fixtures. The software I wrote for the Pi relies on the Open Lighting Architecture Python API.
      The entire setup above cost about $200 (Raspberry Pi $40, micro:bit $12, DMX USB interface $70, Stage lights x2 $80). That's obviously not a trivial amount of money, however that is extremely low compared to the cost of some brand name, closed-source hardware, and also removes the cost of paying a lighting engineer to run the rig. For reference, Chauvet's, which is a popular brand for DJ equipment, consoles will set you back a few hundred bucks not including the amount you have to spend on lights as well. 
      With this setup, the user (unless they want to dive deeper into the software on the Pi) only has to program the micro:bit in order to control the lighting. The micro:bit programming editor provides many high-level abstractions for controlling the lights, just as a standard console that you would find in a venue. In the next section I will show an example of how I made three cardboard foot switches that trigger different sequences that I programmed on the micro:bit. ​

      The above image shows the three foot switches I made for this light show (for a tutorial on how to make a pressure activated foot switch for the micro:bit go here.). Each switch can each be activated by stepping on them. The left most switch triggers a pink/yellow chase pattern (connected to pin P0 on the micro:bit), the middle switch triggers the orange scene (connected to pin P1), the right switch triggers the blackout (connected to pin P2). By default the scene is green when I am not stepping on any of the switches. When I say scene I mean a static light setting, for example in a given scene one light might be pink, and the other might be yellow. Different patterns can then be made by combining scenes. A chase pattern is a sequential switching between scenes, and in this example my chase is just the two lights switching back and forth between being pink and yellow (you can see everything I am talking about in the video at the start of this post).

      Now that you know how the switches are connected to the micro:bit, let's look at the above code to see what's going on. When the program starts it first specifies that there are two lights in this setup and that each light has 8 channels. It then sets both lights' channel 3 to 255, which sets the lights master dim to full brightness. If you look inside the forever loop you will notice a series of if statements that check whether or not I am pressing down on any of the foot switches. If I am pressing down on switch 1 (pin P0) the program calls the chase function, if I press down on switch 2 (pin P1) the program calls the orange function, if I press down on switch 3 (pin P2) the program calls the blackout function, and if I am not pressing any of the switches the green function is called. Each of these functions is defined to the right. Let's look inside the green function. You can see a series of "update channel" calls being made.
      light1 update channel 4 to 0
      light1 update channel 5 to 100
      light1 update channel 6 to 0
      light2 update channel 4 to 0
      light2 update channel 5 to 100
      light2 update channel 6 to 0
      send dmx
As I mentioned earlier, each of my lights has 8 channels. However in this example I am only using channels 3-6 on each light. This is because channel 3 corresponds to the master dimming setting, channel 4 is the red setting, channel 5 is the green setting, and channel 6 is the blue setting. These lights use what is called RGB to create a color and each one can be a value between 0-255. For example, if red is 255 and green and blue are both 0 — the light will be red. If we then change blue to be 255, the light will become purple because we are mixing red light with blue light (think back to art class about how color mixing works). So, with that knowledge we can now look at the code example I posted above for the green function and see that it is in fact setting both lights to be green and then calling "send dmx" to officially update the lights.
      Now you can look at the other functions and try to see if you can figure out what is going on. Remember, you can always watch the video again for help.

      As a bassist who doesn't typically use pedals when I play, it is easier for me to use my feet to control lighting as opposed to a guitarist who might have to be switching distortion on and off at the same time that she would want to change the lights. There are other ways we can imagine controlling the lights in real-time. There is the potential to use audio analysis to detect transitions in the songs, entirely pre-programmed light shows that are fully automated, or have a friend in the audience running the lights for her. The nice thing about using a microcontroller is that there are tons of possibilities that are left to the imagination.
      Some of the next steps for this project will be further simplifying the API and providing a better way for users to keep track of which channels on each of their lights corresponds to what setting. In addition, I hope to further automate the software on the Pi so it is as simple as just powering everything on instead of having to ssh into the Pi and start the software manually.
      I am still learning a lot about DMX512 and practical lighting applications, so I'm sure things will change as I continue my research. Keep your eye out for some Raspberry Pi images available for download in the future. Thanks for reading!

Annie Kelly

When we talk about tangible and playful learning, it is often discussed in the context of children. In this workshop I would like to discuss the application of these concepts for amateur and professional artists and musicians. This is part of a project we call Weird Code Club. We are focused on empowering indie artists to incorporate computing practices and interactive technologies into their live acts.
​We will be constructing and programming tangible interfaces that can scrub through a YouTube video. This is an example of VJing (Visual Jockeying) which is a common artistic practice used in live audiovisual performance.

Author using a touch button to seek to a particular point in a music video.

A few examples of constructed tangible controls: slide potentiometer (top left), potentiometer/knob (bottom left), pressure activated button (right). This post will describe the differences between the three and how to go about constructing and programming them using craft materials and a micro:bit.

This is an example of constructing a pressure activated button to seek to 00:58 in a YouTube video.  The button itself is quite simple to construct and a brief step by step process can be found here. Basically, there are two pieces of foil: one is connected to power, and one is connected to a digital data pin. We the pieces of foil are not touching, the reading is 0. When the pieces of foil touch, the reading is 1​. This allows us to use it as a button or a switch.

The below example code demonstrates how to read the state of the button. When it is 1 (i.e. pressed) we seek to 00:58 in the video, otherwise when the button is 0 (i.e. released) we do nothing. However, you might want to use your button differently than this. For example you can program an event to occur when the button is released, or you can have an event occur repeatedly while​ the button is pressed down. 
In this program we are reading the value from digital pin 1, so make sure your button is attached to the same pin that is chosen in the code.

This is an example of constructing a slide potentiometer that controls the playback rate of a YouTube video. Instead of foil like in the button example, here we are using graphite from a pencil as a conductor. This provides a nice level of resistance to get varying readings along the slide potentiometer. In the video below, as I move the green pin away from the red pin at the top, the voltage reading is lower. As I move the pin closer to the top, the voltage reading is higher.

In the example code below note the use of the map function. This is reading the value of our slide potentiometer and transforming it into its corresponding video speed within a certain range. In other words, when the potentiometer is at its lowest point, the video playback will also be set to its lowest speed.

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.