Physical Computing

Intro to Physical Computing
Instructor: Jeffery Feddersen

pComp – Final

For our final, Jesse and I, instead of building a huge 11 x 25 pixel digital clock, we decided to create 5×5 pixel display.

While we now have all the materials to make a larger version, we learned early on that a smaller scale prototype would represent the foundation on which the larger display would be built on. The smaller display was built using the same principals: acrylic rod for pixels, multiplexing of an LED matrix, controlling an array of solenoids. The only thing the small scale model does not possess is controlling a large array of solenoids using the 74HC595 shift register.

Once we had nailed down our idea to creating a display using a matrix of illuminated acrylic rod actuated to create a 3 dimensional effect, we had to create a plan to keep us on track, and make a list of techniques and challenges to overcome.

As we started looking into hardware for the project, we had a pretty clear idea that we would be using transparent acrylic rod (not tube) for the pixels, and that each rod would be drilled for an LED. This really left three unknowns for us to work through: Rod diameter, rod spacing, LED selection. After playing with a few Illustrator sketches to determine spacing we settled on 7/8” W x 2.5” H acrylic rod for each pixel, 10mm ultra bright LEDs for illumination, and 6mm spacing between pixels.

Screen Shot 2015-12-27 at 1.10.52 PM

The next challenge was the actuation hardware and mechanism, this was where we really started to get out in the weeds. We looked at a number of mechanisms for pixel actuation:

  • Gear driven servo actuation
  • Linear actuators
  • Individual solenoids
  • Solenoid on gantry

We eventually settled on individual solenoid actuation because of mechanism simplicity and cost. Using the solenoids would cut out the need for a complex gear assembly, and low voltage solenoids were less expensive than linear actuators across the board.

The first solenoid we used ended up being perfect for our purposes, the JF-0520B. This solenoid uses 5v, possesses .35N of force, features push / pull operation and has a long stroke length (7mm) compared to many solenoids of similar size and voltage. The push / pull operation also ensures that the pixels will not only be pushed out, but also pulled back in as part of the operation. Once we had the solenoid, the next step we took was building a prototype chassis, fixing the solenoid to it and testing the operation. As you can see below, we built this chassis by cutting three acrylic sheets on the laser cutter. Each had holes in the corner for mounting. The first two sheets used large round center holes to house our acrylic pixels. The third sheet used square openings for the solenoids to seat into.

IMG_5262-1

We learned how to wire the solenoid using the schematic linked here and here. Using the labs from class to guide us, we learned that the transistor is used to “allow us to control the flow of a high-current circuit from a low-current source.” Meaning control the solenoid circuit which runs on bench power using our Arduino. The other component we learned about in this circuit was the protection diode (1N4004) to protect from problems caused by any reverse flow of current.

With our mechanism working we felt we had a good proof of concept for moving forward. At this point we set our sights on fabrication, preparing for the eventual scaling of our project.

FullSizeRender-2IMG_6016IMG_6025 IMG_6039-4

After cutting and drilling a whole mess of acrylic rods, it was time to tackle another large technical hurdle we were facing. Multiplexing the LEDs. For those familiar with Arduino boards, you know there are a finite amount of digital pins for addressing LEDs or any other on / off component. In order to essentially expand the number of digital pins you have to drive LEDs you must learn a technique called multiplexing. This technique requires three things:

  • Creating an LED matrix
  • Wiring the chip
  • Using the code

Soldering together an LED matrix is simple enough, essentially you wire all of the anodes into rows, and cathodes into columns — creating a common cathode matrix. The result looks something like this.

IMG_6012-1 IMG_6015-3

You can check if you’re doing it right as you go by touching one of the cathode (+) column leads to the 3.3v out on your Arduino, and one of the anode (-) rows to ground. If you’ve wired the matrix correctly the LED at the intersection of the column and row should light up like this.

Actually wiring the LED matrix to the chip proved to be much more of a challenge than I had originally estimated. For availability and documentation reasons, we chose to use the MAX7219 LED driver chip to multiplex our LEDs. There was a fair amount of documentation on this chip online, a friend of mine and fellow LED matrix enthusiast Gustavo Abbot also had used these in the past, and offered his assistance.

In the end, the chip worked wonderfully. However, there was a fair amount of info that threw us off as well along the way. We began on this Arduino forum which was aimed at explaining how to use this chip, and even included a schematic. We learned however through the MAX7219 product data sheet that there were a few issues with this page. First, the digits and segments were mislabeled in the Arduino forum’s breakdown of the 7219’s pin layout. The second issue was with the wiring schematic to the chip. The schematic includes decoupling capacitors of 10 micro farads and 100 nano farads to suppress noise signals caused by the power supply lines. However, after speaking with Tom Igoe, we learned that all that was required for the circuit was a 100 nano farad decoupling capacitor. Changing this component out made the illumination of our LEDs much more consistent. I have included below an annotated page of the MAX7219 data sheet to show exactly how to wire it to your arduino, as well as the full data sheet here.

Finally, once we had the chip wired up all that was left was the code. Gustavo was a great help here, pointing us towards the pertinent libraries we would have to include in our IDE to get this to work. The libraries you will need in order to multiplex LEDs on your Arduino using the MAX7219 are:

  • Adafruit GFX: Core graphics library for Arduino – must be paired with hardware-specific library
  • Max72xxPanel: Hardware specific library
  • SPI: Allows you to communicate with Serial Peripheral Interface Devices with the Arduino as the master. — Excerpt from Arduino reference

We started here by first going through the libraries and the example sketches that came with them and pulling out the pertinent lines of code to get this working.

What you see above is the code for scrolling 0 – 9 on a 5×5 pixel display. The persistence of vision phenomenon present in LED matrices made hard coding this an interesting learning experience. You couldn’t just call up a digit at once. You have to do a row or column of the digit, use a very short delay, then proceed to the next. Because the mux pulses the LEDs quicker than the eye can tell, rows and columns of the digit are flashing on and off so quickly your eye cannot tell and you brain just perceives a full digit. The wonderful thing about the Max72xxPanel library is it provides ints for you to plug in the number of horizontal and / or vertical multiplexes for easy scaling of LED matrices. As you can see above I have hardcoded the x,y coordinates which make up each number. While I am only using 1 5×5 matrix. If I was using the full extent of the chip (8×8) and had a second horizontal display, writing to the next matrix is as simple as this:

matrix.drawPixel(8, 1); // top right of first matrix

matrix.drawPixel(9, 1); //top left of second matrix

matrix.write();

For the full version, we would like to try a clock display and will be using code adapted from a clock display programmed in p5.js

Screen-Shot-2015-12-16-at-5.35.04-PM-1

The last ‘how it works’ related items I’d like to cover are the solenoid array, and the 5×5 matrix we presented. For this prototype, because of its size, there were enough digital pins for the multiplex, as well as a 15 solenoid array. Therefore, we did not have to address the solenoids using the 74HC595 shift register. When we scale up however, we will have to address the solenoids using shift registers to help us economize on digital pins. — although scaling up will still necessitate multiple Arduinos running a single sketch, syncing them using I2C. While I have not yet been able to address multiple solenoids using a shift register, this forum seems to provide some nice first steps. One consideration we made while creating even the 5×5 was power for the solenoids. By switching them on and off quickly in sequence to create a snake effect tracing out each digit, we only use the voltage and current requirements of one solenoid. If we wanted to actuate multiples at a time, the power requirements would scale by the number of solenoids being actuated.

With respect to the 5×5 we presented in class, one major design change we had to make as we entered our latter prototyping phases was the LED matrix. As you saw above the earlier matrices we created were rigid, created using solid core wire. Because of the actuation of pixels that was going to happen behind the matrix, for the final we had to create a sort of ‘soft matrix’ using stranded cable. The stranded cable allowed for easy actuation of the pixels, but looked a bit messy at the end of things. In the future, we will examine how to create this matrix to be as robust as possible, while also remaining as neat and flexible as we can allow.

IMG_6214

In terms of the scalability of the project, as mentioned above we are already prepared to scale up on the number of pixels physically and technologically, we have already laser cut our second board as well as created the acrylic pixels for it. I plan to spend my time during the break learning to control a larger array of solenoids using the shift register, as well as experiment multiplexing with RGB LEDs as well. In terms of the fabrication challenges associated with adding a large number of solenoids I believe we need to revisit our method of joining the solenoids to the pixels. Currently we are using hot glue as the shielding as well as the method of joining the pixel to the solenoid. In the interest of creating a robust final product, we will need to replace this with some kind of mechanical link I believe.

For me this idea turned into much more than just a final project. I think combining the concepts of building your own displays, challenging what a pixel is, and experimentation with topographies has potential to be something not only very artistic, but also presents interesting opportunities for data visualization / message augmentation. Some of my ideas for future display projects are:

  • Creating mirrors
  • Music / FFT analysis
  • Scrolling brail below text
  • Interactive displays using RGB LEDs

Please stay tuned for further pixel pushers updates. We will be continuing to experiment with expanding this display through the winter — both of us are incredibly excited to see where this goes.

Finally, we’d like to thank Gustavo de Campos Abbot for pointing us in the right direction with the multiplexing work. To see Gustavo’s amazing work, just give the link above a click. We’d also like to thank Tom Igoe for lending some of his time to help us defrag our MAX7219 circuit. You’ve made it this far, please take some time to look through Tom’s work, here. He is one of the fathers of the Arduino and has oh so much knowledge to give.

If there are any questions on the above, please feel free to reach out directly at p.jesse.donaldson@gmail.com or info@marcelanowak.com.

Marcela & Jesse

Now, time for my little photoshoot:

pin_clock-2 pin_clock-3 pin_clock-4 pin_clock-5 pin_clock-6 pin_clock-7 pin_clock-8 pin_clock-9 pin_clock-10 pin_clock-11 pin_clock-12 pin_clock-13 pin_clock-14 pin_clock

Pin Clock

For my final project I paired up with Jesse. After long brainstorm we finally decided on creating a digital pin clock. We were inspired by a pin toy.

IMG_5125

Our first idea was to create a ‘topographic mirror’ image using 3D pin sculpture and some sort of sensors to detect what was in front of the ‘mirror’.  Because of the mechanical intricacies required to move each pin individually, and because of the cost of linear actuators we would probably have to use, we dropped that idea and came up with the clock concept.

IMG_5119

The clock would work similar as a pin toy does. Just for the design we’d need 3 sheets of flat acrylic ( 2 for board, one to attach mechanism) many acrylic rods and multi colored LED lights.

IMG_5127

Two sheets would hold the pins in place, and the third sheet would house the mechanism, which would actuate the pins forward and back to display time. Moreover, we decided on fitting multi-colored LEDs inside the pegs, so that they enhance the visual effect and the clarity of the time display.

We’ve already made our first small prototype, laser cutting wholes in 2 acrylic sheets and cutting few rods to mock up the clock dimensions. We still need to estimate the grid dimensions, the spacing between holes and the amount of holes in each row.

IMG_5123 IMG_5122 IMG_5121 IMG_5120 IMG_5118 IMG_5117 IMG_5116

Our next step will be to decide how big the grid should be, we’ll have to determine peg spacing between holes.

Here’s how our initial schedule looks like:

WEEK 1:

  • finalize our concept;
  • prototype chassis;
  • determine peg spacing;
  • determine amounts of pegs;
  • research solenoids;
  • get them to work;
  • determine power needs;
  • work with the code;

WEEK 2:

  • work withe the code;
  • work with the code ( LEDs part only);
  • order rest of materials;
  • finalize the sizing;

WEEK 3:

  • cutting the rods;
  • fabrications;
  • preparing to assemble;
  • coding – tests with servos;

WEEK 4:

  • debugging,
  • fabrications;
  • etc.

WEEK 5:

  • final assembly,
  • preparing presentation

Hopefully, everything’s gonna work well and we end up having a new, gorgeous clock for ITP.

‘Dandi’ – pComp Midterm Project

Firstly, my Partner Anne and I considered making a physical object – a box of grass that moved as if being blown by the wind when people walked past. Then, after a brainstorm we both agreed to move the project to the screen.

It was a challenging task in terms of programming. That was the first time I had to use particle system.

I started with drawing a dandelion piece in Adobe Illustrator and saving it as a svg file. Then, I tried to loop it in few circles, just to create dandelion shape.

DANDIThen, after consultation with Moon, we decided to form dandelion pieces in one spiral.Screen Shot 2015-11-04 at 1.48.27 PM Screen Shot 2015-11-04 at 1.47.41 PM

While I was working on design and programming, Anne figured out a lot about the sensors.

At first, we purchased a PIR motion sensor, but it turned out to be way to sensitive. Then, we discovered the Distance Measuring Sensor which seemed perfect for our task, though we did not need to measure distance, because we were able to adjust the level of sensitivity.

She did a great job by getting sensors to work.

Also, I laser cut and etched the lid for our ‘sensor box’.

IMG_4838 IMG_4846

Finally, we connected both out works, and ended up with a beautiful final effect.

Screen Shot 2015-11-04 at 2.06.20 PM

DANDI – pComp midterm (Draft post)

For midterm project, I was paired with Anne Goodfriend.

Screen Shot 2015-10-29 at 3.22.08 AM

We called our project ‘Dandi’. The idea was to show Dandelion blown by wind, created by person, that passes 2 motion sensors.

IMG_4846 2

Laser etched dandelions on a box

The order of on which sensor was triggered first, indicated the directions, the dandelion pieces were blown.

IMG_4866 2 IMG_4847 2

IMG_4840

I have no idea why this video loads upside down….

Lullaby

This week I wanted to experiment with light sensor and piezo. I really don’t like to sleep, so I decided to make myself a toy, which could motivate me to go to sleep earlier.

I laser cut the front of the building, so that we could see the light in the apartments.

IMG_4454-3 IMG_4455-4

Then, I drilled a hole on the top, to place a light sensor inside.

IMG_4562

Finally, I wrote a lullaby, connected piezo and LED lights and installed everything inside.

IMG_4559 IMG_4560 IMG_4561 IMG_4564

IMG_4569

Screen Shot 2015-10-07 at 11.27.29 PM

Rocking horse!

I’m a horseback rider, so what I miss the most while being in NYC are horses. After taking a walk to the Central Park (just to share an apple with one) , I felt inspired to make my next pComp project.

My own goal for this week was to play around with servo and potentiometer. Unfortunately, (or fortunately) I bought a Continous Rotation Servo instead of a standard one, so I’ve been struggling how to use it so that it won’t rotate 360°.

Anyway, as a kid, I always dreamed of having a rocking horse, but I never had one, so now I decided to change that !

Laser cutting it seemed to be pretty smart idea, so I drew one in Illustrator and uploaded to the machine.

Voila! Here they are!

So, the general idea of my project was to move a rocking horse using servo, controlled by potentiometer. Because of the fact that I purchased the wrong servo, I decided to use the potentiometer to turn the LED on and off.

It did’t went exactly the way I wanted, but I achieved my goal anyway. Now, I understand how a servo and a potentiometer work like! Let the game begin!

servo1

sketch_schem

Screen Shot 2015-10-01 at 3.54.19 AM

And here’s how my project looked like:

IMG_4403

IMG_4404

Making a stand

IMG_4405 3 IMG_4406

IMG_4409 2 IMG_4410 2 IMG_4411 2 IMG_4415-1 2

IMG_4414-1 2 IMG_4413 2 IMG_4412 2 IMG_4414-1 2 IMG_4413 2

And finally, the video:

PS. Thank you Emmanuel for holding my Servo! 😀

Food Guard

For our third assignment, we were supposed to come up with a simple application using digital or analog input and digital output.

I really wanted to explore force sensitive resistor, so I decided to build a funny ‘Food Guard’ project.

I wanted to create a 2-layered ‘plate’ for the food. I laser cut two equal squares, then carved a circle, on which I planned to put my food.

Then, I started with a simple version of the project, which was supposed to turn the LED light off every time someone takes the apple from the plate.

Next, I decided to add an alarm, so that we could also hear that someone’s trying to steal our food.

IMG_4253 IMG_4250-1

Also, that was a time to solder wires to my force sensitive resistor. I It wasn’t easy due to tiny and flat parts of the resistor, but luckily I’ve managed to do that.

IMG_4258 IMG_4257

Finally, the assembly:

IMG_4280 IMG_4279

Turned out that the hardest task was to set up the value, that would both run the alarm, and light a LED light. Also, I put few rolled and unstick pieces of electric tape on the force resistor, just to make the sensor more sensitive to a flat surface of the plate.

Screen Shot 2015-09-24 at 4.54.36 AM

 

MetroCard Vending Machines

From time to time, almost every New Yorker must deal with MetroCard Vending Machines. We can find them at every subway station. I decided to watch the one at Vernon Boulevard station, next to my apartment.

IMG_4225 IMG_4226

First thing you notice, while approaching to the machine are color-coded sections, indicating:

Touch screen – Black,

Cash & coins section – Green,

Metro Card section – Yellow,

Credit/ATM Card Section – Blue

Change/ Receipt – Red

IMG_4230 IMG_4229 IMG_4228

I must say, this color code is easy to understand, and significantly quickens the whole transaction.  According to what Norman wrote in his book: ‘The most important principle of design is visibility. The correct parts must be visible, and they must convey the correct message’, vending machines seem to make a good impression on a future user.

To begin the usage, first thing you need to do is to touch a screen, which immediately asks you for a language of preference. After picking the language, we’re headed to the menu, where you pick the MetroCard type. Next, you pick the transaction type. If you wish to refill your MetroCard, all you need to do is to Insert your card to the ‘Yellow’ section and make the payment.

The whole process seems to be pretty easy and intuitive, unless you’re foreigner, who is in rush and wants to pay by international CreditCard. I remember that very well. Right after I came here, first thing I wanted to do is to be able to move around NYC by subway. I went through first steps, but when it came to payment, I encountered a difficulty. Turns out that when a credit card is used the machine asks you to enter your zip code for verification. Back them, my credit card account had a Polish billing address, so I was not subjected to the zip code verification requirement. It took me a while to google the whole situation and find out that instead a zip code I should type in ‘99999’. This  indicated that the card I was using was an international one, what leaded to different authorization process.

So, taking into consideration the amount of tourists who don’t own an American credit card, I’d definitely add a ‘Pay with international Credit Card’ option to the menu (without adding extra step to do that).

Another thing, I would change, is the ‘Touch to begin’ menu. Do we really need to see this welcome screen? What if we could skip it, also skipping the ‘Select your language frame’, just pressing the button with the right flag on it? Wouldn’t that be both intuitive and time saving? Could I touch it it less to get what I want?

The design displays high-contrast graphics, which definitely helps visually impaired. Braille and audio instruction are also available.

After staying next to the vending machine for a while, I could observe that usually, the whole process of refilling card does’t last more than a 2 minutes. There were few people, who were struggling with payment when using international Cards. Most of them ended up asking ticket seller for help.

I’d say that MTA Vending Machines are quite nicely designed, and pretty intuitive example of public interactive technology. I am sure that after few updates they could became even easier to use.

Money Bank

My idea for the second assignment was to create a money bank, which would encourage people to save some money. Usually, spending money seems to be a lot of fun. Let’s make the process of saving them equally entertaining!

To do that, I decided to build a simple box with 3 LED lights on the top, that shines every time someone puts money through the whole in the lid.

I needed only basics tools, which I could find in my own apartment.

LED_bank LED_bank-6 LED_bank-5 LED_bank-4

The construction was easy:

In the bottom of the box I placed the 9 V battery, connected to 2 wires.

LED_bank-7

Then I built the second, conductive  ‘layer’ made of aluminum foil.

LED_bank-8

I connected one wire to the resistor (don’t forget about it Marcela! You don’t wanna burn the LEDs!) and 3 LED lights placed at the top of the money bank.

LED_bank-13

To complete the circuit, I attached another sheet of aluminum foil to the second wire, placing it horizontally inside the box ( the foil should not touch the bottom).

LED_bank-9 LED_bank-11

The circuit completes when the weight of the coin inserted to money bank press both aluminum sheets together.

LED_bank-14

LED_bank-16

Here’s how it works:

The best part of it is the fact, that coins, being conductive won’t break the circuit, so we can easily leave few of them inside the bank and still be able to re-light the LEDs.

I really enjoyed this task. As a physical computing newbie, I was pretty excited seeing that my money bank  actually WORKED!

I’m sure that this tiny gadget will make me a rich man soon!

First Arduino Kit

I am so excited! I just got my first Arduino Kit. As a photographer at heart, I decided to take some pictures and share them on my blog (till all pieces are still safe in the box, nothing is lost and everything smells brand new)!

Here’s how the Kit looks like:

Arduino KitArduino KitArduino Kit  Arduino Kit Arduino Kit

Arduino KitArduino Kit Arduino Kit

The set includes:

  • Arduino Projects Book
  • Arduino Uno – a heart of my future projects,
  • USB cable – connects Arduino to computer
  • Breadboard – on which I will be able to build electronic circuits,
  • Jumper wires – connect components to each other on the breadboard, and the Arduino,
  • Battery snap – to connect 9V battery to power leads,
  • Photoresistor- (photocell / light dependent resistor) – Variable resistor that changes its resistance based on the amount of light that falls on its face,
  • Potentiometer – variable resistor with three pins,
  • Pushbutton – close a circuit when pressed,
  • Temperature sensor – changes its voltage output depending on the temp.of the component,
  • Tilt sensor – switch, that opens and closes depending on its orientation,
  • 1 Liquid Crystal Display (LCD) – display based on liquid crystals,
  • Light Emitting Diodes (LED) – diodes illuminating when electricity passes through it,
  • DC motor – converts electrical energy into mechanical energy,
  • Servo motor – geared motor that can only rotate 180 degrees.
  • Piezo – electrical component that can be used to detect vibrations and create noises,
  • H-bridge- circuit that allows to control the polarity of the voltage applied to load (usually motor),
  • Optocoupler – allows to connect two circuits that don’t share a common power supply,
  • Transistor – three legged device that operates as en electronic switch,
  • Capacitors – store and release energy in a circuit,
  • Diode- ensures electricity only flows in one direction
  • Gels – to filter out different wavelengths of light,
  • Male header pins – fit into female socket. help connecting things ,
  • Resistors – resist the flow of electrical energy in a circuit

After creating this handout and studying it a little bit, I feel a little bit overwhelmed, but still very motivated and excited!

Can’t wait for my first project! Wish me luck!