Champaign-Urbana Community Fab Lab
University of Illinois at Urbana-Champaign
Champaign-Urbana Community Fab Lab

Author Archive

Christian Amato Iteration Assignment

For this assignment, I was inspired by Emilie’s idea that she was going to make a lit-up acrylic sign in layers using neo-pixels and a 3D base. I decided I wanted to go one step further and add an ultrasonic sensor to the front of the base to light up the sign based upon the distance away from you.

 

 

This was my nametag, to begin with, and from there I decided I wanted to display the information in sequence, with my hobbies at the front, my information in the middle and my name at the back. 

 

 

I also kept the same original bear, as that’s my favorite animal but I made it much larger, to approximately 4.5 inches to stay within the realm of the 3D printer base. 

 

 

 

 

This was the overall design I created through Tinkercad with my measurements to scale. 

 

 

But some of my measurements were not correct and were actually in millimeters instead of centimeters, which led me to have holes that were too small to hold the acrylic, and a cavity that was too narrow to house the ultrasonic sensor and the Arduino. 

 

 

As you can tell, the dimensions for the acrylic cut-outs were way too small which could have been a big problem if I had not had access to a Dremel to widen the holes.

 

Thankfully, even with scaling issues, the Neopixel cavity was still wide enough to house the pixels and the perfect length to carry four pixels without any hanging off the edges. This took 8.5 hours to print. 

 

 

 

 

At first, I decided that I wanted to drill out the holes for the Neopixels, but the drill bit and the plastic combination was making it extremely difficult to make consistent cuts without falling into a previous hole. 

 

 

I have used a Dremel in the past and really did not want to use it, but it was my only option at that point. The Dremel’s friction heated the plastic so hot that I was able to rip out the melted strands of plastic with the needle-nose pliers. It was arduous and honestly a huge waste of my time because it could have so easily been avoided with proper measurements 

By widening the holes for the acrylic, it also allowed for larger amounts of light to illuminate the acrylic pieces, which was overall a great thing. 

 

 

Next, I used a soldering iron and soldered the Neopixels in series. I thought it would be generally easy to do but soldering with such small contacts my first time took a ton of trial and error.

 

After a failed first attempt after wiring them from the wrong side of the arrow, Brandon generously helped me rewire from the front side. 

 

 

 

From that point, I wired up the ultrasonic sensor by drilling two holes in the front, along with the Neopixels and as you can see from the picture, the housing was very snug. 

 

 

 

 

 

 

 

 

 

 

This is how it looked without any illumination. 

 

 

I think it could have looked much cleaner without the hot glue, but it was necessary to keep it sturdy. 

 

 

Here is the video of the Neopixels in action without the ultrasonic sensor. I really thought this looked a lot better than the plain colors that I found on the ultrasonic sensor. 



Then, I also decided I wanted to use the Ultrasonic sensor to trigger the lights. 



REFLECTION

I thought this project really used a culmination of all the skills I have developed over this course. I utilized the knowledge I had from the 3D printing unit to create a 3D model that would serve as the base for the entire project using Tinkercad. From there I expanded my knowledge of the Arduino and the code that would end up controlling the entire device. I used the laser cutter again, learned what Neopixels are and the practically unlimited potential for different use. I honed my soldering skills and understood the danger behind lead poisoning. I utilized the drill and the Dremel to cut the housing unit to larger specs. I think this project was great because it allowed me to really use a wide array of devices and in the end it actually functioned. 

What went well?

I think the fact that Adafruit has a large array of test codes for Neopixels aided in the overall aesthetic of the design. The coincidence that I was using white 3D printing plastic was also a huge surprise to see how the Neopixels lit up the honeycomb designs on the inside. I thought it really looked great at the end. I think the soldering took a lot of patience but was worth it when it worked on the second try. Brandon was very helpful in showing me how to properly solder, and talking about the importance of cleaning the solder tip to make the solder go down more smoothly. 

What could I have done differently?

I think the 3D printing of the base was the hardest part of the project. From the beginning, the dimensions were really not right, and it forced me to rip it apart and use a Dremel to try and accommodate the larger components. I got really lucky with the base cavities somehow being the exact right length for the Arduino and the Neopixels being the exact width to fit in the cavities. But as you can see the base is not flat at all. Its curved on all sides and I noticed this after only 10 minutes of printing. I should have put something that would stick all the plastic to the base of the forge so that it would have been nice and neat. My number one takeaway from this project is to measure twice and cut once. Because of this, I bought a digital caliper for use in my future projects!

Arduino Code-

// Turning NeoPixels on and off using a HC-SRO4 Ping Sensor

/*

This sketch reads a HC-SR04 ultrasonic rangefinder and returns the

distance to the closest object in range. To do this, it sends a pulse

to the sensor to initiate a reading, then listens for a pulse

to return. The length of the returning pulse is proportional to

the distance of the object from the sensor.


The Arduino then takes this information and illuminates a strip of
NeoPixel’s based on the distance of the object from the sensor.

This code was developed partially from Ping))) code found in the public domain
written by David A. Mellis, and adapted to the HC-SRO4 by Tautvidas Sipavicius,
while other portions were written by Charles Gantt and Curtis Gauger from
http://www.themakersworkbench.com.
*/

//Tell the Arduino IDE to include the FastLED library
#include <FastLED.h>

//Setup the variables for the HC-SR04
const int trigPin = 8;
const int echoPin = 7;

//Setup the variables for the NeoPixel Strip
#define NUM_LEDS 12 // How many leds in your strip?
#define DATA_PIN 6 // What pin is the NeoPixel’s data line connected to?
CRGB leds[NUM_LEDS]; // Define the array of leds

void setup() {
// initialize serial communication:
Serial.begin(9600);
FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
}

void loop()
{
// establish variables for duration of the ping,
// and the distance result in inches and centimeters:
long duration, inches, cm;

// The sensor is triggered by a HIGH pulse of 10 or more microseconds.
// Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
pinMode(trigPin, OUTPUT);
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

// Read the signal from the sensor: a HIGH pulse whose
// duration is the time (in microseconds) from the sending
// of the ping to the reception of its echo off of an object.
pinMode(echoPin, INPUT);
duration = pulseIn(echoPin, HIGH);

// convert the time into a distance
inches = microsecondsToInches(duration);
cm = microsecondsToCentimeters(duration);

Serial.print(inches);
Serial.print(“in, “);
Serial.print(cm);
Serial.print(“cm”);
Serial.println();

if (inches <= 20) {fill_solid( &(leds[0]), NUM_LEDS /*number of leds*/, CRGB::Blue); //{whitestrobe(30);
FastLED.show();

}
else if (inches >= 21) {fill_solid( &(leds[0]), NUM_LEDS /*number of leds*/, CRGB::Black);
FastLED.show();
}

delay(100);
}

long microsecondsToInches(long microseconds)
{
// According to Parallax’s datasheet for the PING))), there are
// 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
// second). This gives the distance travelled by the ping, outbound
// and return, so we divide by 2 to get the distance of the obstacle.
// See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds)
{
// The speed of sound is 340 m/s or 29 microseconds per centimeter.
// The ping travels out and back, so to find the distance of the
// object we take half of the distance travelled.
return microseconds / 29 / 2;
}

ARDUINO ADAFRUIT CODE

// NeoPixel test program showing use of the WHITE channel for RGBW
// pixels only (won’t look correct on regular RGB NeoPixel strips).

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif

// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1:
#define LED_PIN 6

// How many NeoPixels are attached to the Arduino?
#define LED_COUNT 12

// NeoPixel brightness, 0 (min) to 255 (max)
#define BRIGHTNESS 50

// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRBW + NEO_KHZ800);
// Argument 1 = Number of pixels in NeoPixel strip
// Argument 2 = Arduino pin number (most are valid)
// Argument 3 = Pixel type flags, add together as needed:
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
// NEO_KHZ400 400 KHz (classic ‘v1’ (not v2) FLORA pixels, WS2811 drivers)
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
// NEO_RGBW Pixels are wired for RGBW bitstream (NeoPixel RGBW products)

void setup() {
// These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
// Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
clock_prescale_set(clock_div_1);
#endif
// END of Trinket-specific code.

strip.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
strip.show(); // Turn OFF all pixels ASAP
strip.setBrightness(50); // Set BRIGHTNESS to about 1/5 (max = 255)
}

void loop() {
// Fill along the length of the strip in various colors…
colorWipe(strip.Color(255, 0, 0) , 50); // Red
colorWipe(strip.Color( 0, 255, 0) , 50); // Green
colorWipe(strip.Color( 0, 0, 255) , 50); // Blue
colorWipe(strip.Color( 0, 0, 0, 255), 50); // True white (not RGB white)

whiteOverRainbow(75, 5);

pulseWhite(5);

rainbowFade2White(3, 3, 1);
}

// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single ‘packed’ 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
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
}
}

void whiteOverRainbow(int whiteSpeed, int whiteLength) {

if(whiteLength >= strip.numPixels()) whiteLength = strip.numPixels() – 1;

int head = whiteLength – 1;
int tail = 0;
int loops = 3;
int loopNum = 0;
uint32_t lastTime = millis();
uint32_t firstPixelHue = 0;

for(;;) { // Repeat forever (or until a ‘break’ or ‘return’)
for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip…
if(((i >= tail) && (i <= head)) || // If between head & tail…
((tail > head) && ((i >= tail) || (i <= head)))) {
strip.setPixelColor(i, strip.Color(0, 0, 0, 255)); // Set white
} else { // else set rainbow
int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));
}
}

strip.show(); // Update strip with new contents
// There’s no delay here, it just runs full-tilt until the timer and
// counter combination below runs out.

firstPixelHue += 40; // Advance just a little along the color wheel

if((millis() – lastTime) > whiteSpeed) { // Time to update head/tail?
if(++head >= strip.numPixels()) { // Advance head, wrap around
head = 0;
if(++loopNum >= loops) return;
}
if(++tail >= strip.numPixels()) { // Advance tail, wrap around
tail = 0;
}
lastTime = millis(); // Save time of last movement
}
}
}

void pulseWhite(uint8_t wait) {
for(int j=0; j<256; j++) { // Ramp up from 0 to 255
// Fill entire strip with white at gamma-corrected brightness level ‘j’:
strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
strip.show();
delay(wait);
}

for(int j=255; j>=0; j–) { // Ramp down from 255 to 0
strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
strip.show();
delay(wait);
}
}

void rainbowFade2White(int wait, int rainbowLoops, int whiteLoops) {
int fadeVal=0, fadeMax=100;

// Hue of first pixel runs ‘rainbowLoops’ complete loops through the color
// wheel. Color wheel has a range of 65536 but it’s OK if we roll over, so
// just count from 0 to rainbowLoops*65536, using steps of 256 so we
// advance around the wheel at a decent clip.
for(uint32_t firstPixelHue = 0; firstPixelHue < rainbowLoops*65536;
firstPixelHue += 256) {

for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip…

// Offset pixel hue by an amount to make one full revolution of the
// color wheel (range of 65536) along the length of the strip
// (strip.numPixels() steps):
uint32_t pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());

// strip.ColorHSV() can take 1 or 3 arguments: a hue (0 to 65535) or
// optionally add saturation and value (brightness) (each 0 to 255).
// Here we’re using just the three-argument variant, though the
// second value (saturation) is a constant 255.
strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue, 255,
255 * fadeVal / fadeMax)));
}

strip.show();
delay(wait);

if(firstPixelHue < 65536) { // First loop,
if(fadeVal < fadeMax) fadeVal++; // fade in
} else if(firstPixelHue >= ((rainbowLoops-1) * 65536)) { // Last loop,
if(fadeVal > 0) fadeVal–; // fade out
} else {
fadeVal = fadeMax; // Interim loop, make sure fade is at max
}
}

for(int k=0; k<whiteLoops; k++) {
for(int j=0; j<256; j++) { // Ramp up 0 to 255
// Fill entire strip with white at gamma-corrected brightness level ‘j’:
strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
strip.show();
}
delay(1000); // Pause 1 second
for(int j=255; j>=0; j–) { // Ramp down 255 to 0
strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
strip.show();
}
}

delay(500); // Pause 1/2 second
}

 

Continue Reading

Pom Bot- Christian Amato

This week we learned how to program Arduinos and use them to operate inputs and outputs further than the previous week. 

In class, I created this squirrel with a wagging tail by manipulating the delay sequences in the Arduino itself. I was pretty impressed with the overall result, considering it only took me the class period to finish it, and the servo was built right into the animal. I think it was a great introduction to using motors in the Arduino application. Here is a video below.  

squirrel

From then on, we were tasked with creating something that utilized more than one motor, to create a pom bot that utilized many motors and moved in a similar fashion to an actual living creature. 

This led me to think of some intricate movement, and an animal that I really like is the penguin. I thought to create the waddle was something that could be achieved with servo motors so I decided to go for it. I looked up some pictures of penguins online and the waddle they do involves lifting their feet ever so slightly off the ground. I thought that this could be mimicked using a total of 4 servos acting as the legs, and the Arduino over-top of the servos acting as the torso. 

The circuitry involved in this was pretty straight forward, but I chose to make it as compact as possible by zip tieing a breadboard atop the Arduino and using breadboard wires so the entire torso was as flat as possible. I also liked the breadboard wires better than the traditional pin wiring that came in the kit because they seemed to have a better connection. 

As you can see in the diagram above, I wired a connection for 4 servo motors, wired in parallel using the breadboard. This was very intuitive, and unlike the Arduino where ports matter, a breadboard is free to interpretation so long as all the wires make it to their respective rows. 

From then I decided to get started on the lower portion of the body, which was glued together upside down and to a popsicle stick that I could fuse together to the bottom of the Arduino enclosure.

As you can see they closely resemble hips and legs, which is exactly what I wanted. 

Preceding this, It was important that the servos were all fused together as sturdily as possible. 

 

 

 

To make sure there was a strong bond between the legs, I used the helping hands and first applied superglue which took forever to dry.

I thought the superglue would be thicker, like hot glue but it kind of just bonded the small surface area of the two points together to a small degree. 

I decided to go over the joints with hot glue to ensure that they would maintain their rigidity during movements. 

 

bad legs

 

From the title of this video, these legs clearly were not the best for this case. 

So I thought about it further and decided the best course of action would be to utilize the 3D printer to make a triangular part that could connect both of the servos together, forming a rigid bond. 

 

 

This was the piece I created————>

 

 

And this is how the legs turned out after-

 

 

 

From this rigidity, I was able to make more forceful movements to propel the penguin forward

 

 

 

 

 

 

 

 

 

 

 

The legs were fully capable of holding up the entire Arduino from the bottom, and it was even balanced without really even trying. 

 

 

 

 

Here is a video of the bot walking. Pombot action

 

 

REFLECTION

I loved this unit the most so far, it was really fun to create something that actually runs off a code that you can manipulate, and especially to see what you can do with so little in terms of money. I thought the things that were most important in this unit were understanding how to build the overall bot itself, to be efficient and strong standing. From the building, all aesthetics can be added on after the fact. 

What I would do differently

I think the possibilities with Arduinos are absolutely endless, and getting caught up in the minutia of the technical aspects is very easy to do when you are manipulating something that involves so many ins and outs. I would definitely take more time to plan out what exactly I wanted to accomplish in my time at the lab and work on tighter deadlines. I think that had the setback of the broken legs not set me back, I could have utilized the 3 hours I spent making the first legs into 20 minutes using the 3D printer which literally took 3 minutes per triangle. If I had that extra two hours, I would have been able to make my bot really stand out, I would have used black fleece and could have sewed a working body around it. I think my main distraction, in this case, is not utilizing my time outside of the lab to devise better plans on how I want to get the projects done on time. 

 

 

 

 

 

 

 

 

 

 

Continue Reading

Arduino Project

For this project, in class, we were taught the basics of Arduino, a product I have seen many times online before but have never actually used it. 

It was a quick introduction to

using an LED to light upon a breadboard using a connective circuit utilizing aluminum foil. It was quick and easy and interesting to do. 

As you can see the circuit was made possible by decreasing the threshold for activation and moving it away from any interference. I thought it turned out to be very cool.

 

We then introduced sequencing into the code to make the Arduino blink in intervals by adjusting the time it started and ended. 

 

MY PROJECT

For my project’s inspiration, I recently went to a casino for my brother’s bachelor party and we were playing the game BlackJack. From one lucky hand, my brother won a substantial amount of money but it was cashed out in all cash. From this cash, he placed it in his hotel room so he would not lose it but was sort of nervous that it might get stolen when we went out that night. I thought about this predicament using some sort of security to alert if someone had come close to the money and therefore may take it. 

I did some research into the sonar sensor in the Arduino and thought it would be a perfect fit for the predicament my brother ran into a few months ago. Then I started doing some research into it and found that most of the sonar output was a buzzer but my kit did not have one. Then I thought about using the LED screen but it did not really make sense too because we would not be there to monitor it. Then I found an open-source code that utilized Sonar Radar which I thought would be perfect for this. 

I realized that the Arduino Uno is not capable of utilizing wifi, and therefore any signals that are output would go through the Arduino serial output itself. 

This led me to find a program called “Processing” which can take the output from the Arduino and articulate it into a Sonar Radar type output. 

Here is a video of the sonar in action. 

arduino action

Here is the source code for the Arduino

// Includes the Servo library
#include <Servo.h>.
// Defines Tirg and Echo pins of the Ultrasonic Sensor
const int trigPin = 10;
const int echoPin = 11;
// Variables for the duration and the distance
long duration;
int distance;
Servo myServo; // Creates a servo object for controlling the servo motor
void setup() {
pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
pinMode(echoPin, INPUT); // Sets the echoPin as an Input
Serial.begin(9600);
myServo.attach(12); // Defines on which pin is the servo motor attached
}
void loop() {
// rotates the servo motor from 15 to 165 degrees
for(int i=15;i<=165;i++){
myServo.write(i);
delay(30);
distance = calculateDistance();// Calls a function for calculating the distance measured by the Ultrasonic sensor for each degree

Serial.print(i); // Sends the current degree into the Serial Port
Serial.print(“,”); // Sends addition character right next to the previous value needed later in the Processing IDE for indexing
Serial.print(distance); // Sends the distance value into the Serial Port
Serial.print(“.”); // Sends addition character right next to the previous value needed later in the Processing IDE for indexing
}
// Repeats the previous lines from 165 to 15 degrees
for(int i=165;i>15;i–){
myServo.write(i);
delay(30);
distance = calculateDistance();
Serial.print(i);
Serial.print(“,”);
Serial.print(distance);
Serial.print(“.”);
}
}
// Function for calculating the distance measured by the Ultrasonic sensor
int calculateDistance(){

digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH); // Reads the echoPin, returns the sound wave travel time in microseconds
distance= duration*0.034/2;
return distance;
}

Here is the source code for the Sonar

import processing.serial.*; // imports library for serial communication
import java.awt.event.KeyEvent; // imports library for reading the data from the serial port
import java.io.IOException;
Serial myPort; // defines Object Serial
// defubes variables
String angle=””;
String distance=””;
String data=””;
String noObject;
float pixsDistance;
int iAngle, iDistance;
int index1=0;
int index2=0;
PFont orcFont;
void setup() {

size (1200, 700); // ***CHANGE THIS TO YOUR SCREEN RESOLUTION***
smooth();
myPort = new Serial(this,”/dev/cu.usbserial-1420″, 9600); // starts the serial communication
myPort.bufferUntil(‘.’); // reads the data from the serial port up to the character ‘.’. So actually it reads this: angle,distance.
}
void draw() {

fill(98,245,31);
// simulating motion blur and slow fade of the moving line
noStroke();
fill(0,4);
rect(0, 0, width, height-height*0.065);

fill(98,245,31); // green color
// calls the functions for drawing the radar
drawRadar();
drawLine();
drawObject();
drawText();
}
void serialEvent (Serial myPort) { // starts reading data from the Serial Port
// reads the data from the Serial Port up to the character ‘.’ and puts it into the String variable “data”.
data = myPort.readStringUntil(‘.’);
data = data.substring(0,data.length()-1);

index1 = data.indexOf(“,”); // find the character ‘,’ and puts it into the variable “index1”
angle= data.substring(0, index1); // read the data from position “0” to position of the variable index1 or thats the value of the angle the Arduino Board sent into the Serial Port
distance= data.substring(index1+1, data.length()); // read the data from position “index1” to the end of the data pr thats the value of the distance

// converts the String variables into Integer
iAngle = int(angle);
iDistance = int(distance);
}
void drawRadar() {
pushMatrix();
translate(width/2,height-height*0.074); // moves the starting coordinats to new location
noFill();
strokeWeight(2);
stroke(98,245,31);
// draws the arc lines
arc(0,0,(width-width*0.0625),(width-width*0.0625),PI,TWO_PI);
arc(0,0,(width-width*0.27),(width-width*0.27),PI,TWO_PI);
arc(0,0,(width-width*0.479),(width-width*0.479),PI,TWO_PI);
arc(0,0,(width-width*0.687),(width-width*0.687),PI,TWO_PI);
// draws the angle lines
line(-width/2,0,width/2,0);
line(0,0,(-width/2)*cos(radians(30)),(-width/2)*sin(radians(30)));
line(0,0,(-width/2)*cos(radians(60)),(-width/2)*sin(radians(60)));
line(0,0,(-width/2)*cos(radians(90)),(-width/2)*sin(radians(90)));
line(0,0,(-width/2)*cos(radians(120)),(-width/2)*sin(radians(120)));
line(0,0,(-width/2)*cos(radians(150)),(-width/2)*sin(radians(150)));
line((-width/2)*cos(radians(30)),0,width/2,0);
popMatrix();
}
void drawObject() {
pushMatrix();
translate(width/2,height-height*0.074); // moves the starting coordinats to new location
strokeWeight(9);
stroke(255,10,10); // red color
pixsDistance = iDistance*((height-height*0.1666)*0.025); // covers the distance from the sensor from cm to pixels
// limiting the range to 40 cms
if(iDistance<40){
// draws the object according to the angle and the distance
line(pixsDistance*cos(radians(iAngle)),-pixsDistance*sin(radians(iAngle)),(width-width*0.505)*cos(radians(iAngle)),-(width-width*0.505)*sin(radians(iAngle)));
}
popMatrix();
}
void drawLine() {
pushMatrix();
strokeWeight(9);
stroke(30,250,60);
translate(width/2,height-height*0.074); // moves the starting coordinats to new location
line(0,0,(height-height*0.12)*cos(radians(iAngle)),-(height-height*0.12)*sin(radians(iAngle))); // draws the line according to the angle
popMatrix();
}
void drawText() { // draws the texts on the screen

pushMatrix();
if(iDistance>40) {
noObject = “Out of Range”;
}
else {
noObject = “In Range”;
}
fill(0,0,0);
noStroke();
rect(0, height-height*0.0648, width, height);
fill(98,245,31);
textSize(25);

text(“10cm”,width-width*0.3854,height-height*0.0833);
text(“20cm”,width-width*0.281,height-height*0.0833);
text(“30cm”,width-width*0.177,height-height*0.0833);
text(“40cm”,width-width*0.0729,height-height*0.0833);
textSize(40);
text(“CAmato Arduino Radar “, width-width*0.875, height-height*0.0277);
text(“Angle: ” + iAngle +” °”, width-width*0.48, height-height*0.0277);
text(“Distance: “, width-width*0.26, height-height*0.0277);
if(iDistance<40) {
text(” ” + iDistance +” cm”, width-width*0.225, height-height*0.0277);
}
textSize(25);
fill(98,245,60);
translate((width-width*0.4994)+width/2*cos(radians(30)),(height-height*0.0907)-width/2*sin(radians(30)));
rotate(-radians(-60));
text(“30°”,0,0);
resetMatrix();
translate((width-width*0.503)+width/2*cos(radians(60)),(height-height*0.0888)-width/2*sin(radians(60)));
rotate(-radians(-30));
text(“60°”,0,0);
resetMatrix();
translate((width-width*0.507)+width/2*cos(radians(90)),(height-height*0.0833)-width/2*sin(radians(90)));
rotate(radians(0));
text(“90°”,0,0);
resetMatrix();
translate(width-width*0.513+width/2*cos(radians(120)),(height-height*0.07129)-width/2*sin(radians(120)));
rotate(radians(-30));
text(“120°”,0,0);
resetMatrix();
translate((width-width*0.5104)+width/2*cos(radians(150)),(height-height*0.0574)-width/2*sin(radians(150)));
rotate(radians(-60));
text(“150°”,0,0);
popMatrix();
}

Reflection

Overall this project went smoother than I thought. I believe that the source code online was very helpful in my overall execution of the project. The contact wires on the Arduino seemed to be a little shaky with the movement of the motor, but I think it came together very nicely in the end.

What I would do differently

If I could do this over again I would use a different Arduino, one that has Wifi capabilities that could send a signal if a person or an object comes within a certain threshold of the money, then I could get an alert on my phone to say that someone would potentially be in the vicinity. I think the possibilities with this are endless though, it just takes some creative backbone to send it in the right direction. I would also get a full breadboard to keep all the components intact and make the connection stronger.

All in all, I really enjoyed working with the Arduino and am eager to get my hands on one of my own for future projects!

 

Continue Reading

Textiles- Red Panda Plushie

These past two weeks we were introduced to the basics of sewing and embroidery.

I have never operated a sewing machine in my life and thought that it would be a tough thing to maneuver but I was pleasantly surprised when I began to get the hang of it. In the first lab section, I learned how to thread a sewing machine and the basics of operation including what a bobbin is, how to thread a machine and the basic importance of understanding what not to do during operation.

In class, we were shown how to create bags that were made of cotton. Once I created the bag I was really intrigued as to how I could make it look as good as possible. This led me to make the tassels on the side out of fabric, double-sided using the iron. I was really pleased with the overall quality of the product at the end.

Then we were introduced to the embroidery machine, utilizing Ink Scape and the sewing software to create a 3 color embroidered patch. 

With the historic KAMS closing that week I decided to draw inspiration from the infamous logo.

The final product was great, all I had to do was take apart the connected stitching. 

WEEK 2

The final project I worked on was creating the Red Panda Plushie that was given as a pattern. 

I started by cutting all my materials out of fleece that I found in the scrap drawer. 

 

All of these pieces were then used to construct one aspect or another of the body of the plushie.

 

Feet of the panda

The feet of the plushie after being flipped outside

Hand Sewing the mouth on because I forgot to include this before sewing the bear up!

The bear and the tail waiting to be hand sewn together

The final product with embroidered Kung Fu Panda

 

Overall I was really happy with how this turned out, I followed the instructions to a tee mostly and am happy with the quality that I got for using all scraps. The process was really time-consuming and I think the majority of the time was spent making sure that all of the fleece pieces were cut extremely accurately. I thought this would aid in the overall look and I am sure it did but I did realize that it really comes down to how skilled I am at sewing the pieces together that has a larger effect on the appearance of the bear. Duncan and Emilie were especially helpful in troubleshooting the sewing machine and providing techniques for me to deal with mishaps in the overall project.

What I would do differently

Buy better materials. I think that the bear has some really great potential to be something that I might want to make again using better materials. If I had the ability to go to Jo-Ann fabrics and get some of that Minky fabric I definitely would have because I saw how much of a difference it made in other students’ projects. Also, I would make sure to embroider the patch onto the fabric first before sewing up the body, along with the mouth. I realize that mistake was also a factor in the presentation of the overall product, but I do not think that it affected the look as much as I thought it would have. I also would take more time to plan and execute the project because it would have saved me time in the long run and would not have necessitated such long periods of uninterrupted work which I think had consequences in the overall quality of the product. 

Continue Reading

3D Printing

In class, we began by being introduced to TinkerCad and MeshMixer and were asked to create a fortress and a person that would be in that fortress.

This was what I came up with.

Then I exported the creature into MeshMixer and played around with it from there, learning how to use the tools properly.


That was what I came up with, very funky but I thought it was interesting to just play with the tools in the software.

Then came my designs.

These were the sketches I had come up with, but I decided to really render only the flatware design and a piece that I needed.

This was the final rendering of my flatware design, which incorporated a lot of the holing tools in Tinkercad. It is a mix of a fork and a chopstick holder with a tong design circle that holds the chopsticks at either end.

From there I decided I create something that my apartment has been missing, and that is definitely a spoon rester. Whenever I make spaghetti I have nowhere to set my spoon down without sauce getting on something else. I think that this is actually an extremely practical use of the 3D printer and that is why I rendered it.

This was the final product, and I am really happy with it because I used the beveling tool on the cylinders on both the inside and outside making it look very sophisticated.

Class October 1st.

In class today we learned how to use the 3d scanners using the program Skanect, and also used the scanners on an iPad as well. 

iPad Scanner:

The details are decent, but the facial features were not as detailed as the Skanect. 

Skanect Scanner:

The Skanect did a better job of scanning facial features as well, and the overall texture around the facial region and the hair. I think the Skanect is a good tool to use for any scans that require more detail. 

Final Iteration of Design

My overall final design came out really nicely and functions exactly as I wanted it to. 

This is the spoon rester in action, holding a spoon I used to mix eggs with. I really like the overall usefulness in this design, it keeps the countertop clean and is washable under the tap right after I am finished. 

Reflection

I think this project was really smooth from start to finish. The simplicity of the design of this really didn’t give me a lot of trouble in the design process, and printing it was fairly straightforward. The other designs that I made were not going to be that useful and that’s why I chose to print this one. 

What I would do differently

In the future, I would make another design iteration of this that is larger to hold bigger spoons and spatula’s, but the only problem is that the material is not food safe. It was suggested that I could take my design and upload it to a website that makes clay 3D printed objects for a certain price that is food safe.  That would be pretty cool to actually have something that will likely be in my kitchen for a long time and say I actually made that. Definitely something to think about as I move forward in this course.

Heres a link to my actual design

Continue Reading

Paper Circuit- Christian Amato

In class, we began by creating a simple paper circuit. I do not have an image of the completed project, but it was a simple circuit square that powered one LED light using a watch battery. From there, we transitioned from a circuit in series to one in parallel. This part of the project proved to test my limits using resistors and meeting the requirements of the assignment. From the project, I gained some knowledge about how to use copper taping, which was very temperamental compared to traditional wiring using wires. I spent a ton of time on my design of the actual card using the quotes we were provided in class. This was my first mistake. When all was said and done, the copper taping on the back did not conduct any electricity because I was not careful enough when making mitered corners. This brought me to the tail end of class, and my original drawing on my piece was ruined. I then very carefully mapped out the new circuit, giving a large area for making a parallel circuit. As you can see the end result, is not very pretty and not exactly something I was very proud of. From that point forward, I decided that I wanted to incorporate something similar, like a card with a cool pop-out into my final product. I liked the idea of incorporating a silhouette to make a simple and effective design. This led me to design a mockup of the batman logo, and incorporate a cool quote that I could cut out using the silhouette machine. I cut out the batman logo using heavy-duty cardstock and I think it turned out really great. I then cut a notch into the cardstock for the silhouette to pop-out of the card. I then decided to backlight this with two yellow led’s. I originally planned to have the eyes of the batman light up as well, but The copper tape kept ripping whenever it popped out from the card. The overall layout of my design was very carefully mapped out on the back of the card using a grid of copper taping to make it easy to connect everything. This was the layout. It was easy to connect everything, and I ensured everything was properly connected by first laying down the copper taping and then sandwiching another piece of tape over all the connections. I then decided to go a step further and insulate all of the wirings with hot glue to ensure that no connections came loose. I also made a switch for the battery with a piece of folded cardstock. This proved to be very beneficial in conserving the watch batteries. After some trial and error, I finally got all the LED’s to light up at once. This is the final product. I really enjoyed the feeling of actually having my labor pay off to see the lights turn on without a hitch at the end of this project. If I could do anything differently, I would have definitely used a different method when securing the contacts down. Some of them were not as sticky as I wanted and the glue had to be pressed down for contact between some of the lights and the tape. I would love to do this again with new ideas for design because I feel like I have the hang of all of it now. I also would try to find a different way of pasting the letters within the card, by cutting them out of the black cardstock and pasting yellow paper on the backside, I think this would look way better and the glue marks would not have been there. I learned a lot from this project for sure. Continue Reading

Christian Amato- Vinyl Stickers

For this project, I began by creating a one layer vinyl sticker which combined two animals. The front of the animal was a Lion and the rear was a bear. I used the pinpoint feature in Inkscape to make sure all the lines were lined up nicely and the animal had a rear portion that matched the front. I think the overall design turned out very nicely. Design Process For my main design, I chose to do a golden retriever. The colors of the original image were on a gradient for the overall fur, which made it tough to choose exactly what color I wanted to use.

Golden Retriever Cartoon Drawing and Drawing Of Golden Retriever Golden Retriever Puppy – Pencil Sketch Art

I decided to go with beige color for the fur, with a black background to accentuate the lines and overall outline of the body. If there had not been a black background, the body of the dog would have all been meshed into one. I then chose the layers and what specific colors I wanted to print to add more character to the overall sticker. I used silver for the nose and eye, pink for the tongue and white for the teeth and pupils. Once I finished I decided to cover the entire image in a clear vinyl so that the small details would not rub off. Design Problems/What I Would Change I did not have many issues designing this besides the very intricate details on the sticker itself. I found that portions of the sticker did not really cut out perfectly, and it was tough to stick the vinyl on top of other vinyl without it falling off. Overall if I could redo this I would make sure to incorporate fewer small details to the sticker so it wouldn’t be as hard to place them in their correct positions. EDIT/ UPDATE My outside of class design is as follows. I started with a picture of Marshmello album cover art and broke it apart using Inkscape. It was a layered sticker and I ended up printing out each layer and layering them on top of each other. If I could change anything about this, it would definitely be the transfers from each layer to be more smooth. I used all scraps for this project, so some of the vinyl cut-outs were different shapes before I trimmed them all down to 3.5×3.5 to the best of my ability using a paper cutter. I think the execution was decent. I had to manually cut out some redundant portions with an x-acto knife, sort of shifting some of the vinyl. Overall I am happy with the end result for sure though. Continue Reading

Christian Amato Nametag

For my nametag project, I really wanted to put something together that was unique and utilized both rastering and vectoring well and efficiently. Ideation Phase My ideas for the project stemmed mainly from my interests and hobbies. In the beginning lecture with Duncan, he suggested we all play around with an animal silhouette, which led me to choose my favorite and most feared animal, the bear. Bears are crazily capable of attacking predators, they run, climb and swim making any prey extremely vulnerable. Just a fun fact and a part of a conversation I had with friends about what animals they are most fearful of. Next, I decided that I wanted the rastering portion to be a cool font that was mostly rastered but left little indentations that were unrastered as well. This led me to think of an album cover I had seen previously, A$AP Rocky’s Testing album. I like the lines through the font, and I thought it would really add great character to the piece. Next, I decided to add some more information about me, my year and my major/minor. I also thought it would be a good idea to add little depictions of some of my hobbies, hence the golf club and the half-mile sticker. Execution I knew that I wanted the nametag to represent me and my school and that is why I chose to do it on an orange acrylic board. As you can see, the rastering did what I thought it would, and the name tag really didn’t pop at all. Before I snapped a pic, I thought it would be a good idea to somehow fill in the lines with a sort of paint. I decided to go for the full U of I theme which just happens to look more like a Chicago Bears theme with the vector that was cut out by adding the navy-blue paint marker. This is what was the result after I had gone over the whole canvas in blue paint marker. I then found some Isopropyl alcohol and a paper towel and wiped any excess marker off the top. Which left me with this. I am so happy with how the results of this turned out. I really learned a lot about using a laser cutter and I am excited to use this as a creative tool for the future. What went wrong/ what could I have done differently? I think the only thing I would change would be to raster some more details onto the bear, like the eyes and some fur marks. I also was told by a staff member that using multi-layered acrylic achieves a similar effect as painting as I did, which I would like to also employ in the future. I am excited to continue to use these machines in the near future! Continue Reading