Tigop Object

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.

aliot-object

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.

guodu-cambu-object

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).


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.

processsketching

Process

lprocess09

System Diagram

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

    
  

Xastol – Drewch – Object

  sn34kb0t

_dsc6918

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.

_dsc6915

Schematics

schematics

IFTTT applet

sneak_bot_iftt2          sneak_bot_iftt1

sneak_bot_twitter

 

sn34kBot in Action

 

Jaqaur – Object

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.

Keali-Kadoin-Object

Drunken Nightlight
The Party Animals Awaken

nightlight

https://www.youtube.com/watch?v=lxGlkdMtN5Q&feature=youtu.be

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…

sunset

sunrise

sunrise

sunset

15145047_1372767432838965_483078566_o

Anson/Claker-NetworkedObject

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.

unnamed

2nd_class_lever

Here’s the diagram:

trampoline_diagram_new1

Here’s a video of TrampDial in action! :

kander + lumar – object

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!

img_1791
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.

img_1782

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.

img_1779 img_1778 img_1776

 

Catlu – Arialy – Object

IoT – Umbrella

https://vimeo.com/192148854

Physical Object Documentation:

dsc02195 dsc02209 dsc02210

If This Then That Documentation:

screen-shot-2016-11-18-at-12-05-44-pm screen-shot-2016-11-18-at-12-09-59-pm screen-shot-2016-11-18-at-12-10-45-pm screen-shot-2016-11-18-at-12-12-09-pm

Diagram:

file_000

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.

Antar-Krawleb-object

 

https://soundcloud.com/dyswis-ksc/somenoisesandstuffmade-with-little-bits

A compilation of some of our experimenting throughout the week. This includes playing with the sequencer, place two oscillators one after another, and also our generative melodies.

15133895_10211257399339855_446231032_o

This is the view from Audition, from when we were mixing our soundcloud track together.

15139327_10211257399539860_552601983_n This is the visualizer that we used to help our debugging process. The top bar being the melody, and the bottom being the base line.

Here are some of the little bit arrangements we used.

15086907_10154217151249538_1150515672_n

15129774_10154217151429538_927754563_n15151372_10154217151574538_1637099477_n

This is our computer which is connected to the mp3 piece. The music is then manipulated through a filter and a delay, then played out the speaker which is connect to a splitter. One branch of the splitter goes to the headphones, and the other to the microphone, which is also attached to the computer. The tracks were first recorded with Audacity, then mixed with Audition. fullsizerender-1

Little Bits pieces

  • power
  • oscillator
  • mp3 out
  • midi in/out
  • synth speaker
  • filter
  • delay
  • envelope
  • keyboard
  • pulse
  • noise
  • sequencer

Initial Concept
We both immediately got excited over the Korg synth Little Bits pieces, and knew that we wanted to see how far we could push the affordances of the hardware. At the beginning we thought of only creating music collaboratively, one on the keyboard piece, and one manipulating the sound through playing with cutoffs, feedback loops, and attacks/delays. Our first instinct was to work with Makey Makey to use IFTTT. The general idea was to have a jamsesh and when we fell into a rhythm that we liked, we would hit the Makey Makey to begin recording, then hit it again to stop recording and to upload the track to Soundcloud. However, after some investigation, we realized the limitations of IFTTT and that we would rather spend time trying to learn new ways to create music, rather than to dwell over uploading issues.

2nd Iteration
Deciding to focus on the music, we discovered the mp3 Little Bits piece. This piece allowed create music through p5js, which we could then modify and manipulate the way we had been for the music generated with the Little Bits pieces. Our concept was that we could have a stream of melodies being generated through our program, and we could have a collaborative jamsesh between the coded music, and our own improvisations on the little bits pieces. After some brainstorming, we came up with an idea to translate strings, possibly scraped from places like Twitter or NYTimes, into melodies, but in a very meta way. The program would translate any letter from A-G into their corresponding note, if the character was not one of those letters, it would simply hold the previous note, or rest. If given a string such as “a ce melody“, our program would translate it into AAAACEEEEEEDD. This required us to also to lean about the p5 sound library, and also create our own scale using an array of midi numbers.

We wanted our music to have some depth so we figured we could also generate a baseline. If we were using the content of the article or the tweet as the melody, then the username or author’s name could be used for the baseline. This was when we had the pleasure of learning about Euclidean rhythms (Godfried Toussaint). Given two numbers, the algorithm can create a beat made by evenly distributing the smaller number into the larger number. Some of these patterns can be found in traditional music, such as E(3,8). “In Cuba it goes by the name of the tresillo and in the USA is often called the Habanera rhythm” [Toussaint]. We would then use the mp3 Little Bit to bring in the melody, and use the midi Little Bit for the baseline, which would enable us to manipulate the two pieces differently.

antarkrawleb

Unfortunately, because the melody was following patterns within the string, it wasn’t really following any rhythmic time at all. This made it difficult to align it to any baseline. Though we thoroughly enjoyed coding and learning about euclidean rhythms, we ended up not using this algorithm.

3rd Iteration
Once we had finalized our melody code, we began to set up all of our pieces. We connected Krawleb’s computer with an aux cord to the mp3 little bits piece, to play our coded melodies into the little bit. We then attached a filter and a delay to the mp3 and connect them to the speaker. We used a splitter connected to the speaker, with one branch connected to a microphone that recorded into Antar’s computer, and the other branch connected to headphones. We were really excited to start manipulating the melodies and adding in our own improvised music, but we quickly discovered the limitations of the Little Bits. Unfortunately, the audio would have these sharp clips, that sounded like the speaker was blowing out. At first we thought one of the bits was broken, but after testing each piece individually, we realized that it was not a single piece that was causing this, but rather the quantity. When we added a 10th piece to our path, no matter which piece it was, we would have this error. Unfortunately to be able to do any sort of collaboration with our generative melody, we would need to have at least 10 pieces connected. We decided to then simply record our manipulated melody, then, separately, record us creating our own music.

Through the project we felt some other limitations of the Little Bits, such as overheating, weak power, sound compression, and a fatality (a delay blew out). We spent a ton of time making really interesting music, but failed to record most of it. In retrospect, we should have began recording earlier, and much more frequently, so as to have a larger library to mix with. We should have also incorporated a simple networked component.

Ngdon-Darca-Object

The Toilet Paper Printer

wechatimg5

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

plotterv

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.

wechatimg3

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.

wechatimg1

ezgif-com-optimize

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.

wechatimg2

 

Littlebits Circuit

snip20161117_15

 

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.

snip20161118_18

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.

img_4729

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.

 

img_4711

hizlik-object

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:

recipes

And the diagram of the bits:

screen-shot-2016-11-15-at-10-21-09-am