Here I made a small device with the makey makey that functions as a module to teach users about consent. PERFECT for Haven courses that incoming freshman must take as a requirement, now in addition to sending students the last lecture book, students will also be sent a consent module package.

I also thought about how this little module might be used to keep people who want to diet away from junk food. They can place a chocolate bar or cookie inside a box and put it under these guys.

The only downside to this is you need to wear something on your wrist to close the circuit. I would have preferred to have a way to have this happen without the thing that goes on the wrist, but that’s okay. Maybe one day.

I wanted to make unnecessary tweaks to an everyday object that would record and post something banal about its use. I came up with many many ideas (a motion detector for a book so that a tweet would be produced for every page turned, a motion detector for eye glasses that would post an instagram picture every time you blinked, a pressure detector for a shoe that would tweet every 100 steps). The concept behind this piece would be to (perhaps pedantically) point out the banality/self-centrist nature of posts on our social media as well as the hilarious frivolity of the internet of things, taken to an extreme. At this point, such statements are almost cliché, I realize, but I wanted to do it anyway.

I finally settled on creating a coaster that would make a facebook post every time a user picked up their drink. The post would document the place and time as well as an optimistic health-related message about staying hydrated.

Update (Nov 29, 2016)

I (cambu) continued to work on this project with another classmate, Lucas Ochoa, in Environments Design Studio/Lab (51-265/7). See the below video for an iterated version of the project. The entire demo is working except the environmental controls (fan & projector screen). Guodu and I (cambu) will be moving forward from this second iteration for our final project. See the process blog posts for the other course at the below links (password: Environments).

• e1.a2.c1
• e1.a2.gm
• e1.a2.u1

---

For our (guodu + cambu) project, we prototyped various examples of tangible media interactions for computer input. We began our project buzzing with inspiration from Hiroshii Ishii’s lecture on Radical Atoms, intrigued to play with some basic ideas from the domain of tangible media. Our early ideas were focused around the notion of creating a flip-based “cubular” interaction that would allow the traversal of linear or 2D dimensional information spaces.

Process

System Diagram

Code (github)

Note: there seems to be issues with the xml file getting messed up by the wordpress code embedder plugin, please look at the code on github to see it correctly.

   
    App Switch Right
    private.ssr
    

    __KeyToKey__
    KeyCode::CURSOR_RIGHT,    
    KeyCode::TAB, ModifierFlag::COMMAND_L

    
    

    __KeyToKey__
    KeyCode::TAB, ModifierFlag::COMMAND_L,                                                      
    KeyCode::CURSOR_RIGHT

    
    
    
    App Switch Left
    private.ssl
    

    __KeyToKey__
    KeyCode::CURSOR_LEFT,    
    KeyCode::TAB, ModifierFlag::COMMAND_L,ModifierFlag::SHIFT_L

    
    

    __KeyToKey__
    KeyCode::TAB, ModifierFlag::COMMAND_L,ModifierFlag::SHIFT_L,                                                     
    KeyCode::CURSOR_LEFT

    
  

  sn34kb0t

sn34kb0t starts sneaking every time someone in the area posts a tweet. It traverses stealthily over flat terrain using two dc motors and 2 servos, and communicates with ifttt.com through a cloudbit.

At first, the concept we were going for was to create a terminally depressed robot that would disconnect itself from its power source after seeing lots of negative tweets (via ifttt.com and cloudbit). Although this was a very viable direction that we could have kept going with, we decided that littleBits weren’t the right medium for the message (too many lights, spotty connection, poor movement options, etc.).

Instead, we put a shoebox over the robot.

Schematics

IFTTT applet

         

 

sn34kBot in Action

 

Screaming Monster Alarm

Okay, yes. This project was done fairly last minute, while I had no creative ideas, and it depends on the use of a CloudBit, which I didn’t have. So, all in all, I wouldn’t really call it a success.
Still, here is a little video I made showing my Baby Monster in action:

Basically, the screaming monster alarm is an alarm clock that is active between 8:00 and 8:30 (that’s the networked part) and will scream unless it sees motion with its motion sensors. I thought it would be good because it would stop me from accidentally falling back asleep after turning it off. I made the tube to cover it so it wouldn’t pick up miscellaneous other motion, like that of my roommate, because the sensor it very sensitive. I like how you can make it be quiet by covering its mouth (it was that covering action that gave me the idea to make the tube into a creature). But in retrospect, it’s really not much different from a regular alarm clock.

I got the sensor/buzzer part working, but I couldn’t actually get the timed aspect to work because, as I mentioned above, I didn’t really have access to a CloudBit and didn’t want to wait around for one for the sake of this project. I did create some events on “If This Then That” that WOULD activate and deactivate the cloud bit at 8:00 and 8:30 respectively, if I had one.

I have very few sketches for this project and no code to embed, due to all of the reasons above. Not my best work, but I’m glad I learned about “If This Then That,” and its always fun to play with Little Bits. Had networking our object not been part of the assignment, I would have loved to experiment with the Makey Makey. That device was definetely the my favorite thing from this last week.

Drunken Nightlight
The Party Animals Awaken

If there’s one thing we learned from this, it’s that Keali and Kadoin are not meant for hardware.
Our plan was to make a nightlight that would activate based on the sunset time of a certain location, which would be done with the CloudBit and IFTTT’s weather applet options. This was a simple though practical idea, which meant the rest of the project became geared towards craft and the actual construction of the nightlight, which went through multiple iterations: we had rotating carousel ideas, light boxes, and planetarium-like sketches planned, but the actual reality was a more complicated process of how to get something to stand still and rotate smoothly, all the while having the littlebits stay connected and be distributed properly so that the lights would work within the tube. We went through multiple construction tests with papers, tissue papers, cardboard, clay, and finally made a platform by 3D-printing it (shoutout to John’s help), and finalized an unfortunately wonky design of a tall tube with knifed out designs that swings unevenly and tilts because Keali forgot that physics was a thing when he cut all of the landscape outlines on one side which consequently caused the entire structure to bend over (and much more so when it spins). A boxed structure was a base that contained the motor bit and set it to stand upright, while the splitter bit directed the rest of the RGB and LED lights up into the tube; clay animals were tied with string and hung from the top base of the tube. But all horror aside a final product was successfully completed (though the refinement itself is… not much a success), and we have ourselves a rotating drunken nightlight that activates once the sun sets, and halts at sunrise. We miss D3…

Claire and I made a trampoline that can dial any phone number, input as numbers corresponding to jumps by a user. The trampoline essentially functions as a keyboard to type the numbers for you. Phones are often used absentmindedly, we may feel tethered to them to stay connected, and we often lead sedentary lives sitting at laptops all day. So, here comes TrampolineDial, breaking up the monotony, and turning phone calls into an active, fun interaction!

We wrote the code using Arduino. When a user jumps, the Little Bits act as a cursor, typing in numbers that create the phone number. Apparently if we used Java.robot we could automate the calling, so that the call would be placed once the 10 digits were generated by the jumps.

Here’s the diagram:

Here’s a video of TrampDial in action! :

For our Networked Object, we decided to make one of Lumar’s long-desired ideas, a bubble wrap dispenser, under the assumption that everybody finds popping bubble wrap useful to relieve nervous energy. We improved upon it by installing a roll trigger, and every time a piece of bubble wrap is pulled out, the trigger is pulled, and the connected CloudBit activates the IFTTT Applet that posts to the slack channel called “#stresspopper (you should all subscribe). Now everybody can feel your pain!

Diagram of the StressPopper. The power source is connected to a roll trigger, which it triggered every time a piece of bubble wrap is pulled out. The trigger is connected to a CloudBit, which activates the IFTTT Applet that posts to the #stresspopper Slack channel

We used a ceramic flower pot to house the bubble wrap, and we laser cut a top with a slit for the bubble wrap to come out of. We had to do several iterations of the top, as the first tops we made broke. We also had to figure out how to fold the bubble wrap so that pulling one piece brings the next piece out of the slit (like Kleenex), and used a little bit of rubber cement between each piece to aid in this process.

Our original idea was to create a stress ball with a push button inside, and every time the ball was squeezed, it posted to the Slack channel, but the balloons we were using kept tearing, and we were worried about the Little Bits getting crushed.

 

IoT – Umbrella

Physical Object Documentation:

If This Then That Documentation:

Diagram:

For our project, we were drawn to the idea of using the internet and the Little Bits to establish a connection between 2 people. We thought a lot about how we could use the little bits we had (mostly lights, buttons, and a speaker), to establish a relationship between different places. In the end we decided to use the sound of rain. When people are living apart from each other in different places, it’s often hard to feel connected because you do not experience things together anymore. The final idea we decided on was a set of 2 umbrellas, each of which uses a cloud bit to connect to If This Then That. Each umbrella would be set to the place where the opposite person is, so when the opposite person is experiencing rain, you will hear the rain too. Sometimes it only take a little to help establish a greater feeling of intimacy, and our project was an attempt to do so. For the umbrella, we connected a wall charger power bit to a cloud bit and an input speaker bit and an mp3 player. We then connected the cloud bit to IFTT and created an applet with Weather.com that would let you set a location. If the status of the location changes to “rain,” IFTT sends a signal to the cloud bit, and the speaker will start playing the music from the mp3 player. Optimally we would have wanted something small like an Ipod Nano or Shuffle, but had to make do with a phone. Originally we also wanted to use a battery for the power supply, but the p1 battery power didn’t work with the cloud bit, which then wouldn’t connect to IFTT. We ended up using the wall charger bit and running the strip along the edge of the wall.

The Toilet Paper Printer

The Toilet Paper Printer plots data in realtime on a roll of toilet paper. It can accept data such as a simple sine wave, amplitude of noises in its surroundings, or even any data curled from the internet. Its circuit mainly consists of three littlebit DC motors and a cloudbit, while the entire structure is built with cardboard boxes, straws, and toothpicks.

Video

Inspiration

I like plotters. As a kid I enjoyed ripping off the top of a printer while its printing and peaking into the machine as it worked. So when I saw all the motors we’ve got, I suggested that we can make our own plotter/printer thing.

The Print Head

We spent most of our time figuring out how to make a print head that actually works.

At first we tried to make a conveyer-belt-like mechanism to move the pen. That didn’t work because little bits motors couldn’t their change direction of rotation in real time. So I designed a logic circuit which splits the analog input to control the motors separately. This didn’t work either, because the axles are locked even when the motors are not activated.

I came up with the idea of a gear and a rack when I suddenly realized that the wavy layer in cardboards could serve perfectly as the teeth of the gears. We made both the gear and the rack out of peeled cardboard, and powered the gear with the only motor that can rotate both ways. It worked.

There is rail at the bottom of the print head, so it could slide smoothly left and right.

The Paper Feeder

We had a couple of ideas how this could look like. One is that the printer should have wheels like cars and drives back and fro on the paper. Later we decided to print onto a motor-driven toilet paper, because it’s both easy to implement, and interesting as a concept.

We made two gears, rotating in opposite directions, fixed very close to each other. Thus the paper which is placed in between them gets driven out.

 

Littlebits Circuit

 

The Software

We used cloud bits to receive data from the computer over wifi. Basically a processing program gets input from the microphone, writes it real time into a text file, which is then read in real time by an AppleScript script, which uses shell commands to communicate with the cloud bit API.

Code

Processing:

import processing.sound.*;
Amplitude amp;
AudioIn in;

void setup() {
  size(640, 360);
  background(255);
    
  amp = new Amplitude(this);
  in = new AudioIn(this, 0);
  in.start();
  amp.input(in);
}      

void draw() {
  background(255);
  float aa = min(0.99,amp.analyze()*10);
  //println(aa);
  line(0,aa*height,width,aa*height);
  saveStrings("audioin.txt", new String[]{""+aa});
}

AppleScript:

set p to "/Users/lingdonghuang/Documents/Processing/audioin/audioin.txt"
set f to 0
set lf to 0
set i to 0
try
	repeat
		delay 0.2
		try
			set f to (read p) * 100
		end try
		set d to (f - lf) * 0.4 + 50
		if d > 80 then
			set d to 80
		else if d < 20 then
			set d to 20
		end if
		set d to d - 3
		set a to do shell script "curl \"https://api-http.littlebitscloud.cc/v2/devices/243c201dc4f7/output\" -X POST -H \"Authorization: b97ba2fe26cdb3de50b2ead1c2838e0c13e244f0d628a0c5a20a8ca3d6d358ab\" -H \"Content-type: application/json\" -d '{ \"percent\": " & d & ", \"duration_ms\": " & -1 & " }'"
		set lf to f
		log {d}
	end repeat
on error
	log ("STOP!")
	set a to do shell script "curl \"https://api-http.littlebitscloud.cc/v2/devices/243c201dc4f7/output\" -X POST -H \"Authorization: b97ba2fe26cdb3de50b2ead1c2838e0c13e244f0d628a0c5a20a8ca3d6d358ab\" -H \"Content-type: application/json\" -d '{ \"percent\": " & 50 & ", \"duration_ms\": " & -1 & " }'"
	
end try

The Box

Made of laser-cut white and frosted plastic.

Reflections

Little bits sucks. They might sound like a nice idea, but when you actually want to make something with them, they only “kinda works”. They make you want to trample on them and fling them out of the window. But in general we’re quite satisfied with what we’re able to achieve.

I enjoyed the process of struggling with the littlebits and the cardboards-and-straws mechanisms we had. Instead of being able to make whatever I want like coding in Processing or Python, we had to constantly take into consideration the flakiness of little bits and the straws, and challenge ourselves into coming up with more and more robust and reliable solutions.

The thing that excites me most is being able to make a working printer entirely out of trash. In the future I can probably improve the hardware and software so that it will be able to write letters and even make drawings. I’m going to publish the recipe so even beggars can own printers.

 

CHOCO BOXO

For my physical computing project I decided to create a little box to protect my chocolates from warm weather. Once the environmental (outdoor) temperature reaches 65 degrees Fahrenheit or greater, the fans kick in until the temperature drops back below 65. Who wants melted chocolate during the summer? This will keep them nice and cool, but not hardened like putting them in a fridge would.

Using the littleBits was rather simple, as Golan described. Setting up my cloudBit was a no-brainer and linking it with IFTTT was also extremely simple. Wiring up my box also did not take too much time but the connections are a bit unreliable, due to their magnetic nature. Unfortunately if the box is jolted and the cloudBit loses power, it takes 15 seconds to reboot, and will not start the fans back up if they were already on before the “power outage.” This is because on start, the cloudBit awaits a trigger from IFTTT, which wont send a new “turn on fan” one until it goes above, then back below 65 degrees.

This project was created using littleBits and a cloudBit, as well as IFTTT. Here are the recipes:

And the diagram of the bits: