This week I was tasked to make multiples of a multi-process piece. I wanted to start making puzzles, so after researching for wood puzzles models online, I found one which would be makeable in one week considering my fabrication knowledge level. Then, I found this great instructable guiding the fabrication process, so I basically followed it step-by-step and created five versions of it.
I bought everything I needed at the Home Depot hardware store in Bed-Stuy (a piece of Pinewood, a piece of dowel, and paracord). And I could experience using for the first time all of the machines of the shop introduced during the last class: the milter saw, the drill press, the sander, and the band saw.
Fabrication Process
The most challenging part was drilling 15 dowels because they are made of bad quality wood and are kind of small for the size of the hole that I needed. After some trials, I found a way of making them stable enough and learned that drilling slowly is better for delicate materials. Then I sanded them to correct some damages to the wood made during this process.
Find below the final result. To solve the puzzle you need to find a way of taking the ring out of the object.
For this assignment, I was tasked to create a flashlight defined as portable, battery-powered, and creates light. My first thought was that I wanted to work with things that I already had in hands and create something that could be used as a wearable. So, the only thing I had to buy for this assignment was a 9V battery.
first sketch
Materials
9V battery;
Arduino Nano (I had to use an Arduino because the light that I had was an addressable LED, which only works connected to a microcontroller – the good thing about it is that you can change the LED effect whenever you feel like – just need to modify the code).
Flora RGB Smart NeoPixel programmed with a rainbow effect;
3D printed box (Base model downloaded from Thingverse, designed by anewsome, and customized by myself using the Tinkercad software);
Satin keychain;
Wires;
Reflective fabric to customize the eyes;
Small breadboard;
Velcro strip.
3D model
Machines/Tools
3D printer Ultimaker 2+;
Drill (to create a tiny hole in the box to pass wires through);
Solder;
Scissor;
Wirecutter;
Hot glue gun.
Reminders
Do not try to use hot glue with wires;
It’s always better to have more work building a switch instead of dealing with wires every time you want to turn on your device;
Be delicate when working with 3d printed small objects. Always be delicate in dealing with small materials.
My final object turned out to be a potential necklace or a luminary that can be hanged anywhere.
This week I worked with Lizzy Chiappini. We were tasked to create a 30 seconds loop stop motion animation video. As a starting point for the process, we saw each other’s portfolio and tried to find out points of intersections in the subjects of our past artworks. We found out that both of us are interested in somehow deconstructing the binarism between humans and nature. We see nature as a environment where we can create dialogues, rather than explore it in a colonial way, just for our own goods, without thinking about and trying to listen to other vegetables/animal/mineral perspectives and the consequences of its exploration.
Find the result of our work here or watch it below.
Stop Motion animation by Fernando Gregorio and Lizzy Chiappini
Notes about the process of creation
After watching and talking about some references as listed below, we decided to work with silhouette paper cut animation. Our initial concept for the storytelling was an egg or a seed from where a half-human/half-vegetal would grow. This initial image made us think about other compositions and combinations of human, animal and vegetable forms.
Gone: An Historical Romance of a Civil War as It Occurred b’tween the Dusky Thighs of One Young Negress and Her Heart, 1994, by Kara Walker
The whole process was very fluid and we could develop the concept and change the initial storyboard while we were going deeper with the practice. It was very pleasant to collaborate with Lizzy, who also has an artistic background and is opened for experimental processes.
The shooting was long and slow, but very pleasant. We had to split it in two different days, which can be noticed by the sudden light change in the animation, probably because we didn’t notice that the light table was upside down. The hardest part was fitting some big elements inside of our seed and moving them separately. Sometimes we had to cut them in the middle to be able to do it.
Materials
Canon 5D Mark III;
Lens with Zoom;
Power Supply for the camera;
Mini USB Cable;
Tripod;
Software: Dragon Frame;
Light Table;
Black Paper;
Scissors;
Pencils to move the papers slowly while animating.
Wire to articulate/create the joints of our characters;
Tape to glue the joints and our elements to the light table while they shouldn’t move.
My midterm project for physical computing is an ongoing project. I’m creating a performative poem about a cyborg bird who died in the middle of the city. Where the bird died, a tree grew, because the bird had an invisible seed inside their belly. What is this seed made of and how does this tree look like?
The first version of the wearable LED strip
To tell this story I will use gestures (Dance), Light (LED), Words and Sound (Voice, and maybe other effects). To do so, I want to create a wearable for my hands with LED’s that change its colors according to the gesture I do with my hands. I’m going to start with two words:gestures: Fire, Bird, Tree, Seed and Death.
The video below shows how far I got by my midterm deadline. Using Arduino, I created a physical interface with two switches and a led strip containing the number of LEDs I’ll have in my hands. Using serial communication, the code is connected to a p5.js interactive interface that I designed.
The initial state of the strip is blinking white and on the screen you see random letters floating and vibrating around the canvas.
If you press 1 button, the strip turns blue and you can read bird on the screen;
if you press another button, the strip turns green and you can read tree on the screen;
if you press both switches together, the strip turns red and you can read fire on the screen.
Video showing the switches changing simultaneously the color of the LED strip and the words on the screen
Arduino code
To communicate with the LEDs I started studying the Neopixel library. Some of my fellows advised me to use the FastLED instead, so I may study that option too. Thanks to Max da Silva, who helped me a lot with this code.
##Arduino Code for the project finding words
#include <Adafruit_NeoPixel.h>
// Which pin on the Arduino is connected to the NeoPixels?
#define LED_PIN 6
// How many NeoPixels are attached to the Arduino?`
#define LED_COUNT 8
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
const int indexSwitch = 2; //define the normally opened switch activated by the index finger in the PIN 2
const int thumbSwitch = 3; //define the normally opened switch activated by the thumb finger in the PIN 3
void setup() {
Serial.begin(9600);
pinMode(indexSwitch, INPUT); //define the PIN as an INPUT
pinMode(thumbSwitch, INPUT); //define the PIN as an INPUT
strip.begin(); // Initialize NeoPixel strip object
strip.setBrightness(10); // Set BRIGHTNESS to about 1/5 (max = 255)
strip.show(); // Initialize all pixels to 'off'
}
void loop() {
if (digitalRead(indexSwitch) == HIGH && digitalRead(thumbSwitch) == HIGH) { //if both switches are pressed
//fire led effect - color red
uint32_t red = strip.Color(255, 0, 0);
colorWipe(red, 0);
Serial.println(4); //write the number 4 in the serial monitor
} else if (digitalRead(indexSwitch) == HIGH) { //if the index finger button is pressed
//tree led effect - color green
uint32_t green = strip.Color(0, 255, 0);
colorWipe(green, 0);
Serial.println(2); //write the number two in the serial monitor
} else if (digitalRead(thumbSwitch) == HIGH) {
//bird led effect - color blue
uint32_t blue = strip.Color(0, 0, 255);
colorWipe(blue, 0);
Serial.println(3); //write the number 3 in the serial monitor
} else {
blink(); //blink white if none of the buttons are pressed
Serial.println(0); //write zero in the serial monitor
}
delay(10);
}
//define how the blink function works
void blink(){
uint32_t white = strip.Color(255, 255, 255);
colorWipe(white, 0);
delay(30);
uint32_t off = strip.Color(0, 0, 0);
colorWipe(off, 0);
delay(30);
}
void colorWipe(uint32_t color, int wait) {
for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
strip.setPixelColor(i, color); // Set pixel's color (in RAM)
strip.show(); // Update strip to match
delay(wait); // Pause for a moment
}
}
Wearable and other materials research
Materials used during the process
In general, I had a lot of trouble trying to build my wearable. First of all, I chose to work with reflective fabric, which is very complicated to sew because its to thick, although it’s beautiful and connects perfectly with my concept that will try to explore themes around mineral extractivism. Thus, I will continue working with it, but need to find a more sewable version of it.
Fabric research – I got these samples for free at Mood store in the Garment District in Manhattan
After not being able to sew the reflective fabric, I used a general fabric that we have in our soft lab at ITP to build the first prototype. By the way, Idith, who is responsible for this space, helped me a lot with advice and lending me some materials such as conductive fabric and thread. The thread that I had bought had a really bad quality – it is important to check its conductivity before using it and sewing every line two times to improve the quality of the current you get.
Tests with sewable LEDs and reflective fabric
I chose to work with individual sewable Neopixels by Adafruit to have more freedom to place the LEDs as I wanted, and to have a more flexible and more convenient base for them, comparing to general LED strips. Therefore, I’ll have a more organic and adaptable format for my hands and gestures.
Myself presenting the project in class. Photo by Tianjun Wang s2
For my ICM midterm project, I created my first experiment with coding and words. This is a kind of interactive poetry that I’m working on to combine with physical computing, in a way that each word is going to be activated by gestures that press wearable switches. In the future, this is going to be presented as a live storytelling performance.
Some screenshots showing random results generating visual poetry
This is a work in progress. Find the code before I included the serial communication commented above; try it or edit it on the p5.js online editor here; and find the code after I included the serial communication to activate each word with a different button here.
//press the mouse or your keyboard or both together to see or combine the words bird and fire.
//define each letter of the word as a different piece of data in the array identified by an index number
let bird = ["b", "i", "r", "d"];
let fire = ["f", "i", "r", "e"];
//define the distance between the letters when a word is written
let betweenletters = 20;
function setup() {
createCanvas(600, 400);
}
//write the word putting its letters from the array together
function renderWord(word) {
for (i = 0; i < word.length; i += 1) {
fill(random(0, 360), 180, 100, 100);
text(word[i], (width / 2 - (betweenletters * 2)) + i * betweenletters, height / 2);
}
}
//position each letter of the word in a random position in the canvas and change its color randomly over time
function randomLetters(word) {
for (i = 0; i < word.length; i += 1) {
fill(random(0, 360), 100, 100);
text(word[i], random(0, width), random(0, height));
}
}
function draw() {
colorMode(HSB);
background(255);
textSize(28);
translate(random(-1, 1), random(-1, 1)); //vibrant visual effect
if (mouseIsPressed) {
renderWord(fire);
}else{
randomLetters(fire);
}
if (keyIsPressed == true) {
renderWord(bird);
}else{
randomLetters(bird);
}
}
I think that some memories need to be preserved as well as some future presences, that don’t exist yet, need to materialize themselves. And to do so, I feel like telling a story. It’s a story about a cyborg bird who died in the middle of the city and, where they died, a tree grew because the bird was carrying an invisible seed inside their belly.
To tell this story I want to create a live performance containing: Gestures (Dance), Light (LED), Words and Sound (Voice, and maybe other effects). Therefore, my Pcomp midterm is going to be the first experience towards that story that I don’t know yet.
Drawing the circuit for the fire bird
My initial plan is to create a wearable for my hands, which contains LED’s that change its color effects according to the gestures I make. I’m going to start with two words/gestures: Fire and Bird. The color effects are going to be activated by two different buttons made with conductive fabric located in different parts of my hands.
As a first try connecting the wearable with P5.js animations, I would like to create a program that writes a different word on the screen according to the gesture I make with my hands.
Fire and Bird. The dots represent the LED position.
Materials I need
Conductive fabric to create the buttons;
Flora RGB Smart NeoPixel version 2 – Sheet of 20;
Stainless Thin Conductive Thread;
Gloves (think about the fabric/design – use transparency);
Microcontroller – Arduino;
Power Supply.
Doubts
Is it better to connect the LED’s as if they were one strip or two (one for each hand, connected to different digital ports)?
How to use a battery? And what’s the best battery to use in this project?
This week I learned how to create functions and objects and how it can be applied to create repetitions and modulations. The code that I chose to do it was kind of tricky because some parts of the variables I used to create it, needed to be defined in the setup function, some in the draw, and some outside both, so I’m not sure if I organized it in the best way. Find the code here. Therefore, I’ll try to do it in another code I created before – the Rainbow Creature.
Ps: finally I got to create a rainbow gradient animation. To do so, I used colorMode(HSB) and a simple variable which goes up to 360 and turn into 0 again:
For the past few weeks, I’ve been struggling to learn Pcomp. I feel that the ability to mix coding with electronics is something that takes a lot of time to assimilate, considering that both are quite new universes for me.
Hence, I started to create new learning strategies to find ways to study on my own and organize information. First, I created a new workflow using the app Notion, which allows me to put together and link in a very visual and accessible way all the resources that I need to quickly access when studying for Pcomp. Secondly, I mapped places where I can find the information I need when doing exercises, for example, the books “Learn Electronics with Arduino: An Illustrated Beginner’s Guide to Physical Computing” and “Physical Computing: Sensing and Controlling the Physical World with Computers“, and also the page of the class itself, and the Arduino website. Thirdly, I decided to focus on doing all the labs from the Syllabus instead of trying to be creative or making up applications for the circuits that I’m learning to build. I also printed a lot of things that I need to memorize, such as Arduino’s functions and basic rules for electronics and stuck to the wall of my bedroom, so I can always look at it.
This week I focused on Labs 2 and 3. Lab 2 was about Digital Input, so it purposes using a button to change how LED’s behave. The lab went well, I just don’t understand exactly why do I need a Pulldown resistor to create a button.
Lab 2 – Button and Led
Lab 3 was focused on Analog Input. First using a potentiometer to change the brightness of an LED and then changing the led for a speaker, in a way that the analog signal of the potentiometer changes the frequency of the sound.
Lab 3 – Using forcing sense resistors to change the brightness of LEDS
Last part of the lab was variating the brightness of two different LEDs in sequence according to the pressure applied to two different Force Sense Resistors. In general, I understand well how to prototype, but I feel I need to improve my skills creating and reading the codes and getting to know better how electricity behaves in relation with data and vice-versa.
This week I tried to explore repetition with equilaterals triangles. I’m still trying to figure out how to improve this code regarding color interaction and the size of the triangle in relation to the size of the canvas. Find the code here.
