I wasn’t initially sure what sort of object I wanted to make with the unrolling method, although I as fairly sure I wanted to use the triangles method of construction. I really enjoyed the semi-chaotic behavior of the simplification functions when used on rounded objects. Because of this, the first object I modeled was a simple sphere.

I decided to push the boundaries of the simplified weirdness with more rounded surfaces. My next experiment involved a series of lantern like shapes, again simplified.

Then, unrolled:

Pretty interesting! A lot more predictable than the sphere, but I also like how predictable it is. You can pretty much tell how to assemble the object just by looking at it.

Continuing in the vein of more predictable unfolding, I made a model of a lantern which would unfold well, this time without using the simplification functions. This time I used primarily Loft to connect a series of octagons.

And then unfolded:

Pretty cool, but it doesn’t seem like this model would do well when assembled; the long thin exterior pieces would likely collapse.

I decided I would like to make a lantern like structure, a little shorter than the previous one, without using the simplification functions, or lofting. This is what I came up with.

After unrolling (and resolving some weirdness):

At this point I used the provided grasshopper functions to make tabs and dotted lines for each piece. This required some further manipulation of the pieces to prevent tab overlap.

The final product:

After laser cutting all the pieces, I assembled them, which was surprisingly easy. The final product ended up looking pretty decent too!

Part C: Modeling

My first thought for a small object was a bottle opener that would fit on a keychain, as mine broke a couple weeks ago. After modeling, I’m not completely sure that the 3D printer material would be strong enough to open a bottle – but whatever. I used image trace to get proper proportions from a picture.

The next two models are designed for a similar purpose. A friend of mine has been having some turmoil in their DnD game based around suspected cheating on dice rolls. To solve this, I designed a dice rolling cup, which doesn’t allow the roller to see the the roll. I also modeled some dice to go along with it.

I couldn’t figure out how to round the corners of the dice in Rhino without creating an unclosed object, although I’m sure there is a way.

I was not able to print my modeled objects due to time constraints and general weirdness with the 3D printers.

I made a simple game controlled by potentiometers using p5 for this lab. The general idea of the game is based on targeting a circle, which has a random location. 2 potentiometers control the x and y coordinates of the crosshairs. Any button press on the computer “shoots” at the target. If the target is missed, a score count is incremented, 3 seconds are added, and the target moves to a new random location. Every time the target is shot successfully, it is slightly smaller when it is moved. Two LEDs and a speaker are triggered by serial output from p5. After a shot, if it is successful, the green LED flashes and a high tone is played. In the event of a missed shot, a low tone plays, and the yellow LED flashes. The circuit diagram for the arduino can be seen below.

None of the circuitry is particularly complex.

The Arduino side of this game essentially reads values from the potentiometers, sends them to p5, then sends outputs to the speaker and LEDs if p5 sends values back. Values from the potentiometers are mapped, then serial printed together as a string, with a comma separating them (for parsing reasons). After these values are interpreted by p5, p5 may send a value back, in this case a 10 or 100. If one of these values is sent, depending on the value, different values are sent to the LEDs and the speaker.

The full arduino code can be seen below.

In p5, for setup I create a canvas, and establish global variables. I then generate a circle of size 30 at a random location. This will be the first target. After this, the draw function runs. The draw function prints the current score, and the location of the crosshairs, based on data parsed from the serial monitor (using the serialEvent function). It also handles the timer, which uses the frameCount function to keep a regular clock.

If a key is pressed, the keyPressed function runs. This function generates a range of values around the center of the target circle, which are then used to determine whether the target has been hit. If not, “10” is printed to the serial monitor. If so, “100” is printed instead, 3 seconds are added to the clock, and the target is moved to a new random location. The new target will be slightly smaller, because the radius variable is decremented with every hit.

The full code can be seen below. I did not any of the given files except for the one show below.

Since filming the screen and the Arduino at the same time proved difficult, I filmed each individually as well as together.

Hiroshi Ishii is, in his own words, “battling against the pixel empire”. To Hiroshi, pixels are a poor way of depicting digital information, and an even worse method of interaction with that information. Ishii’s revolutionary thoughts on the way that computer interactions should occur were first presented in a paper called “Tangible Bits”. This paper described an alternative to pixels by structuring computer interactions in intuitive settings, designed to make background data manipulation physical, and thus more readily understood by the user. An example of is Ishii’s “TransBoard”, a white board with a set of specially tagged markers, which connect physical interaction between the markers and the board to a digital canvas. TransBoard is a one way interaction in that information flows only one way, from physical to digital. Since then, Ishii has widened the scope of tangible interfaces, sending and receiving to all of the senses. 

Ishii’s second revolutionary paper, “Radical Atoms”, sought to make tangible interfaces dynamic by augmenting with kinetic and actionable elements. His projects following Radical Atoms undergo physical transformations in the process of human interactions. The most famous of these is TransForm, a system of hundreds of small square pegs which are motorized, and together form structures which move and evolve in response to user interaction. I was stunned by example in which a user manipulated a ball on the TransForm board by simply moving their hands under a camera. TransForm is a fantastic example of the concept of Radical Atoms, because the physical surface responds to the user. 

Several of Hiroshi’s projects struck me. The first of these is an earlier project og his PingPongPlus. PingPongPlus is an augmented ping pong table that aims to augment athletic activity by providing sound and visual reactions to game actions. In this case, whenever a ball hit the table, an array of microphones under the table triangulated of impact, and a water ripple animation was played at that location. In addition to this, sounds were played whenever a ball hit the net or a point was scored on a player. It is notable to mention that this project was implemented before Radical Atoms was written, and so does not involve any digital kinetic interactions. 

Most of Ishii’s project involve sensors which interpret physical data into a digital output, but one of them doesn’t even involve any electronics in it’s implementation. This project, called “Transformative Appetite”, consists of flat pasta designed specifically so that it assumes a certain geometric form when cooked. This is possible through the use of a special 3D printer which prints with common pasta materials, such as cellulose and starch. Although this project is very different from most of Ishii’s projects, its relationships to Tangible Bits and Radical Atoms are clear; digital models become physical things which respond to stimuli.

Part 1: Variable Input and Output

The first part of this lab required controlling two LEDs with PWM digital pins based on analog input. The analog input consisted of a photo-resistor and a potentiometer. This input was mapped from both the read ranges to 0-255 to outputs for LEDs. The code used to do this can be seen below.

This circuit required adding a resistor in order to read output from the photo-resistor. Everything else was fairly self explanatory. A diagram can be seen below.

After assembling the circuits on the breadboard, I uploaded the code and connected the arduino. It can be seen working below.

Part 2: Tone Output

The second section of the lab involved controlling a speaker with two photo-resistors, using the arduino tone function. The circuit consisted of a very simple set up, simply reading a value between the two resistors (so both would effect the output), mapping the output to 0-255, and sending it to a speaker using a PWM pin. The circuit diagram can be seen below.

My code for this section involved reading in integer values, mapping them to a float 0-255, and output this to the speaker. The code can be viewed below.

A video of the completed circuit working can be seen below.

Part 3: Laser Cut Sensor Box

For the final portion of this lab, my partner Talia Krause and I decided on two potentiometers, slide and rotary, for our inputs, and two LEDs and a speaker for our outputs. The general idea of our sensor box was to use the slide to control the size of the tonal range of the speaker and the blink speed of the LEDs, and the rotary potentiometer to control the pitch and the brightness of the LEDs.

The circuitry for our box is fairly simple. A diagram is show below.

In order to avoid using a breadboard, we soldered two different breakout boards, one for power and one for ground. One of these can be seen below.

Most of the functions of our box are fairly straight forward analog in/out. The unique part of the code is a pair of functions which resize the speaker’s range. They do this adding a portion of the slide reading to the bottom of the speaker’s range, 100, and subtracting it from the top, at 1000. As the slide moves up, the range widens. The slide also controls the sample rate of new tones and blink of the lights, using it’s output value and the delay function. The complete code can be seen below.

I used makerbox to develop plans for our sensor box, then imported these files to Rhino to add apertures for sensors, LEDs, an speaker grill, and the power chord. The final Rhino file can be seen below.

It slipped my mind to add an aperture for the power chord at this time, so I had to add one later with the drill press.

Before inserting the electronics into the box, I glued all the panels except for the back and top in place with hobby glue reinforced on the insides with hot glue. Then, insterted the electronics and glued the lid down. The back panel will remain unglued, for future trouble shooting purposes.

Part A: Modeling from life

For the first section of Lab #2, I decided to model my water bottle. I chose it because I could mostly envision how it would be best modeled in Rhino, command wise. It turned out to be a bit more complicated than I expected, as things do, but ultimately went fairly smoothly. Images of the actual bottle can be seen below:

In order to model this object, I first uploaded loaded each picture into Rhino. I did this at first with BackGroundBitMap, but this was ultimately no flexible enough to manipulate the pictures, so I ended up using Picture to get everything. I wanted to model around the origin, so my pictures were originally oriented for modeling there.

Next, I traced the exterior curve of the body of the bottle, then revolved it 360 degrees. Later I added another ridge around the threading of the bottle with the same method. To created the lid, I extruded a couple circles, extruded a triangle shaped cutting object, and used it to cut out the ridges in the lid with BooleanDifference. Finally, I created the handle with extrudeCrvAlongCrv. Images of the completed object can be seen below.

Part B: Sliced Model

Based on my experience with slicing last semester, I decided to avoid hollow objects. I wanted to make a bowl, which presented its own set of problems. I made the object initially with polycurve tools, then rotated it, and used cageEdit to stretch the edges of the bowl on two sides.

After modeling, I exported the model as a .stl, and imported it into Slicer. I elected to slice the model vertically, to avoid round hollow pieces for easier nesting. Because of the size of my model, many of the slices ended up being quite thin, so I was able to fit all the pieces on two sheets of 12″x18″ cardboard.

Initially I had some problems laser cutting because I accidentally imported the DXF files with thickness, but after resolving this, cutting went smoothly. I assembled the pieces with a gluestick, which worked well initially, but later had to be re-glued with superglued. The assembled model ended up more compact than the 3D model because of the thickness of the cardboard.

Part C: Companion Models

Since my first item was a bowl, I decided to make some other table setting objects to accompany it. The first object I made was a potted plant, made with revolve functions, cageEdit, loft, and pipe. I was aiming for a sort of cactus.

The second object I made was a martini glass, with olives, made with revolve functions, cageEdit, and extrudeCrvAlongCrv.

Part D: Joinery

For my flat joints, I decided to make key joints. The first of these joins has a compass shaped key, which connect four different sections.

The section of the keyjoints is a right angle with a figure eight shaped key.

My final joint is a finger and tennon joint.

Part 1: Breakout Boards

For part one of this lab, I made two breakout boards. The first of which was a switch, with an input sent to the board after the switch, detecting high or low voltage. For this board, I used the following diagram:

This circuit uses a pulldown resistor to ensure accurate voltage readings.

The second breakout board consists of two LEDs wired in series, as with the first lab. This board will serve as the output from the arduino, controlled by the switch. The diagram can be seen below.

A Note on Soldering:

I stink at soldering. This being said, below are close ups of my soldered nodes on my breakout boards. Look at your own risk.

Part 2: Arduino Implementation

The second second step of this lab required controlling the breakout boards with an arduino, using the switch to control the LEDs. Generally, when the input from the switch is pressed, the lights should turn off, and other wise should be on. This means that the LEDs will be off whenever the output is LOW, and on otherwise.

The arduino code which I used can be found in the repository below.

	int ledPin =2; // choose the pin for the LED
	int inPin = 7; // choose the input pin (for a pushbutton)
	int val = 0; // variable for reading the pin status
	void setup() {
	pinMode(ledPin, OUTPUT); // declare LED as output
	pinMode(inPin, INPUT); // declare pushbutton as input
	}
	void loop(){
	val = digitalRead(inPin); // read input value
	if (val == HIGH) { // check if the input is HIGH (button released)
	digitalWrite(ledPin, LOW); // turn LED OFF
	} else {
	digitalWrite(ledPin, HIGH); // turn LED ON
	}
	}

view raw led.switch.ino hosted with ❤ by GitHub

I sourced this code from an arduino published coding guide. Because this code is so simple, and the resource was posted by arduino themselves, I am assuming that it is acceptable to use for this assignment. If not, please let me know, and I will provide original code.

This code takes input from pin 7, reads it as HIGH or LOW, and based on this reading, decides whether to send power with a simple if statement. After uploading the code, I connected power, and attached the electronics, using a breadboard to ease connections. This can be seen below:

As expected, the LEDs turned on. Finally, I tested the button control, which can be seen functioning in the video below.

After completing the first lab for Form, I can confidently say that Rhino is CONFUSING. That being said, the program is clearly extremely capable and I can see myself doing a lot of cool stuff with it in the future. In order to gain a baseline level understanding of Rhino, this lab was broken up into four segments: curves, planes, 3D objects, and 3D printing.

Part A: Curves

The curves section of lab 1 was fairly easy, as all of the tools behaved as I remembered, and the simple shapes made for easy modeling for the program. Essentially I went through the most prominent curve creation tools and made 2 curves with each tools.

The most significant tools from this section were BackgroundBitMap and PointsOn. BackgroundBitMap has an immense amount of potential, as it enables modeling from actual objects. It also allows the user to import a certain curve from a photo without image tracing. I haven’t yet used an image tracing function in Rhino, but it seems as if it would be easy to trace in Illustrator and then import. PointsOn was significant to me because it reminded me of my favorite part of Illustrator, the direct selection tool, which allows the user to directly edit anchors and lines within a shape. Control points in Rhino seem to be a little less forgiving, however.

Part B: Surfaces

Surfaces are more difficult for me to visualize at this point. The surface tools in Rhino are generally fairly intuitive, except for a select few which are more conceptually complex. Sweep2 and ExtrudeCrvAlongCrv both were difficult to understand. Two iterations of each function can be seen below.

Since ExtrudeCrvAlongCrv was tricky for me at first, I decided to use it for my sketches and alterations, along with Loft, a function I didn’t remember but really liked. My sketches are below. First I sketched the objects from three angles, then sketched a modified version, and finally attempted to model the modified version.

After sketching modified versions, I modeled them to my best ability using Rhino. I think these came out pretty well.

Part C: Surfaces

Solids were the primary focus of the third part of the lab. This lab section consisted of a list of commands, and I made two iterations for each of these commands. These iterations can be seen below.

These methods seemed to me to be a bit more straightforward than part B. The most interesting tools from this part were the Boolean tools, which allow shapes to interact with one another, by adding, subtracting, and splitting one another. I relied upon these tools in the last part of this lab.

Part D: Fabrication

For the last part of the Lab, 3D printing was the focus. Because of this, I decided I wanted to make a simple character figurine to print. I start off with truncated cone, added some extruded oval eyes, another cone for a hat, and suddenly I had a little wizard guy. For my accompanying objects, I made a simple wand from a revolved curve, along with a chest. These objects can be seen below.

I had a few issues with BooleanUnion that pertained to trying to join naked edges, but I eventually resolved these, and made the figure watertight, and ready to print.

This figurine required a lot of supports, as well as a substantial raft. Both of these things ended up being quite difficult to remove.

The next challenge was to remove the raft and supports. This proved difficult, and I had to use more force than I would have liked. Eventually I removed everything I could get too, however, and the figure was finished.

The final segment of this lab was to remodel the printed object, taking into account manufacturing difficulties. I choose to make both arms raised, since the downward facing one required too many supports which were difficult to removed without damaging the subject. I also extended the body cone through the eye area, in order to provide more support for the hat, and negate the need for some of the supports. The remodeled object can be seen below.

Part 1: LEDs in Series and Parallel

The first circuit for this lab consisted of two LEDs in series, with power supplied by a voltage regulator, which transformed 9v to 5v. Each LED had a forward voltage of 2v, and a minimum current of 30 mA. From this I derived a desired resistance of 33.33333 ohms. I choose the next strongest resistor available, which was 50 ohms.

The schematic for my completed circuit is below.

The second circuit involved the same power regulator and LEDs, but this time involved two LEDs run parallel, with a resistor in each parallel piece of the circuit. For this circuit, I calculated an ideal resistance of 100 ohms per resistor.

Below is my diagram of the second circuit, as well as my implementation.

Part 2: DIY Switch

For my custom switch, first I folded copper foil around two patch cables. Next, I cut out a picture frame shaped piece of foam and glued it to one of the cable, as seen below.

Next, I glued the other foil wrapped cable to the other side of the foam. Finally, I cut squares of foam to protect the outsides of the switch from grounding issues and shorts. A diagram of the switch can be seen below.

The idea behind this switch is that when the two sides of the foam are squeezed together, the copper sheets will connect and complete the circuit, making a sort of instantaneous switch. Videos of the switch functioning can be seen in part 3.

Part 3: Creative Enclosure

At first, I planned to make an enclosure for my board out of corrugated cardboard. Given the relative weakness of my fabrication skills though, I soon decided that I would be better served to find a pre made box that would fit my electronics. After trying a few boxes which ended up too big, I finally happened across an empty cigarette package which turned out to be a perfect size. I chose this as the basis for my enclosure.

Since my electronics were very limited in their function, and could really only turn a lightbulb off and on, I decided that I would take advantage of this simplicity to “animate” an illustration. In order to do this I would move the electronics into the enclosure, and place an image on top of the box so that it would be illuminated when the LEDs were switched on.

First, I moved replaced the toggle switch with my custom switch, and tested for errors. After brief troubleshooting, everything worked, and I moved the breadboard into the box. To prevent random malfunctions, I taped several of my leads, and cut holes of the 9V supply. I taped the LEDs to the top of the box. Below is a video of the open enclosure, with functioning electronics.

After making sure everything was functioning and secure, I closed the box, and taped it so it would stay closed. To do this, it was necessary to route the button of the box and back in, as seen above. Below is the closed box, with the illustration attached.

Finally, time for the final test: will the cat’s eyes light up?

They did!