Skip to content →

Category archive for: p-comp

penelope – final documentation

Like I’ve said in many posts before, for my final project I designed a weaving loom that weaves during the day and unweaves during the night. So the system works in this order:
1) p5 access data from the web a) geolocation of the piece b)time when the sunrises and when the sunsets
2) p5 says if it’s day or if it’s night
3) send this data to Arduino
5) arduino turn stepper motors on, changing the direction according to the information received
6)build the final weaving loom
6) mount arduino and steppers on the weaving loom

And I tried to build the separate parts in separate steps but that didn’t work separately at all. So bellow is an attempt to separate them in three big segments/posts that were developed simultaneously:


At first I started to take a look on how sunrise/sunset astronomy APIs work to understand what kind of information I would need as a geolocation reference for it. I opted to use the weather channel API ( ), that can call astronomy information from different positions according to city name or latitude and longitude.

var currentTime;

function setup() {
  createCanvas(480, 240);
  loadJSON("", gotData);

function gotData(data) {
  currentTime = data;

function draw() {
  if (currentTime) {
    fill(255, 200, 0, 100);
    ellipse((currentTime.sun_phase.sunrise.hour) * 20, height / 2, 10, 10);
    fill(0, 200, 255, 100);
    ellipse((currentTime.sun_phase.sunset.hour) * 20, height / 2, 10, 10);
    if (currentTime.moon_phase.current_time.hour > currentTime.sun_phase.sunset.hour || currentTime.moon_phase.current_time.hour < currentTime.sun_phase.sunrise.hour) {
      fill(100, 100, 100, 100)
    ellipse((currentTime.moon_phase.current_time.hour) * 20, height / 2, 10, 10);


Since most geolocation APIs give back latitude and longitude coordinates, I was now ready to find a geolocation API that works with those two variables. For commodity and popularity I started testing with the google geolocation API. After a while trying to make the sketch to work on my computer and failing overtime with some error related to the API variable, I decided to go to the ICM group and ask for help. John Farrell told me I could try to work with a built-in HTML function called navigator, so that I didn’t need to worry about APIs and it would give me the object in pre-formatted standards. That also didn’t work at first and after a while googling I found out that because those were referring to variables outside my sketch, they didn’t work unless they were running on the web. I uploaded the sketch and charm – it worked!


Now that I knew how to use the navigator and google api , it was just a matter of understanding how the weather channel API worked, how I accessed the sunrise and sunset objects and how I could put an api inside an api. So what I got as a solution was to assign a new global variable to each of the coordinate values and add them up to the weather channel API url. Tom Igoe gave an interesting comment about the geolocation that I didn’t know: they only actually work outdoors, inside building they get the closest value they can get. But for now, all I needed to know where the loom is and that worked.

Once I had the sunset and the sunrise hours of the day, it was time to compare it to the current time and define if it was either day or night. Creating new variables for each of those hours and comparing them through if statements to know if it’s day or night. Once I had that comparison I had to work with some tricky situation with accessing the weather channel API: I’ve put it on the draw function and soon enough I got an email from them saying I had accessed the limit of access per day I could have. It took a while for me to understand that to only access it once a day I’d have to create universal variables, assign them values inside a “weather channel” function and then call them back on the function draw.

var coordenadas;
var data;
var posR; //position sunrise time
var posS; //position sunset time
var posC; //position current time

function setPos(position) {
  var lat = position.coords.latitude;
  var lng = position.coords.longitude;
  text("latitude: " + lat, 50, 50);
  text("longitude: " + lng, 50, 70);

  var url = '' + lat + ',' + lng + '.json';
  loadJSON(url, gotData);

function gotData(data) {
  text("sunrise: " + data.sun_phase.sunrise.hour + ":" + data.sun_phase.sunrise.minute, 50, 90);
  text("sunset: " + data.sun_phase.sunset.hour + ":" + data.sun_phase.sunset.minute, 50, 110);
  var hora = hour();
  var minuto = minute();
  text("current time: " + hora + ":" + minuto, 50, 130);
  line(posR, height / 2, posS, height / 2);
  posR = ((data.sun_phase.sunrise.hour) * 50) + data.sun_phase.sunrise.minute;
  posS = ((data.sun_phase.sunset.hour) * 50) + data.sun_phase.sunset.minute;

  posC = ((hora) * 50) + minuto;
  fill(255, 255, 0);
  ellipse(posC, height / 2, 20, 20);
    ellipse(posR, height / 2, 10, 10);
      ellipse(posS, height / 2, 10, 10);


function setup() {
  createCanvas(1200, 600);


function draw() {
  background(180, 225, 255);

After I was able to get all the values working, I asked some friends around the world to test it (just to be sure it was working).


Now that I had everything running well on the p5 , it was time to connect it to the Arduino sketch – and this was also tricky because I needed to access a serial port from a sketch that was uploaded on the web. I didn’t quiet understand how the communication between both happened, so this was a good exercise to understand how it works. I also went up to the ICM group and was help by Shawn Van Every, who told me I could access the serial server manually, through the p5 serial port node library.

var serial; // variable to hold an instance of the serialport library
var portName = '/dev/cu.usbmodem1421'; // fill in your serial port name here
var inData; // for incoming serial data
var outByte = 0; // for outgoing data

var coordenadas;
var data;
var posR; //position sunrise time
var posS; //position sunset time
var posC; //position current time
var texto = "";

var hora, minuto;

// var dados = {};

function setPos(data) {

  var url = '';
  loadJSON(url, geoLocation);

function geoLocation(data) {
  var lat =;
  var lng = data.location.lng;
  sunTime(lat, lng);


function sunTime(lat, lng) {
  var url = '' + lat + ',' + lng + '.json';
  loadJSON(url, test);

function test(data) {
  hora = hour();
  minuto = minute();
  posR = ((data.sun_phase.sunrise.hour)) + data.sun_phase.sunrise.minute;
  posS = ((data.sun_phase.sunset.hour)) + data.sun_phase.sunset.minute;
  posC = ((hora) * 100) + minuto;


function printData() {
  hora = hour();
  minuto = minute();
  text("current time: " + posC, 50, 130);
  text("it is", 50, 150);
  if (posC > posS || posC < posR) {
    text("NIGHT", 70, 150);
    texto = 'H';
    // turn the motors this way
  } else {
    text("DAY", 70, 150);
    texto = 'L';
    // turn the motors the opposite way
  text(texto, 70, 150);


function setup() {
  createCanvas(1200, 600);
    serial = new p5.SerialPort(); // make a new instance of the serialport library
  serial.on('data', serialEvent); // callback for when new data arrives
  serial.on('error', serialError); // callback for errors; // open a serial port


function serialEvent() {
  // read a byte from the serial port:
  var inByte =;
  // store it in a global variable:
  inData = inByte;

function serialError(err) {
  println('Something went wrong with the serial port. ' + err);

function draw() {
  text("sunrise: " + posR, 50, 90);
  text("sunset: " + posS, 50, 110);
  // gotData(data);

Everything works the way it should be, yay! Some improvements I’d like to do in the future regarding to this computational media part of the project:
– be able to make it refresh by itself once a day
– be able to string the data and send to the how long the day / night is and therefore how low the weaving and unweaving should take


For sure one of the biggest challenge on this project was to work with motors – something that I was very excited about but I didn’t have a lot of knowledge over. I had some stepper motors I had recently bought and therefore I decided to use them. I started by putting them to work through an H bridge and powering it with a bench power supply, which worked with a simple code but had a lot of wiring that didn’t make a lot of sense and was extremely messy. I was also very concerned about wiring the motor with the power supply, because I didn’t want to exceed the limit current of the motors.


I was able to make both motors to work separately and the mechanism (the stepper winding and unwinding the thread) as well. When I tried to turn the two motors at the same time, I wasn’t sure on how I should power them and after talking with some friends & Jeff, I decided to test some motor shields to control the steppers. I tried sparkfun’s super easy driver (but it didn’t work at all – maybe the way i wired and/or solder it) and adafruit motor shield, that had a great documentation online and was very straight forward on how it should be wired as well as how the code/stepper library worked.


How to manage the power supply seemed a bit arbitrary at the beginning and I accidentally burned one of the chips on the motor shield because both motors working at the same time were demanding more than 3A, the maximum current the shield can take. But after having some office hours with one of the residents(Pedro), I was able to understand that the power supply is not actually that controllable and what you can do (and for this case it was very important) is limit the current.
Once I had the wiring and power figured out, it was time to test and experiment with the speed of the motors and speed modes (single, double, micro steps etc). At first I thought that all I needed was to make them work at the same time, running in different directions; ater testing, I’ve realized that this was actually tensioning the thread in different directions and wouldn’t make the thread to move around. Some experiments were made, specially with the single and micro steps, and I chose to use a combination of alternated micro steps between both motors. This way, the thread was never 100% tensioned and it was moving elegantly smooth.
Now that the mechanism of arduino + motors was also set, I had to change the serial communication code on the arduino side, so that it would turn on the motors and move them in the right speed and direction.

int incomingByte;     // a variable to read incoming serial data into

#include "utility/Adafruit_PWMServoDriver.h"

// Create the motor shield object with the default I2C address
Adafruit_MotorShield AFMS = Adafruit_MotorShield();

Adafruit_StepperMotor *myMotor1 = AFMS.getStepper(200, 1);
Adafruit_StepperMotor *myMotor2 = AFMS.getStepper(200, 2);
void setup() {
 Serial.begin(9600);             // initialize serial communication

AFMS.begin();  // create with the default frequency 1.6KHz
  //AFMS.begin(1000);  // OR with a different frequency, say 1KHz

  myMotor1->setSpeed(100);  // 10 rpm

  myMotor2->setSpeed(100);  // 10 rpm

void loop() {
 if (Serial.available() > 0) {   // see if there's incoming serial data
   incomingByte =; // read it
   if (incomingByte == 'H') {    // if it's a capital H (ASCII 72),
  myMotor1->step(100, FORWARD, MICROSTEP);
   if (incomingByte == 'L') {    // if it's an L (ASCII 76)
  myMotor2->step(10, FORWARD, MICROSTEP);

It worked!! The only thing that I’d like to continue to develop is to make the shift from day to night (motor direction and speed) automated. For now, when the sunset/sunries time comes, it doesn’t understand that it changed – so I have to refresh the p5 sketch so that it changes the direction. It’s fine for the moment because it can be controlled manually but I think that for a consolidated version of this project (maybe with several pieces around the world?) this should be working automatically.


At last but not least at all – while I was developing icm and p-comp parts, fabrication was happening in a sort of obsessive rhythm. During the time I developed this project, I kept on building different versions of the loom: different mechanisms for the thread to roll as well as a wide range of sizes and cloth’s weft. There were 10 versions of a weaving loom to understand which would work with the mechanism i was dealing with : two steppers working in different and/or same direction to pull a thread one way or another. Like it has been shown in other assignments for fabrication, I was able to get some positive conclusion by myself as well as feedback from Ben and other builders that have much more experience within designing mechanisms/machines than me.


For sure there were three big challenges on building the loom: working with a mechanism that wouldn’t lock the thread’s movement, fitting the parts of it perfectly and giving the whole piece a nice polished finish. One colleague and Jeff Federsen were following the building process and suggested that I tried to work with pulleys, that were available at McMaster and they were great to work with. It was a bit of a short in the dark but a shot that for sure was likely to work since they can handle much more tension/friction than I was putting on them. While looking for the right pulley, I found out that McMaster Carr not only has a great search engine but also there are so many different types of pulleys – and there are specific pulleys for ropes. I didn’t find pulleys with the small dimensions I had in mind and those rope pulleys were a bit over my budget, so I chose to buy 10 big rope pulleys; you don’t have the sensation of being a fabric (in the case of the concept of this piece, a shroud), but it does have the visualization of the weaving being done and undone.
Since this was the final version of the loom, I wanted to plan if very well and be sure that I didn’t miss any of the measurements or that after starting to build it I’d realize I needed more of x or y material. From the sizes that I’ve tested on older versions of the loom and also according to the number and sizes of the pulleys (thank you McMaster for the downloadable files!!), I picked a “medium” size that was a bit bigger than my small looms but that I felt comfortable that would work – and then I went straight to Illustrator to calculate precisely how much of each of the materials I would need. So this is the technical drawing of the piece:


After finishing this technical drawing, I went straight to metropolitan lumber shop to get the wood for building it. I knew I wanted to try to work with either pine wood or poplar tree, but I didn’t know which would be more affordable. Surprisingly I was well treated at metropolitan: they helped out explaining the differences, gave the cost of each one of them and explained me better about wood thickness – something that I didn’t count in on my technical drawing, but it was ok because i got a pine wood that was thicker than i needed.
Back to the shop, it was time to face the band saw the way it is: it doesn’t cut straight and it requires a lot of filing to make your pieces to fit each other. The positive point was that there were only four pieces of pine to be filed (for the weaving frame); but even though, it was an afternoon full of dust to make the pieces fit each other and to have the same exact measures.
After this, it was a matter of marking where the pulleys and motor mounts would go and assembling the pieces together – so before starting this, I went to the yellow cabinet and looked for unlabeled finishing wood oils. I knew I wanted to make the wood a less pale due to the fact that the thread had to be white and it kind of disappeared if kept the pine wood in its natural color. I had some spare piece of the wood and this was great for testing finishing oils. I tested a few tinted finishing oils and decided to go with one layer of the oak wood finishing oil, that gave a golden/tanned finish to the wood enough to pop the thread out of it and to make it look well finished. I waited 10hrs for the oil to dry and started marking down and assembling the pulleys to the side of the weaving frame.

penelope_15Using the punching whole tool and putting a tape on the driller bit as a stopper were very handy for this step: making sure i didn’t go through the wood and that the holes were drilled where they should be assured me that both sides of the frame were aligned as initially planned. After assembling the pulleys, i assembled the weaving loom frame to realize i hadn’t plan where the motor mount would go. i improvised and went to the laser cutter with some thick acrylic I had, doing some tweaks on a vector file of a motor mount I had so that it would fit the stepper motor i had.

so one of the motor was mounted and the other was loose, in front of the weaving loom. I’ve put the loom to work to realize that motors have to be better mounted and any change on the thread direction would cause a lot of friction and lock the movement at some point.


So I decided to get real motor mounts and rethink both thread reels position within the weaving loom. With the stepper mounts, I’ve put them as aligned with the weave as possible, so the one that was pulling the fishing wire was upside down on the inside-top-left corner of the loom and the one that had the cotton thread was on the horizontal axis, with a thread reel mounted on the stepper rod outside the wooden frame, but keeping the direction of the thread the same of the weaving. I had laser cut a disk to fit the stepper rod and to attach the wooden spool to; it definitely worked to make the reel to spin according to the motor direction and speed but I had to improvise a bit because the thread started to wind before the spool – for the show, i used a small pencil to stop this.



BUT I MUST CONFESS that this was not the last version of the loom. the guys from metropolitan accidentally gave me some poplar wood big enough to make a new version of the loom. Seeing that the pulleys worked, I got confident to try to make my own pulleys with sewing machine reels and aluminum tubes, making more horizontal lines as well as hiding the pulleys and the arduino. Again, I went back to illustrator and got all the measurements correct.

penelope_25v2I got some help from a friend to make the pulleys and one motor’s slot inside the wood with the CNC machine. I did the illustrator file and got a lot of help to transform it and export it to the CNC machine. It looks more scary than it actually is; you just have to pay a lot of attention when you set the file on the shop computer and when you set the machine to work. And also I’ve learned that you really have to attach your wood to the table to be sure it won’t start spinning with the CNC on.

And so I spend more time building this loom that I thought it would be my final solution. I also had to think how the motor of the fishing wire would be mounted, how it would fit the pulley column etc. It was a lot of work but I felt that it would work – or at the worse situation, it would be just a manual weaving loom. So I built it and put all the elements in it. When I turned it on, it didn’t work. At all. It was too much fiction and I didn’t give enough space for the reels to spin freely – so if one of two got locked, it ended up locking up the whole movement.

For those who came to the show probably saw me live weaving on supenelope_29nday (since it was not working and there was no time to go back to the other version). On monday I was able to get the earlier, mount both motors to the old version of the loom and made it work!


I wish to continue on improving the weaving loom, making it bigger and adding more horizontal lines, trying new pulleys & other materials. I don’t know how long it would take, but I’ll try to see if I can get any kind of grant or short artist residence to develop it further. And I really got the hang of building things, I’m looking forward to improve my shop skills and learn other machines, making fabrication more and more clear and easy.


Thank you Dan, Jeff and Ben for helping out through the process; I do feel I learned a lot and specially because you all pushed me further to test and experiment with possibilities that I haven’t tried before. Thank you all itp friends who helped me out from the moment Penelope was just an idea to the final moment of mounting motors right before the show started on monday!


It was indeed a great semester, see you soon ITP =)

Leave a Comment

intro do fab / week 05 – two materials

for this week assignment we had to fabricate something using to materials that were not acrylic or plywood. since i’m non-stop building looms and i needed to test one last version of a loom for my p-comp final, i decided to make a new weaving loom with some better quality wood and metal rods (i ended up using acrylic as well – sorry ben).

from my last experiences in fabrication i learned that the first thing that i needed to do was to plan exactly all the measures of the loom, where each piece would fit, how much of each material i would need and when i needed to buy all of them. so i did a sketch of a blueprint on illustrator to perfectly plan how the loom would come out and took it with me to buy the materials. since i didn’t know which specific materials i wanted to work with, i looked through some of the websites to know what materials i want. i went to metropolitan and surprisingly they were very helpful and i decided to use pinewood to work with. some friends went to metalliferous, so i looked on their website what metal rod i wanted to use.


once i got the material, i prepared them (aka cut and file the ones that need to be filed) and was reading to start techniques of fastening them. to guide me, i did a list of procedures i should do, in the order i believe they work better:


for weaving part of the loom, i had done some tests before and i needed some kind of metal rod that wouldn’t bend. i wanted to make threads on the rod as well as to matching threads on the wood with the tap and die tool – but i think that the kit is missing some piece to fit the tap, i tried doing it by hand (testing it) and it didn’t work. so i just drilled a hole and put the brass rods. even though i needed some kind of structure that would stop the weaving of going to the center, i also needed it to let the thread to run freely – so i put an acrylic tube over the brass. it was the right fit, not too loose but loose enough to spin with the thread. i had to hammer them (the wood got a bit dirty but it’s ok).

i’ve been working with the pocket screw jig and i feel confident about it, so i decided to keep using them to assemble the frame. however, the pinewood i was working was a bit too thin, so i had to be really careful on where to make the pocket screw hole. i ripped off a little bit of the pinewood in one of the wholes, but since i had no left overs of the material, i just ignored it and assemble the one besides it.

i was very happy with the result, but i want to get better on making the material assemble better. even though it works and it is not falling/ it balances by itself, it’s still not perfectly fitting.


and here’s a demo o how the weaving loom works:

Leave a Comment

penelope / weaving loom prototyping

i worked on the last two weeks on a prototype in different scales for the weaving loom. it’s been a very intense process of doing, testing, rethinking and doing a new version. i’ve never weaved before this but i have experience in manual crafts and though it wouldn’t be that hard to weave. it is not, but to think how a machine can weave is more challenging than expected for sure.

prototype 01. small, full weaving


successes – i was able to weave, the frame works well;

failures – was able to cross the thread on the horizontal axis, not in ther vertical axis.


prototype 02. alternate crossing, small (long) loom, test weaving



sucesses: was able to also make the threads vertical axis to cross

failures: using two wood pieces to alternate them lock the crossing in the middle of the weaving canvas.


prototype 03. big frame (actual size), test weaving



sucesses – the vertical axis crossing happened by just a back and forth movement;

failures – the crossing of the lines was not high enough to make the weaving to start at the top of the frame and i would lock the weaving if i have some kind of wood piece crossing the threads on the horizontal axis.


Leave a Comment

icm + p-comp final / penelope

title Penelope

what is it A tapestry loom that weaves and unweave according to sunrise and sunset, referring to an excerpt of Homer’s The Odyssey in which Penelope delays an unwished fate by choosing to decide to which of her suitors she would marry once she finishes the burial shroud for Odysseus’s elderly father Laertes.


kickstarter point Although there’s a romantic aspect on this story, my interest in this passage of The Odyssey is focused on the fact that it exhibits women empowerment through subtle actions – specially in a mythological context in which the woman are not only submitted to fate, but also to the misogynous dominance of men over decisions.

description A tapestry loom that weaves when the sun rises and unweaves the same piece when the sun sets. The white thread on the loom refers to ancient greek burial rituals in which the deceased would be dressed in a full length white shroud – as if the closer the loom gets to have the piece done, the more Penelope is confined to her own imprisionement.


audience The audience of this work is every person interested in art, installations, conceptual work and mythology.

questioning pt1 Penelope weaves during the day and during the night, when there’s no one watching, she unweave it. When one of her maids accidentally sees her unweaving, she tells Icarus and Penelope is uncovered. I thought that maybe adding this to the installation in a way that if someone goes through the piece when it is unweave the loom would break…what you guys feel about this idea? Any other suggestions on how or if I should add this to the piece?



Ligia Pape – Ttéia 1C / Site-specific installation using steel wires and lighting in a room, creating a very aerial and immersive environment.

Clotho – CADU / Performance with two women (each one on a corner of a room) in which one does crochet while the other undoes it.


Falha – Renata Lucas / Site-specific installation in which the “flexibility” of the wooden objects are an invitation to the public to intervene and transform the piece.

Fragmented Memory – Phillip Sterns / woven tapestries made out of raw binary data from the computer/s physical memory.

questioning pt 2 any ideas on how I can automate the loom (it’s going to be a simple one)? how can make it more clear that the loom will only weave when is day and unweave during the night, considering the fact that the public won’t see it for the full 24hrs ?

I think most of my questionings are also a question over how far can we go with technology without being overwhelmed by it, finding a balance on creating a very dense installation without extrapolating on technological tool…help out, would love to hear your thoughts over it!!

One Comment

p-comp / midterm – rgb light to cmyk pigment

for the p-comp midterm me and Nilomee decided to make a RGB to CMYK converter, in which you pick the light color and get the correspondent color pigment. In simple steps, we wanted the whole mechanism to work in this order:

  1. set the amount of red, green and blue you want;
  2. save this color;
  3. convert this color from RGB color mode to CMYK;
  4. put the percentage of each of the colors of the CMYK mode inside a recipient;
  5. mix the colors;
  6. print them on a paper.

Also developing the process in this order, we chose to work with three potentiometers and a RGB LED light so that the user can pick separately the amount of each color(red, green and blu). Once the user had set the color, he/she would click on a button to save the value of each channel.


After we had the RGB value, it was time to convert it do CMYK. We searched over the internet for formulas that would easily convert them and we didn’t find any that was clear to the program or that gave precise values (they would only point if any of the channels were present or not). So we decided to figure out by ourselves the formula, which started very confusing because the RGB works with a range of amounts (0-255) and the CMYK works with percentage (0-100) that are independent of each other. Also, it was confusing to know when the shade of a color got lighter/darker due to the opposite behaviours each of them have on the two color modes and what was the exact correspondency between those systems (which colors on RGB generate colocr channels of the CMYK and vice-versa).

After some brain melting, we decided to use 255 as the value that represent 100% on the CMYK and to create the exceptions. If all the channels of the RGB are 0, we have 100% in all CMYK channels(black) and if we have 255 in all RGB channels, all colors are 0% (white). And we found the proportion between the color correspondency between RGB to CMYK. The colors are not exactly the same, but they are as close as possible


C = G + B

G and B have the same proportion and we know they have to be on their maximum value to get 100% cyan.

100C = 255G + 255B



B = C + M

And to have Blue, you have cyan and magenta at 100% and 0% of yellow or black.

255B = 100C + 100M + 0Y + 0K

So not only we mapped the potentiometer values (0-1023) to the RGB colors (0-255), but we also mapped the RGB colors(0-255) into CMYK correspondents(0-100).

//RGB LED declare
int pin1 = 11; //red
int pin2 = 10; // green
int pin3 = 9; // blue

// switch button
int switchPin1 = 7;

// RGB color combinationl
int colorRed;
int colorGreen;
int colorBlue;

// CMYK color combination
int colorC;
int colorM;
int colorY;
int colorK;
void setup() {
//RGB LED individual pins as output
pinMode(pin1, OUTPUT); //RED
pinMode(pin2, OUTPUT); //GREEN
pinMode(pin3, OUTPUT); //BLUE

//switch button as input
pinMode(switchPin1, INPUT);

void loop() {
//map potentiometer1 to output Red's value
int pot1 = analogRead(A0);
int pot1converted = map(pot1, 0, 1023, 0, 255);
analogWrite(pin1, pot1converted);

//map potentiometer2 to output Green's value
int pot2 = analogRead(A1);
int pot2converted = map(pot2, 0, 1023, 0, 255);
analogWrite(pin2, pot2converted);

//map potentiometer3 to output Blue's value
int pot3 = analogRead(A2);
int pot3converted = map(pot3, 0, 1023, 0, 255);
analogWrite(pin3, pot3converted);

//if button is pushed, save the RGB combination
if (digitalRead(switchPin1) == 1) {
int colorRed = pot1converted;
int colorGreen = pot2converted;
int colorBlue = pot3converted;

Serial.print("RGB color = ");

colorC = (map(colorBlue, 0, 255, 0, 100) + map(colorGreen, 0, 255, 0, 100)) / 2;
colorM = (map(colorBlue, 0, 255, 0, 100) + map(colorRed, 0, 255, 0, 100)) / 2;
colorY = (map(colorRed, 0, 255, 0, 100) + map(colorGreen, 0, 255, 0, 100)) / 2;
if (colorRed == 0 && colorGreen == 0 && colorBlue == 0) {
colorC = 100;
colorM = 100;
colorY = 100;
colorK = 100;
if (colorRed == 255 && colorGreen == 255 && colorBlue == 255) {
colorC = 0;
colorM = 0;
colorY = 0;
colorK = 0;
Serial.print("CMYK color = ");


Once we had the CMYK values, we started to test the ink dripping – this was definitely the trickiest part of the process and that we ended up spending more time than we could. We wanted to make a treadmill in which you would have each color hanging in recipients above it. A small recipient would be over the treadmil’s belt; it would stop below each color recipient and wait for the color to drip the right amount before moving on to the next color.

pcomp-midterm-02At first, we wanted this part of the machine to be fully automated: once you pick your color on the LED, it would start to move the recipient to the first color, count how many drops of ink felt and then move on to the other color. But then we saw that it would demand a bigger time to: analyze the rhythm in which the ink dripped and also what kind of mechanism would we use to stop/star tthe dripping.


After talking with Jeff and Pedro (one of the residents), we saw that we had some possibilities to do so: use a syringe + mechanism to press it, use a dropper + solenoid, use a peristaltic pump or leave the recipients dripping and control the time they stay under each color.

Because of time and budget limitations, we experimented the dropper and the control time options. We tried using the dropper of the ink itself and it was made of a plastic that was too rigid, so it wouldn’t vary that much when pressed with a solenoid or a servo motor. So we moved on and tried to work with time duration and the dripping. Calculating how many drops per second was not that precise to translate it in time duration because the pace would vary according to the volume of the flask.

In the end, we decided that the more manageable alternative to do so was to leave all recipients continually dripping (with a recipient below the treadmill) and the user controls how much time the pot stays below each color ( ideally counting the drops) by pressing a button to make the recipient over the threadmill move.



int switchPin = 3;

Servo myServo;
int angle = 0;
int buttonState = 0;

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


void loop() {

  buttonState = digitalRead(switchPin);
  if (buttonState == HIGH) {
    angle = angle + 30;
    Serial.print("angle =");
    if (angle > 180) {
      angle = 0;

To make the treadmill, we used two servo motors and tested several sizes of gears attached to the servos, that had a belt over them. We opted to get bigger gears to have a bigger distance between the recipients, so we started prototyping for the final version – and that’s when things got tangled. I think that the part that demanded knowlegde that neither me or Nilomee have was the fabrication part. We perceived to build it, but there were some measurements and pieces placement that we didn’t think it through that much and once we had the final pieces, it wouldn’t fit.


However, for the purpose of illustration and delightment, here’s a picture of our little frankenstein:


It was great working with Nilomee, I think we were able to colaborate and build up this project a lot due to our different interests/background. We definitely need to get better on our fabrication skills – which means we did the right thing of taking intro to fabrication on the 2nd session. Right on time for the final =)

One Comment

icm / friday workshop

Last friday all of icm classes got together to understand how to communicate between arduino and p5, followed by the one button design challange =)

I was paired with Zoe and we decided to do a slot machine haiku from which we could get reflections over ITP stuff.


We were able to make the serial communication between them, but we weren’t able to figure out which part of the code on the p5 was placed on the wrong place – so the program didn’t actually worked the random combinations part of it. Despite that, it was definitely fun to do it and see everybody together working on small creative applications.


One Comment

p-comp / week 04

this week i took the time to review all the concepts we were taught during class. obviously the quizz was the kick start for that, but i’m glad it was because i really want to be comfortable with the electrical part of the circuit. i was also able to make all the labs and understand how the circuit and code are working together.

so for this assignment, i decided to work with servo motors to make a thread reel to move. if i had more time, i’d definitely try to make a structure so that you can let the thread roll around freely. i felt like it was much clear for me to build it by myself after i had reviewed all the content, so i was able to put the servo motors with a photocell. the software read the photocell values and mapped it, giving a correspondent value within angles (0-180).

and the code for this circuit:

Servo servoMotor1;
Servo servoMotor2;

int photoValue = 0;
int servoPin1 = 3;
int servoPin2 = 5;
int servoAngle = 0;
int libraryInstance = 0;

void setup() {

void loop() {
  int photoValue = analogRead(A0);
  int servoAngle = map(photoValue, 150, 980, 0, 180);
  servoMotor2.write(180 - servoAngle);


Leave a Comment

p-comp / week03

for this week, we had some different activities to complete. Making a circuit with digital input or outuput and an analog input, completing a quiz about the content we’ve been learning and observing some kind of interactive situation open to public. The first two ones complemented each other, so it was actually good to review and think more about some parts of the electricity in the circuit that sometimes we go by just because we know it works (but we actually don’t know why it does). I was able to play a little with the digital input, working with a “digital” response (light on / off) and an “analog” response (creating a dimmer the light).


For the observation task, I decided I wanted to observe a recycling machine near a supermarket in Prospect Park. I’ve walked by here a few times since I moved in, but I never really stopped to understand how it works. Basically people go there with bottles and cans made of recyclable materials (glass, plastic, aluminum), and they’ll be paid for recycling it. One thing that I noticed at first was that there’s always a line there of 3/4 people with big carts full of recyclable cans/bottles. Anyone can come and use it, but there are people that make a living of it – so they come with a huge volume of mateiral and it takes a while to put all they’ve been collecting in the machines. Being an interactive situation like Crwaford’s describer, the process happens in 5 steps: 1) the person put the can inside the proper machine (whether is a can, plastic or glass recipient), 2) waits for the machine to understand that the can went through, 3)repeat it until there are no cans left, 4)finishes the “operation” and 5)get a certain amount of money depending on the volume of recyclable material you brought and the percentage of the kinds of materials. I didn’t use the machine but from what i observed it is definitely a slow process – specially if you consider also the amount of time people spend gathering the recyclable materials. This interactive experience is very interesting because it motivates a change related to usage of material and how we treat our garbage, but also because it ends up having a bigger function than just the recycle one: it is actually a source of income for some people. I think that this part of the experience is very related with Graham’s point of view over how design evolutes because an initial idea of people being rewarded for recycling their garbage actually became something bigger, in which people will take it as an income source.

I find it very interesting when products evolutes after their core idea, letting the public to resignify it in a way that is more functional/makes more sense to them. In portuguese we have a word for it: gambiarra. Google it, and you’ll see what I’m talking about the creativity the user can have to input information over a product or process and change it for a better use.

Leave a Comment

p-comp / week 02

Last week we had a dense class about electricity and circuits! Despite I have worked a bit with arduino before, I’ve never completely understood the electrical part of it – I think that after this class and the additional materials I was able to understand it better. Our homework was to make a circuit with arduino, using a switch to turn an LED on. For this assignment, I decided to make a silly game with a sewing thread reel inside a box. In the interior of it there are some obstacles and the ideia is that you have to rotate the object until the thread reel gets to the bottom of the box – and when that happens, the LED goes on.

I had issues to find out how I would put it all together (hardware, box and pins) and also if this would work as imagined. After brainstorming and prototyping, I had an idea of how to build it and started prototyping it. I decided to use to conductive copper wires and aluminum foil as my switch: they are not touching each other unless the thread reel gets to the bottom and push the wires to the aluminum foil, closing the circuit.


The problem was that the thread reel was to light to push them together; I had to find some other material to either gain weight on the thread reel or to be sufficiently heavy to make the wires connect but not to make the distort and end up touching forever the foil.

A quarter actually did the work, but I just thought that the thread could be a game that ended with the thread it self and we would have a graphic evidence of it, through the “paths” the wire made. Here’s the final prototype to this homework:

Even though the idea of making something more creative demanded more time to think how I would prototype it, I think I started to feel what is to actually prototype and work with different materials. Can’t wait to start intro do fab and be able to build things with different materials.

Leave a Comment

p-comp / week 01

On our first class of physical computing the class was introduced to some concepts and the general idea of how micro controllers work. Jeff proposed us to sketch a fantasy device and my group chose to think about a dream storage. To get familiar with our resources and shops, we were able to go around the floor and find material that we could “prototype” our device.

So me, Francesca and Jesse started brainstorming about this dream storage. We came up with a system of storage that would 1)recognize you started dreaming, 2)detect the brainwaves/connections your hippocampus is doing at that time, 3)transfer that information to a cloud storage and later on, when you wake up, you can 4) categorize/describe the dream. In this way, the system itself would evolute with your feedback; he’ll categorize your dreams, depending on the kind of nerve cell connection or brainwaves he received according to your dream history. When we decided to make this a on-going developing and accurate system we also thought the other way around could be possible – the system could detect a nightmare and send signal back to turn it into a good dream or maybe you can even restart a dream you had on storage from the point you woke up. This last part is a bit too much, right? And we thought this could be like a external hard drive close to your bed, accessible through your phone.

When we explained it to the class, Jeff questioned us about the choice of being on a smartphone, introducing us to a problematic that was also developed on Bret Victor’s article A Brief Rant on the Future of Interaction Design: it just seems that screen is the ultimate answer to any future interactive experience. I think for the past two years I’ve been wondering the part of visual representation in experiences, on how they can help the public to imagine certain concepts, but also limit their freedom to experience something . It is good now that the screen got in this debate for me and also surprising how the limitation of format went unnoticed until last thursday.

And to complement this initial questioning about interaction, the first two chapters of The Art of Interactive Design tries to define and show what is interactivity and what is not. Crawford starts talking about misconceptions over the “interaction” definition and to clear the understanding he defines it as a “cyclic process in which two actors alternately listen, think and speak”. Interaction can happen between more than to actors (but at least two) and there’s only interaction when one of the actor’s actions are given as an input for the other actor’s action.

When he started to point out the reasons why i.e. films are not interactive, I recalled Oliver Grau’s Virtual Art: from Illusion to Immersion, on a part that he contest these kind of art that don’t “digest” the public reaction as limiting directional immersive experiences; whereas what he calls open immersion occurs in experiences that don’t have closed/predetermined formats. Grau is defending immersive experiences as situations in which the public is free to intervene and modify the experience, leading to a more intense and engaging participation. And this is a parallel thought to Crawford’s idea of interactivity: like he said on the text, only when we truly interact we can truly engage into the experience.

After reading these texts and associating with my past experiences, I can only this of physical interaction as the immersive experience of constant exchange between two or more actors if they are using the other’s present action as input to their future responses. A good physical interaction will get you involved/immersed in such a high level that you feel you are part of it, it is a sensorial experience and therefore you have a big engagement over the experience itself. Despite Janet Cardiff and Georgers Bures Miller’s The Murder of The Crows is a sound installation with a very immersive atmosphere, at any point it won’t use the audience responses to intervene on the piece. It will always be the same, despite the site in which is exhibited or the audience is experiencing it.

I’m looking forward to see how my colleagues define psychical interaction as well as see what will come from this debate!

Leave a Comment