Engineering PATHWAY

3D Keychain project: This was our first project of the year and one of the first times I ever used TinkerCAD. I designed the keychain on the software and printed it out.

Corn hole board Project: My teacher challenged my group and I to make a finished corn hole board to sell to consumers interested in the game. It had to have excellent craftsmanship in order to be sold so we could make a profit. I also designed a logo for our company.

Engineering Concepts

Moire Kinetic Sculpture

The Task

My teacher assigned us with the task of creating a Moire Kinetic sculpture with moving parts and electrical wiring.

The Constraints

Here is the list of project constraints for our sculptures which is essentially the rules that we have to follow so that our final product will meet all of these requirements.

The Benchmarks

These are the benchmarks that we have to complete as we go along with the project. These benchmarks will help me and my classmates become experts at some of the tasks and the completion of these benchmarks will allows us to be on track for finishing the project at the end of the year.

Benchmark #1

I made a simple gearbox that has a parent gear and a child gear. The child gear is the one on the far right going in the same direction and the parent gear is the one on the left.

Benchmark #2

My next benchmark was to use the Retina Engraver software on the laser cutter to successfully cut my name in a piece of cardboard.

Benchmark #3: Gearbox with parent gear moving 2x the speed of child gear

In this benchmark, I created a gearbox with one parent gear(smaller gear with less teeth) and the child gear(bigger gear with more teeth).

Benchmark #4: LEDs go RGB

In this benchmark, I used the Arduino IDE software to program my LED to blink different colors (red, green, and blue).

IMG_6503.MOV

Benchmark #5: 2 Moire sketches

I had to draw two moire sketches that had repetition of form and at the same radial distance.

yayservo.MOV

Benchmark #6: Servo Rotates

In this benchmark I used code to program my Arduino to rotate my servo left and right .

Benchmark #7: LED pumpkin

I made a cardboard pumpkin by creating a file on Inkscape and using the Full Spectrum laser to cut it out. I coded my Arduino to blink orange, yellow, and red.

pumpkin.MOV

Benchmark #8: Two servos and one LED all controlled by one arduino

I got to program my Arduino with code. I also connected my LED with a breadboard and 2 servos to the single Arduino to make them work simultaneously.

IMG_3015.MOV

Benchmark #9: Perpendicular servo mount created using laser cutter

I used Solid works to create the file used for the laser cutter. This prototype was made out of cardboard and will help the servo stay in place.

Benchmark #10: Moire design 1 completed on SolidWorks

I used the Solidworks software to create a circular array for my moire file. Then I uploaded to the Laser cutter software to cut into cardboard .

Benchmark #11: Two INDEPENDENTLY rotating disks on one shaft

In this benchmark, I used wooden gears and dowels to make the disks rotate. In this case, the small gear is a parent gear and it controls the disk at the very top. The second larger gear on the side controls the slightly larger disk beneath the smaller one.

IMG_6745.MOV

IMG_6746.MOV

Benchmark #12: All cardboard PIECES cut out

I used the Full Spectrum laser cutter to print all of my pieces. The material I used was cardboard and I have to use those pieces to make a functional prototype with my moire designs.

Benchmark #13: A functioning prototype

I finished my cardboard prototype on time and to the best of my ability. My LEDs blink colors other than RGB or ROY and my servos rotate opposite ways which control the gears that make the moires rotate.

IMG_6900.MOV

SolidWorks file

I used this picture(a 3D file made on the SolidWorks software) which enables the user to move around the object in real time. This file is a 3D replica of our final/ end product and I was able to deconstruct it. By "deconstructing" it, I could see what small and large parts made up our kinetic sculpture. That in turn helped me assemble my prototype.

int redPin = 11;int greenPin = 10;int bluePin = 9;//uncomment this line if using a Common Anode LED#define COMMON_ANODE#include <Servo.h> Servo myservo;Servo myservo2; void setup(){ pinMode(redPin, OUTPUT); pinMode(greenPin, OUTPUT); pinMode(bluePin, OUTPUT); myservo.attach(5); myservo.write(90); // set servo to mid-point myservo2.attach(2); myservo2.write(90); // set servo to mid-point }void loop(){ setColor(255, 0, 0); // red delay(1000); setColor(0, 255, 120); // green delay(1000); setColor(0, 0, 255); // blue delay(1000); myservo.write(180); // set servo to mid-pointdelay(1000); myservo.write(0); // set servo to mid-pointdelay(1000);myservo2.write(180); // set servo to mid-pointdelay(1000); myservo2.write(0); // set servo to mid-pointdelay(1000); }void setColor(int red, int green, int blue){ #ifdef COMMON_ANODE red = 255 - red; green = 255 - green; blue = 255 - blue; #endif analogWrite(redPin, red); analogWrite(greenPin, green); analogWrite(bluePin, blue); }

Code

On the left is the code that I used to program my Arduino. I combined old code that made the LED's go RGB and code that made a servo rotate. Basically, this code controls the LED's and makes them blink different colors. It also tells the 2 servos to rotate independently. This code is so important because my Arduino would be useless without it (it tells it what to do).

presenationE.MOV

Presentation to Engineering Class

The purpose of a functional prototype is create a design that is closest to the final product as possible but with a few changes like material. It allows for thorough testing and iterations (changes) before the final product is made. It also saves time and money which are both very valuable. For instance, my prototype was entirely made out of cardboard (not the final material) because it is very expensive and there is the possibility that there could be an error in the design which could be fixed in the prototype. My entire prototype was made out of cardboard which included the gears that control the moving parts (moires). Cardboard is flimsy so the gear teeth kept crunching together and breaking apart. In turn, that affected the mobility of the moires which would sometimes get stuck or not even move at all.

One improvement would be to get rid of the holes in the front of the acrylic of they are not being used by LED's. The last improvement to the kinetic sculpture (Solid works) file would be for the back to not be clear or see through. That could affect my craftsmanship because the wiring would be visible.

An improvement to my moire files would be that there is uniformity between my first design and my second one. This means that each design compliments each other equally and blends together overall.

Benchmark #14: Installed servos in acrylic

I used screws to install these two servos into the acrylic. There are two screws (screwed in oppositely) on each servo.

Benchmark #15: Cut out moire 1

This is my first moire that I cut out with the Glowforge. Also, wood was the material used to print this end-product rather than cardboard which was the material used for my prototype.

Benchmark #16: Cut out moire 2

I cut out this second moire with the Glowforge and used SolidWorks to make a 3D model. This second moire has repetition of form and equal radial distance to the first one.

Benchmark #17: LED'S go RGB for final product

I installed 8 LEDS into my acrylic and soldered wire to create a circuit controlled by an Arduino.

finalled.MOV

Benchmark #18: Arduino installed on middle acrylic

I installed my arduino to my middle acrylic with a drill and 2 screws which will keep it secure.

lightpattern.MOV

Benchmark #19: KS does three repeated light patterns

I used code to program my Arduino to complete 3 patterns that repeat three times. First, the LEDs fade to the brightest setting(3 times). After that, the LEDs alternate between greenish yellow, off, and red for three more times. Lastly, the LEDs turn white and then fade down to red.

Benchmark#20: Moires are independently controlled

My moires are controlled by my gears and servos. The servo attached to the big gear controls the back moire and the small one controls the front moire which is attached to the shaft.

servoalt.MOV

servopat.MOV

Benchmark #21: Servos do three distinct motion patterns

I programmed my servos to move my moires in different motion patterns. For example, my front moire increases its speed while my back moire goes at full speed in the other direction. At instances, both moires move in the same direction. But, they also move in opposite directions at times.

Benchmark #22: Assemble!!!

I assembled my three acrylic layers together. The first layer is the frosted acrylic, the second layer contains my moires and wiring, and the third layer is the clear acrylic. The middle layer contains the bulk of our project.

Benchmark #23: Final KS code

This is the final code that I used to program my Kinetic Sculpture. This code controls the servos which rotate the moires and control the colors of the LEDs.

KS CODE

int redPin = 11;

int greenPin = 10;

int bluePin = 9;

//uncomment this line if using a Common Anode LED

//#define COMMON_ANODE

#include <Servo.h>

Servo myservo;

Servo myservo2;

void setup()

{

pinMode(redPin, OUTPUT);

pinMode(greenPin, OUTPUT);

pinMode(bluePin, OUTPUT);

myservo.attach(5);

myservo.write(90); // set servo to mid-point

myservo2.attach(3);

myservo2.write(90); // set servo to mid-point

}

void loop()

{

myservo2.write(0); // set servo to mid-point

delay(1000);

myservo2.write(50); // set servo to mid-point

delay(1000);

myservo.write(85); // set servo to mid-point

delay(10000);

myservo.write(80); // set servo to mid-point

delay(1000);

myservo.write(75); // set servo to mid-point

delay(1000);

myservo.write(70); // set servo to mid-point

delay(1000);

myservo.write(65); // set servo to mid-point

delay(1000);

myservo.write(60); // set servo to mid-point

delay(1000);

myservo.write(55); // set servo to mid-point

delay(1000);

myservo.write(50); // set servo to mid-point

delay(1000);

myservo.write(45); // set servo to mid-point

delay(1000);

myservo2.write(0); // set servo to mid-point

delay(1000);

myservo2.write(50); // set servo to mid-point

delay(1000);

myservo.write(85); // set servo to mid-point

delay(10000);

myservo.write(80); // set servo to mid-point

delay(1000);

myservo.write(75); // set servo to mid-point

delay(1000);

myservo.write(70); // set servo to mid-point

delay(1000);

myservo.write(65); // set servo to mid-point

delay(1000);

myservo.write(60); // set servo to mid-point

delay(1000);

myservo.write(55); // set servo to mid-point

delay(1000);

myservo.write(50); // set servo to mid-point

delay(1000);

myservo.write(45); // set servo to mid-point

delay(1000);

myservo.write(180); // set servo to mid-point

delay(5000);

myservo.write(50); // set servo to mid-point

delay(5000);

myservo2.write(50); // set servo to mid-point

delay(1000);

myservo2.write(0); // set servo to mid-point

delay(1000);

myservo.write(180); // set servo to mid-point

delay(5000);

myservo.write(50); // set servo to mid-point

delay(5000);

myservo2.write(50); // set servo to mid-point

delay(5000);

myservo2.write(0); // set servo to mid-point

delay(1000);

myservo.write(180); // set servo to mid-point

delay(4000);

myservo2.write(0); // set servo to mid-point

delay(50);

myservo2.write(90); // set servo to mid-point

delay(1000);

myservo2.write(180); // set servo to mid-point

delay(4000);

myservo.write(180); // set servo to mid-point

delay(4000);

myservo2.write(0); // set servo to mid-point

delay(50);

myservo2.write(90); // set servo to mid-point

delay(4000);

myservo2.write(180); // set servo to mid-point

delay(1000);

setColor(0, 0, 0); // red

delay(250);

setColor(20, 0, 0); // red

delay(400);

setColor(40, 0, 0); // red

delay(400);

setColor(60, 0, 0); // red

delay(400);

setColor(80, 0, 0); // red

delay(400);

setColor(100, 0, 0); // red

delay(400);

setColor(150, 0, 0); // red

delay(650);

setColor(200, 0, 0); // red

delay(700);

setColor(255, 0, 0); // red

delay(850);

setColor(255, 0, 0); // red

delay(4000);

setColor(0, 0, 0); // red

delay(250);

setColor(20, 0, 0); // red

delay(400);

setColor(40, 0, 0); // red

delay(400);

setColor(60, 0, 0); // red

delay(400);

setColor(80, 0, 0); // red

delay(400);

setColor(100, 0, 0); // red

delay(400);

setColor(150, 0, 0); // red

delay(650);

setColor(200, 0, 0); // red

delay(700);

setColor(255, 0, 0); // red

delay(850);

setColor(255, 0, 0); // red

delay(4000);

setColor(0, 0, 0); // red

delay(250);

setColor(20, 0, 0); // red

delay(400);

setColor(40, 0, 0); // red

delay(400);

setColor(60, 0, 0); // red

delay(400);

setColor(80, 0, 0); // red

delay(400);

setColor(100, 0, 0); // red

delay(400);

setColor(150, 0, 0); // red

delay(650);

setColor(200, 0, 0); // red

delay(700);

setColor(255, 0, 0); // red

delay(850);

setColor(255, 0, 0); // red

delay(4000);

setColor(0, 0, 0); // pause

delay(500);

setColor(255,255, 0); // yellow

delay(1000);

setColor(0, 0, 0); // pause

delay(500);

setColor(255, 0, 0); // red

delay(2000);

setColor(0, 0, 0); // pause

delay(500);

setColor(255, 255, 0); // yellow

delay(1000);

setColor(0, 0, 0); // pause

delay(400);

setColor(0, 0, 0); // pause

delay(500);

setColor(255,255, 0); // yellow

delay(1000);

setColor(0, 0, 0); // pause

delay(500);

setColor(255, 0, 0); // red

delay(2000);

setColor(0, 0, 0); // pause

delay(500);

setColor(255, 255, 0); // yellow

delay(1000);

setColor(0, 0, 0); // pause

delay(400);

setColor(0, 0, 0); // pause

delay(500);

setColor(255,255, 0); // yellow

delay(1000);

setColor(0, 0, 0); // pause

delay(500);

setColor(255, 0, 0); // red

delay(2000);

setColor(0, 0, 0); // pause

delay(500);

setColor(255, 255, 0); // yellow

delay(1000);

setColor(0, 0, 0); // pause

delay(400);

setColor(255, 255, 255); // white

delay(5000);

setColor(230, 255, 255); // white

delay(850);

setColor(200, 255, 255); // white

delay(700);

setColor(175, 255, 255); // white

delay(650);

setColor(100, 255, 255); // white

delay(400);

setColor(75, 255, 255); // white

delay(1000);

setColor(50, 255, 255); // white

delay(400);

setColor(25, 255, 255); // white

delay(400);

setColor(15, 15, 15); // white

delay(400);

setColor(5, 5, 5); // white

delay(400);

setColor(0, 0, 0); // white

delay(250);

setColor(255, 255, 255); // white

delay(5000);

setColor(230, 255, 255); // white

delay(850);

setColor(200, 255, 255); // white

delay(700);

setColor(175, 255, 255); // white

delay(650);

setColor(100, 255, 255); // white

delay(400);

setColor(75, 255, 255); // white

delay(1000);

setColor(50, 255, 255); // white

delay(400);

setColor(25, 255, 255); // white

delay(400);

setColor(15, 15, 15); // white

delay(400);

setColor(5, 5, 5); // white

delay(400);

setColor(0, 0, 0); // white

delay(250);

setColor(255, 255, 255); // white

delay(5000);

setColor(230, 255, 255); // white

delay(850);

setColor(200, 255, 255); // white

delay(700);

setColor(175, 255, 255); // white

delay(650);

setColor(100, 255, 255); // white

delay(400);

setColor(75, 255, 255); // white

delay(1000);

setColor(50, 255, 255); // white

delay(400);

setColor(25, 255, 255); // white

delay(400);

setColor(15, 15, 15); // white

delay(400);

setColor(5, 5, 5); // white

delay(400);

setColor(0, 0, 0); // white

delay(250);

}

void setColor(int red, int green, int blue)

{

#ifdef COMMON_ANODE

red = 255 - red;

green = 255 - green;

blue = 255 - blue;

#endif

analogWrite(redPin, red);

analogWrite(greenPin, green);

analogWrite(bluePin, blue);

}

Engineering Applications

Captain Safety Project

Our team wanted to take a break from the InvenTeam grant and decided to focus on a separate project related to COVID-19 due to the fact that our application needs to be reviewed to see if we are selected for the grant.

The Materials:
Here is the list of the materials we will need to make this project. We spent time in class(zoom) reviewing/getting acquainted with all of the materials.

The purpose of the materials assignment is it will be very helpful to us when we start to actually assemble the circuit. It allows us to be super efficient and allocating time to learn the materials will not hinder us from moving on when we proceed to the next steps.

Circuit Picture

The circuit picture is different from the circuit diagram because the circuit picture is essentially a model that uses actual images. The circuit picture is the best representation of our circuit because it accurately depicts the real-life model except for its 2-D format.

Circuit Diagram

The circuit diagram visually represents a circuit with different symbols. The diagram above shows each of the pins and also shows which wires from the servo motor(represented by the symbol m) are connected to the D13, 5V, and Ground pins. Also, we can't represent the breadboard on the diagram.

Research: The LED Matrix

Website 1

This website contains a circuit diagram with associated code and a video explaining the matrix.

Website 2

It lists the fundamentals of pin configuration of 1388A LED matrix module and how to solve any issues associated with pin configuration.

Website 3

This site provides a step-by-step tutorial on how to wire our circuit. It lists the materials with an associated video. 1.Arduino Uno 2.8×8 LED Matrix 3.Wires
It also talks about how to create graphics displayed on the matrix like the image above using the byte array that will be used in the code.

My Functioning LED matrix

The first task that we had to complete was wiring our LED matrix and making all of our lights turn on. We worked collaboratively in a zoom breakout room to get this task done as well as resolve any troubleshooting issues.

led matrix .MOV

On the left is my functioning LED matrix. I used the code below to program the lights on my matrix to do different shapes. The first shape is I, the second shape is a heart, the third shape is U, and the last one is with all of the lights turned on. I had to rewire my led matrix because when I compiled the code, the matrix did not show the correct shapes.

THE LED MATRIX CODE

#define ROW_1 2

#define ROW_2 3

#define ROW_3 4

#define ROW_4 5

#define ROW_5 6

#define ROW_6 7

#define ROW_7 8

#define ROW_8 9

#define COL_1 10

#define COL_2 11

#define COL_3 12

#define COL_4 13

#define COL_5 A0

#define COL_6 A1

#define COL_7 A2

#define COL_8 A3

const byte rows[] = {

ROW_1, ROW_2, ROW_3, ROW_4, ROW_5, ROW_6, ROW_7, ROW_8

};

byte A[] = {B00011000,B00111100,B01100110,B01100110,B01111110,B01111110,B01100110,B01100110};

byte B[] = {B01111100,B01100110,B01100110,B01111100,B01111110,B01100110,B01100110,B01111100};

byte C[] = {B00111110,B01111110,B01100000,B01100000,B01100000,B01100000,B01111110,B00111110};

byte D[] = {B01111000,B01111100,B01100110,B01100110,B01100110,B01100110,B01111100,B01111000};

byte E[] = {B01111110,B01111110,B01100000,B01111110,B01111110,B01100000,B01111110,B01111110};

byte F[] = {B01111110,B01111110,B01100000,B01111100,B01111100,B01100000,B01100000,B01100000};

byte G[] = {B00111000,B01111100,B01100100,B01100000,B01101110,B01100100,B01111100,B00111000};

byte H[] = {B01100110,B01100110,B01100110,B01111110,B01111110,B01100110,B01100110,B01100110};

byte I[] = {B01111110,B01111110,B00011000,B00011000,B00011000,B00011000,B01111110,B01111110};

byte J[] = {B01111110,B01111110,B00011000,B00011000,B00011000,B00011000,B01111000,B01110000};

byte K[] = {B01100110,B01101100,B01111000,B01110000,B01110000,B01111000,B01101100,B01100110};

byte L[] = {B01100000,B01100000,B01100000,B01100000,B01100000,B01100000,B01111110,B01111110};

byte M[] = {B01000010,B01100110,B01111110,B01011010,B01000010,B01000010,B01000010,B01000010};

byte N[] = {B01000110,B01100110,B01100110,B01110110,B01111110,B01101110,B01100110,B01100110};

byte O[] = {B00111100,B01111110,B01100110,B01100110,B01100110,B01100110,B01111110,B00111100};

byte P[] = {B01111000,B01111100,B01100110,B01100110,B01111100,B01111000,B01100000,B01100000};

byte Q[] = {B00111100,B01000010,B01000010,B01000010,B01000010,B01001010,B00111100,B00000010};

byte R[] = {B01111100,B01100110,B01100110,B01101100,B01111000,B01111000,B01101100,B01100110};

byte S[] = {B00111100,B01111110,B01100000,B01111100,B00111110,B00000110,B01111110,B00111100};//{B00111000,B01111100,B01100000,B00110000,B00011000,B00001100,B00111100,B01111000};

byte T[] = {B01111110,B01111110,B00011000,B00011000,B00011000,B00011000,B00011000,B00011000};

byte U[] = {B01100110,B01100110,B01100110,B01100110,B01100110,B01100110,B01111110,B00111100};

byte V[] = {B01100110,B01100110,B01100110,B01100110,B01100110,B01100110,B00111100,B00011000};

byte W[] = {B01000010,B01000010,B01000010,B01000010,B01000010,B01011010,B01011010,B00100100};

byte X[] = {B01100110,B01100110,B01100110,B00111100,B00011000,B00111100,B01100110,B01100110};

byte Y[] = {B01100110,B01100110,B01100110,B01111110,B00111100,B00011000,B00011000,B00011000};

byte Z[] = {B01111110,B01111110,B00000110,B00001100,B00011000,B00110000,B01111110,B01111110};

byte Zero[] = {B00111100,B01111110,B01100110,B01100110,B01100110,B01100110,B01111110,B00111100};

byte One[] = {B00011000,B00111000,B01111000,B00011000,B00011000,B00011000,B01111110,B01111110};

byte Two[] = {B00111100,B01111110,B01000110,B00001100,B00011000,B00110000,B01111110,B01111110};

byte Three[] = {B01111100,B01111110,B00000110,B00111110,B00111110,B00000110,B01111110,B01111100};

byte Four[] = {B00001100,B00011100,B00111100,B01101100,B01111110,B01111110,B00001100,B00001100};

byte Five[] = {B01111110,B01111110,B01100000,B01111100,B00111110,B00000110,B01111110,B01111100};

byte Six[] = {B00001100,B00011000,B00110000,B01111100,B01111110,B01100110,B01100110,B00111100};

byte Seven[] = {B01111110,B01111110,B00000110,B00000110,B00001100,B00011000,B00110000,B01100000};

byte Eight[] = {B00111100,B01100110,B01100110,B00111100,B01111110,B01100110,B01100110,B00111100};

byte Nine[] = {B00111100,B01100110,B01100110,B01111110,B00111110,B00001100,B00011000,B00110000};

byte All[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};

byte Circle[] = {B00111100,B01111110,B11111111,B11111111,B11111111,B11111111,B01111110,B00111100};

byte Heart[] = {B00000000,B01100110,B11111111,B11111111,B01111110,B00111100,B00011000,B00000000};

float timeCount = 0;

void setup() {

Serial.begin(9600);

for (byte i = 2; i <= 13; i++)

pinMode(i, OUTPUT);

pinMode(A0, OUTPUT);

pinMode(A1, OUTPUT);

pinMode(A2, OUTPUT);

pinMode(A3, OUTPUT);

}

void loop() {

delay(5);

timeCount += 1;

if(timeCount < 200) {

drawScreen(I);

} else if (timeCount < 230) {

} else if (timeCount < 400) {

drawScreen(Heart);

} else if (timeCount < 430) {

} else if (timeCount < 500) {

drawScreen(U);

} else if (timeCount < 530) {

} else if (timeCount < 600) {

drawScreen(All);

} else if (timeCount < 630) {

} else {

timeCount = 0;

}

void drawScreen(byte buffer2[]){

for (byte i = 0; i < 8; i++) {

setColumns(buffer2[i]);

digitalWrite(rows[i], HIGH);

delay(2);

digitalWrite(rows[i], LOW);

}

void setColumns(byte b) {

digitalWrite(COL_1, (~b >> 0) & 0x01);

digitalWrite(COL_2, (~b >> 1) & 0x01);

digitalWrite(COL_3, (~b >> 2) & 0x01);

digitalWrite(COL_4, (~b >> 3) & 0x01);

digitalWrite(COL_5, (~b >> 4) & 0x01);

digitalWrite(COL_6, (~b >> 5) & 0x01);

digitalWrite(COL_7, (~b >> 6) & 0x01);

digitalWrite(COL_8, (~b >> 7) & 0x01);

}

Circuit Picture

The Circuit picture is an actual replica/representation or model of our actual circuit. It depicts the real-life feasibility of our wiring because we are able to simulate it.

Circuit Diagram

This circuit diagram is a visual representation of the connections from the Arduino nano to the LED matrix.

Research: Ultrasonic Sensor

Website 1

This site provides a diagram to help wire the sensor to the arduino. It also shows a table with the necessary connections from the arduino to the sensor . 1.VCC to 5V(on arduino) 2. Trig to Pin 11 (on arduino) 3. Echo to Pin 12 4. GND to GND These connections correspond with the given code on the website. The website also explains how their code works and how to troubleshoot.

Website 2

Operating Voltage: DC 5VOperating Current: 15mAOperating Frequency: 40KHzMax Range: 4mMin Range: 2cmRanging Accuracy: 3mmMeasuring Angle: 15 degreeTrigger Input Signal: 10µS TTL pulseDimension: 45 x 20 x 15mm
Above is the complete specifications as listed on this website. The ultrasonic sensor uses sonar to figure out the distance to an object. The Trigger Pin will sends a high-frequency signal. Then the signal finds an object, reflects it, and the echo pin gets it. The website also has moving pictures/ gifs to better understand the function of the sensor and even shows how to connect an LCD.

Page updated

Report abuse

Engineering PATHWAY

Table of Contents

Moire Kinetic Sculpture

The Task

The Constraints

The Benchmarks

Benchmark #1

Benchmark #2

Benchmark #3: Gearbox with parent gear moving 2x the speed of child gear

Benchmark #4: LEDs go RGB

Benchmark #5: 2 Moire sketches

Benchmark #6: Servo Rotates

Benchmark #7: LED pumpkin

Benchmark #8: Two servos and one LED all controlled by one arduino

Benchmark #9: Perpendicular servo mount created using laser cutter

Benchmark #10: Moire design 1 completed on SolidWorks

Benchmark #11: Two INDEPENDENTLY rotating disks on one shaft

Benchmark #12: All cardboard PIECES cut out

Benchmark #13: A functioning prototype

SolidWorks file

Code

Presentation to Engineering Class

Benchmark #14: Installed servos in acrylic

Benchmark #15: Cut out moire 1

Benchmark #16: Cut out moire 2

Benchmark #17: LED'S go RGB for final product

Benchmark #18: Arduino installed on middle acrylic

Benchmark #19: KS does three repeated light patterns

Benchmark#20: Moires are independently controlled

Benchmark #21: Servos do three distinct motion patterns

Benchmark #22: Assemble!!!

Benchmark #23: Final KS code

KS CODE

Captain Safety Project

THE LED MATRIX CODE