on Aug 24th, 2013Pottery meeting the digital

Found this outlandish hard-drive-hack to create a mini pottery wheel. It somehow feels satisfying to just look at it.



on Nov 30th, 20123D printing excursion

Following up our excursion into 3D printing today – one open question was how to get the model into the proper format (.stl) that would on the archaic software used on the 3D printer.

Here is a tutorial for moving from Maya vin Rhino to arrive at the necessary .stl format.

There seems to be at least one direct exporter from Maya into the .stl format. But I have not tested it. So let us know if you played with it.



on Nov 6th, 2012Conductive Ink testruns

This week we will play with conductive ink. There should be some CuPro-Cote ink at hand. Conductive ink comes in various forms and qualities (see Hannah’s summary) and our main goal will be to test whether we manage to get any reasonable circuits assembled from this material.

For inspiration: there are a number of tutorials on conductive ink projects out there:

– a paper piano from the HighLow Group

– a cardboard mouse driven by your USB from Instructables

– Bare Conductive is a particular ink producer with some basic tutorials on the site

– before they took it commercial, those folks did the Human Synthesizer at RCA

– Parsons had a course (aptly named Collab II) on “soft circuits” in fall 2011 with a bunch of student projects, some involve conductive ink.

– via Ashton: conductive materials in a nifty book project by Waldek Węgrzyn (site in Polish)

– Pumping Station: One experimented with magnetic AND conductive ink (via openMaterials)

and I am sure there are plenty more.

on Oct 26th, 2012Making your computer talk to arduino

I’ve adapted (read copied wholesale) an example from the ITP website here that describes how to create serial connections from an Arduino to a Processing sketch.

First, here’s a sketch to take digital input on pin 2 and send it to the computer over serial:

void setup() {
  pinMode(2, INPUT);

void loop() {
  if (digitalRead(2) == HIGH){
    int digitalValue = 255;
    int digitalValue = 0;

Second, here is an (even more simple) sketch that reads a single analog input and sends it to serial:

void setup() {
void loop() {
    int analogValue = analogRead(A0)/4;

Finally, here’s a sketch that takes any serial input (notably from either of the Arduino sketches above) and creates a graph of the results:

import processing.serial.*;

Serial myPort;           // The serial port
float xPos = 0;          // horizontal position of the graph

void setup () {
  size(1280, 720);        // window size
  // List all the available serial ports
  // println(Serial.list());
  String portName = Serial.list()[7];
  myPort = new Serial(this, portName, 9600);

void draw () {
  // nothing happens in draw.  It all happens in SerialEvent()

void serialEvent (Serial myPort) {
  // get the byte:
  int inByte = myPort.read(); 
  // print it:
  float yPos = height - inByte;
  // draw the line in a pretty color:
  line(xPos, height, xPos, height - inByte);

  // at the edge of the screen, go back to the beginning:
  if (xPos >= width) {
    xPos = 0;
    // clear the screen by resetting the background:
  else {
    // increment the horizontal position for the next reading:

here are the sketches in a zip: talking

For more complicated examples, including multiple inputs to processing, check out the ITP serial duplex tutorial here

on Oct 12th, 2012Ohm’s Law – How to choose resistors for your circuits


1. Figure out the properties of your circuit elements.
2. Figure out whether to limit the current or the voltage.
3. Do some math.
4. Find the right resistor in your bucket.
5. Plug it in and turn it on.

on Oct 5th, 2012Battling through a tech sheet

To document some work on our “catch up project” of the Colab pinball: I chose to work on a display for our machine and picked a dot matrix display I found in one of the grab bags in the lab. More precisely: the LJ7071-22-M1.

Unlike most earlier projects that somehow follow a modified tutorial, I had no information about this little fella. So I went online to find the Specifications for this dot matrix. With a bit of experimenting I got the basic wiring together.

Continue Reading »

on Aug 8th, 2012New Mini Make Faire at Tech!

Welcome back from the long holidays – and already something to look forward to this term:
Seems there will be another Mini Make Faire at Tech on Oct 6th. MAKE blog even has an anoucement on it!

on Apr 17th, 2012Wallace Waver

Here’s how to make the Cyborg Ben Wallace Waving Machine

Processing Code (simple frame differencing)

import processing.video.*;

import processing.serial.*; //This allows us to use serial objects
Continue Reading »

on Apr 13th, 2012Laying out a PCB with EAGLE


CadSoft EAGLE PCB is a pretty ok piece of software for drawing up schematics and then laying out a printed circuit board. I say “pretty ok” because its interface and UI consistency leaves a lot to be desired, particularly if you’re used to the relatively sane default behavior of software like Adobe Illustrator. This caveat aside, though, Eagle is kind of amazing: it’s free for educational use (with a limited board size) and does it all. What it lacks in immediate user friendliness it makes up for in extensibility, where any number of people can contribute board shapes for all sorts of components.

This is the real deal! To get started, download the software. Pick the software type that matches your operating system, unless you enjoy fruitless struggle:

We’re also going to need to have some libraries to be sure that we’ve got all the components we want. Sparkfun has a good library, as does lady ada. If you want to save time, though, just grab mine. It’s got all those and more (a bag of chips??):

My thought for today was that we could

  1. build a schematic for a power supply
  2. build out the schematic for an arduino
  3. add AVR programming headers
  4. make a schematic for the touch sensor from last week
  5. hook all these up
  6. lay out a pcb for a custom “Touchduino”

While we’ll probably just play around with Eagle during colab this week, Sparkfun’s tutorials for embedded electronics include some decent eagle guides. I’ll link them here for future reference.

on Apr 6th, 2012Building from schematics and data sheets

Once you’re comfortable building arduino projects with simple sensors and outputs, its fairly soon you find yourself needing more stuff. A basic arduino uno has a limited number of inputs and outputs, for example, and standard inputs tend to limit applications. One way around this is to find sensor and other types of integrated circuit (IC) packages and use them in an arduino-driven project. To do this, it’s necessary to be able to read a datasheet, as well as any schematics found inside them.

Reading schematics

Here’s a handy reference of some common schematic symbols:

This is from Forrest Mims III’s book Radioshack Electronic Sensors Lab, and while some of the parts are specific to this kit (all the cards for example) it’s a decent place to start. There are also many online guides for schematic reference (e.g. here and here). Having a resistor reference is handy. If you’re on a Mac, I like Resistulator.

One of the chips’s we’ll be playing with today has a datasheet circuit that looks like this:

Setting up a breadboard

I’m a huge fan of having a breadboard set up for prototyping that has its own built-in power supply. I know that we don’t all have these, but I feel like it’s worth having on the blog for reference:

This is a breadboard with a standard DC jack, a 7805 power regulator that will give a consistent 5V output, and decoupling capacitors that will keep the current reasonably level. The heatsink is there because regulating 12V to 5V puts off some serious heat.

IC pin orientation

ICs can be read by the “notch” in one end of the chip, or a small depression near one of the pins. The first notes the side that the pin counting starts at, and the second indicates which pin is number 1. Pins on a chip are counted around the IC in a counterclockwise way:

Today’s project(s)

Because this isn’t all that many chips to share, it’s also worthwhile to get the hang of making an Arduino on a breadboard. I have parts enough for at least a couple of those, and I prefer this format of Arduino much more than using a regular Arduino on a PCB because I get much more prototyping space. There are a couple really good pre-built arduino boards that make a breadboard into a decent prototyping platform (e.g. boarduino), but doing it yourself is the gold standard in my book.

Using a in-circuit system programmer (ISP) like the USBtinyISP and a breakout board for the 6 pin programming header, it’s possible to program a breadboard arduino fairly easily.