Cubano Tarot

This project takes a DC motor with a fan attachment and turns it into a fun little Fortune Teller game. The Cubano Tarot is based on a form of card-based fortune telling more commonly seen in members of the Afro-Latino Cuban community. Including my own family.

A button placed on the breadboard and when pressed by either the Fortune Teller or the person having their fortune read, the preprogrammed Arduino code allows the fan on the DC Motor to spin for about 10 to 15 seconds. Attached to the fan are three coins. The Crying Eye, which represents failure. The Rose which represents money. And lastly, the wine cup which represents happiness. There is also a circular based at the bottom with three leaf-designed. Each leaf has a Roman numeral from 1 to 3. The person having their fortune read has to assign a wish or a prediction to each leaf. Depending on what coin lands where determines their future. Or, if the coins don’t align with the three leaves, then the fortune is inconclusive or if the person likes, they can wait for the coins to spin again and land on a proper leaf.

The art has been drawn by me in Adobe Illustrator. Then, laser cut into their specific shapes and glued together. A fan has had each coin, (that has been glued to a stick) taped to its individual wing. Then, the DC Motor is placed through a hole in the bottom base—the base being propped up by a Cuban coffee cup—and the fan attached. Allowing it to spin above the base.

Sketch

Schematic

Pictures

 

 

Video Demonstration 

Code

//www.elegoo.com
//2016.12.12

/************************
Exercise the motor using
the L293D chip
************************/

#define ENABLE 5
#define DIRA 3
#define DIRB 4

int i;
 
void setup() {
  //---set pin direction
  pinMode(ENABLE,OUTPUT);
  pinMode(DIRA,OUTPUT);
  pinMode(DIRB,OUTPUT);
  Serial.begin(9600);
}

void loop() {

  // RUN MOTOR for 10 SECONDS TOTAL
  digitalWrite(ENABLE, HIGH);

  digitalWrite(DIRA, HIGH);
  digitalWrite(DIRB, LOW);
  delay(5000);   // run 5 seconds

  digitalWrite(DIRA, LOW);
  digitalWrite(DIRB, HIGH);
  delay(5000);   // run 5 seconds

  // TOP MOTOR FOR 15 SECONDS
  digitalWrite(ENABLE, LOW);   // stop motor
  Serial.println("Motor stopped");
  delay(15000);                // stay stopped 15 seconds
}
   

Cat Paw

SVG File

 This work is called Cat Paw. The main intention of this was to create a cute motorized cat that moves its paw up and down. Referencing the beckoning cat, this project uses a motor along with a joystick to control the paw. Along with the cat is a fish that can easily get knocked down. The story is of a playful cat messing aggressively with a fish. 

//cat code

#define ENABLE 5

#define DIRA 3

#define DIRB 4

int joyStickPin = A0;

int drift = 20;

int i;

 

void setup() {

  //---set pin direction

  pinMode(ENABLE,OUTPUT);

  pinMode(DIRA,OUTPUT);

  pinMode(DIRB,OUTPUT);

  pinMode (joyStickPin, INPUT_PULLUP);

  Serial.begin(9600);

}

void loop() {

  //first get the up or down of the joy stick  between 1023 and 0 and then remap it to ... -255 to 255 for the motor if it's 0 - 255 it's down paw, if it's -255 through 0 it's up paw

  int inputY = MapValues(); //get a return value that will determine if up or down and how fast up or down

  Serial.println(inputY);

  if(inputY > drift){

    analogWrite(ENABLE,abs(inputY)); // enable amount

    digitalWrite(DIRA,HIGH); //down paw

    digitalWrite(DIRB,LOW);

     //delay(50);

  }

  else if(inputY <= drift && inputY >= -drift ){

    digitalWrite(ENABLE, LOW); //paw off, might need some fall off

    // delay(50);

 

  }

  else if (inputY < -drift ){

    analogWrite(ENABLE,abs(inputY)); // enable amount

    digitalWrite(DIRA,LOW);  //up paw

    digitalWrite(DIRB,HIGH);

     //delay(50);

  }

   

  }

  int MapValues(){

Serial.println(analogRead(joyStickPin));

  int mapStick = map(analogRead(joyStickPin), 0, 1023, -200, 200);

      Serial.println("Mapped Input: ");

  return mapStick;

}

Ignacio Vergara - Expressive Motion

 

Expressive Motion

Concept Description

For this assignment, I created a project called Perseverance. The concept represents a young man training to become a samurai. His posture is firm and focused, and his only objective is the training post in front of him. Through continuous practice and repetition, he aims to master his skill. The deeper idea behind the project is that perseverance through discipline not only builds strength but also cultivates inner peace.

In the starting state, everything is static. The warrior stands still, symbolizing preparation and mental focus. When the button is pressed once, the servo moves the arm and produces a single swing of the blade. This represents the beginning of effort. If the button remains pressed, the warrior continues swinging repeatedly, expressing long-term dedication and consistent practice. When the button is released, the motion stops and the system resets.

Technical Description

The movement is achieved using a servo motor connected at the arm joint. The laser-cut components consist of three separate pieces: the body of the warrior, the arm with the sword, and the training post. The Arduino reads the button input and controls the servo to create the swinging motion.

 Video Demonstration

 

 Photos

 Sketch

  

 

Schematic

Code

 

#include <Servo.h>

Servo myservo;  

int pos = 80;  

const int btnPin=2;

void setup() {

  myservo.attach(9);  

  pinMode(btnPin,INPUT_PULLUP);

  Serial.begin(9600);

}

void loop() {

  if(digitalRead(btnPin)== LOW){

    train();

  } ;

  Serial.println(digitalRead(btnPin));

}

void train() {

  for (pos = 30; pos <= 150; pos += 2) {  

 

    myservo.write(pos);  

    delay(15);          

  }

  for (pos = 150; pos >= 30; pos -= 2) {  

    myservo.write(pos);                  

    delay(15);                            

  }

}

 

 

The LED game

 

This is meant to be a game where you use the potentiometer along with an analog joystick to control the values of an LED. You try to match these values to the first LED, which is randomly assigned at the start of the game. When you finish and get close enough to the color, the LEDs flash and restart, allowing the first LED to change color. If you get it wrong, a buzzer will sound, letting you know you haven't gotten it yet. 
The analog inputs include two from the Joystick: vrX and VrY. The Joystick also uses the press-down digital input represented by the white wire. This allows the user to check whether they are close to the LED color. The jumper cable wires represent what color they are: red, green, or blue. For the Joystick, the red value is the power, while black is the ground, and white is the button input. For the potentiometer, the jumper wires are primarily red to both show power and the input for the red LED. The only exception to this is an orange wire used with the buzzer. 
Finally, there are paper UI showing the red knob, the Green and blue, and a label that says press to check on the joystick. 

int ledUpRed = 6; 

int ledUpGreen = 5; 

int ledUpBlue = 3; 

int ledDownRed = 11; 

int ledDownGreen = 10; 

int ledDownBlue = 9 ; 

int buzzer = 7; 

int vrXGreen = A1; 

int vrYBlue = A2; 

int knobRed = A0; 

int confirmButton = 2; 

int randomRed; 

int randomGreen; 

int randomBlue; 

int mapValRed; 

int mapValGreen; 

int mapValBlue; 

int close = 5; 

 

void setup() {

  pinMode(ledUpRed, OUTPUT);

  pinMode(ledUpGreen, OUTPUT);

  pinMode(ledUpBlue, OUTPUT);

  pinMode(ledDownRed, OUTPUT);

  pinMode(ledDownGreen, OUTPUT);

  pinMode(ledDownBlue, OUTPUT);

  pinMode(buzzer, OUTPUT);

  pinMode (vrXGreen, INPUT);

  pinMode (vrYBlue, INPUT);

  pinMode (knobRed, INPUT);

  pinMode(confirmButton, INPUT_PULLUP);

  //set up the first random number for the upper one

  Random(); 

  // put your setup code here, to run once:

    Serial.begin(9600);

 

}

void Random(){//also going to be the reset function for the end of the 'game' 

  //get random numbers 

  randomRed = random(0, 255);

  randomGreen = random (0, 255);

  randomBlue = random ( 0, 255);

  //set these values to the upper pin .. probably in loop. 

}

void AssignRandom(){

  analogWrite(ledUpRed, randomRed);

  analogWrite(ledUpGreen, randomGreen);

  analogWrite(ledUpBlue, randomBlue);

  delay(10); //this is to make sure its not too quick

}

void loop() {

   digitalWrite(buzzer, LOW);

  

  AssignRandom(); 

  // scale the values of the inputs map and set them 

  MapValues(); 

    

  //check the values to see if they are close to one another when pressing confirm 

  if(!digitalRead(confirmButton)){ 

      if(CheckValues()){ //check values is kinda wrong 

        // do the lalalalala

        // make both the LEDs fade to white then off then slowly restart the 'game' 

        CoolEnd(); 

      } 

      else{ 

        //fail sound play buzzer

        digitalWrite(buzzer, HIGH);

        

        Serial.println("you failed!");

      }

  }

}

void CoolEnd(){

  analogWrite(ledUpRed, 255);

  analogWrite(ledUpGreen, 255);

  analogWrite(ledUpBlue, 255);

  analogWrite(ledDownRed, 255);

  analogWrite(ledDownGreen, 255);

  analogWrite(ledDownBlue, 255);

  delay(200);

  analogWrite(ledUpRed, 0);

  analogWrite(ledUpGreen, 0);

  analogWrite(ledUpBlue, 0);

  analogWrite(ledDownRed, 0);

  analogWrite(ledDownGreen, 0);

  analogWrite(ledDownBlue, 0);

    delay(200);

  Random(); 

  

}

bool CheckValues(){

  // check the values.. if they are 30 ish close enough return true, if not return false 

  bool redCorrect = false; 

  bool blueCorrect = false; 

  bool greenCorrect = false; 

  if((analogRead(ledDownRed) - analogRead(ledUpRed))< close &&  (analogRead(ledDownRed) - analogRead(ledUpRed)) >-close )

  redCorrect = true; 

  if((analogRead(ledDownGreen) - analogRead(ledUpGreen))< close &&  (analogRead(ledDownGreen) - analogRead(ledUpGreen)) >-close )

  greenCorrect = true; 

  if((analogRead(ledDownBlue) - analogRead(ledUpBlue))< close &&  (analogRead(ledDownBlue) - analogRead(ledUpBlue)) >-close )

  blueCorrect = true; 

Serial.println("these are the true or false");

Serial.println(blueCorrect);

Serial.println(redCorrect);

  if(redCorrect && blueCorrect && greenCorrect){

    return true; 

  }

  else{

    return false; 

  }

}

void MapValues(){

  

  int mapValRed = map(analogRead(knobRed),0, 1023, 0, 255);

  int mapValBlue = map(analogRead(vrYBlue), 0, 1023, 0, 255);

  int mapValGreen = map(analogRead(vrXGreen), 0, 1023, 0, 255); 

 

  //then write 

  analogWrite(ledDownRed, mapValRed);

  analogWrite(ledDownGreen, mapValGreen);

  analogWrite(ledDownBlue, mapValBlue);

 

  //delay for nonsense 

  delay(10);

}

Marie's Mapping

 

Mapping

This project demonstrates an RGB LED controlled through a switch-based input system, where user interaction directly affects the color output of the light. The strength of which is determined by how far the user slides the potentiometer on the breadboard. The potentiometer functions as the primary and only way to provide user input. It sends signals that allows the light of the LED to appear blue when activated and increase it's brightness overall. The RGB LED switch emphasizes the relationship between hardware inputs, some minor software logic and visual output. Internally, the microcontroller reads the switch’s state and maps it to strength of the blue color in the LED. demonstrating basic input mapping and conditional logic. Displaying how user interaction can dynamically shape an electronic system’s behavior. This project serves as a practical example of physical computing design at a small scale.

Sketch

Schematic

Pictures

Video Demonstration 

Code

const int bluePin = 9;
const int greenPin = 10;
const int redPin = 11;
const int thePin = A1;

int maxVal = 0;
int minVal = 1023;

void setup() {
  // put your setup code here, to run once:
  pinMode (bluePin, OUTPUT);
  pinMode (greenPin, OUTPUT);
  pinMode (redPin, OUTPUT);
  pinMode (thePin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  // put your main code here, to run repeatedly:
  Serial.println(analogRead(thePin));
  int knobval = analogRead(thePin);
  if (knobval > maxVal) maxVal = knobval;
  if (knobval < minVal) minVal = knobval;
  int mapval = map(knobval, minVal, maxVal, 0, 255);
  analogWrite(redPin, mapval);
  delay(10);
  Serial.print(knobval);
  Serial.print("\t");
  Serial.print(minVal);
  Serial.print("\t");
  Serial.println(maxVal);

  //for(int i=0; i<255 analogwrite="" bluepin="" code="" delay="" greenpin="" i="" redpin="">

Unconventional Switch - Electronic Group 11

 

For our unconventional switch, we decided to make a can that when a lid closes it, an LED would light. We used a 3.3v power source, a 2v LED, and a 100-ohm resistor. One clip is connected to the lid, and the other clip is connected to the bottom of the can. The LED lights when the lid is on, signifying whatever is in the can can't be taken out, until the light turns off. The light kind of signifies the spark in a kid's brain whenever they see a closed wafer/cookie jar, and the light stays on until they figure out how to get the lid off.

Unconventional switch - Team 4

 Unconventional switch - Team 4 

 

    For our unconventional switch, we chose to use Gatorade as the method for turning the circuit on and off. Using a power supply, two 100ohm resistors, A red LED, and two alligator clips, we connected the components together and placed both clips at the top of a cup without letting them touch

    Gatorade contains a high amount of salt, which lets the current pass through it and complete the circuit. When the liquid reaches the clips, the circuit is completed and the LED turns on. 

    The practical use for this setup is as an indicator to show when to stop pouring your drink. Like if it was dark at night the led would let you know. This could also be improved, if we used a speaker it would make an even better indicator for the visually impaired. Alternatively you could reverse this, with the led on when the cup is full. You can check if anyone stole some of your drink because the led would turn off if the liquid went lower

Unconventional Switch - Team 3

 

For our Unconventional Switch, we chose to use a glass of lemonade as the switch. 

Lemon juice, and by proxy: lemonade, is a conductive fluid. This is due to the high amounts of citric acid it contains, which makes the water act as an electrolyte. In fact, one could use a lemon to make a whole battery and produce electricity. 

However, we were sufficient in just using it to simply transfer power from our own power source. The electricity comes in and out of the juice through alligator clips which connect it to the rest of the circuit. But to keep the clips dry from the corrosive juice, we used tinfoil to dip into the juice and carry the charge into it. The tinfoil is at different levels within the cup. Which means if enough juice is removed, usually by drinking out of the straw, then the circuit would be open and the LED wouldn’t be powered anymore. Adding juice back into the cup will close the circuit and restore power to the LED. A specifically plastic straw is used to remove juice from the cup, as you wouldn’t want to use a metal straw for charged lemonade. Since we used another straw to hold one of the tinfoil clumps, we call it Lemonade for Two!

Unconventional Switch Team- 19

We chose to do two swords hooked up that once they touch each other turns on the LED. The blades are metal and so is the desk as shown in the video, but only the swords clashing turns on the led no other surface. 

It's a 5v power supply with a 100 ohm resistor with a red 3v LED light. We got one alligator on the breadboard and another next to the LED, these then lead to the clamps that are then firmly attached to the tip of each sword. Once they touch, the electricity conducts to the LED. The moment they stop touching it stops. 

As one can see we went for the aesthetic route. Who wouldn't want to see cool sword light effects? This can be used for entertainment such as a light show or a movie. This is because it can pick up and flash exactly when a blade clashes. And since it doesn't need that hard of a press, just a simple touch, its easy for performers to "fake" clashes. 

Unconventional Switch: Electronics Team 10

 For our take on the unconventional switch assignment, we decided to include a practical design aspect, which involves hanging keys up on a lanyard. The reason we chose this line of reasoning is because it reflects something common and mundane that most people wouldn't typically think twice about. In many ways, taking a key off or placing it on a lanyard is often a means to an end, serving as a step towards another goal, so we decided to intentionally showcase this often-overlooked step.

We utilized the conductivity of the key ring and the conductive portion of the lanyard (the metal ring). By attaching an alligator clip to each of these components, the green LED would turn on once the key ring was clipping onto the lanyard, closing the circuit by touching one another. Then, once the key is unclipped, the circuit is opened and the LED turns off. 

Switch Circuit Schematic:

Video Demonstration:

Unconventional Switch - Electronics Team 13

For our team's switch, we wanted to create a way to turn a light on via some sort of play feature, so we used elements of the Pokémon Trading Card Game to create a light switch which turns on when a Pokémon card is placed into the active spot of a playmat. The circuit makes use of wires attached to strips of aluminum foil which has been attached to both the playmat and backing of the Pokémon card. Once the card is placed onto the mat, the circuit is completed, allowing the light to be powered and illuminate. Removing the card will cause the circuit to break again, and the light will turn off. Ideally, this can be used to detect which positions on the playmat have been filled, and can be used in things such as mechanic displays which show how many cards are on each players' field.

Unconventional Switch Team 2

Our unconventional switch uses two pieces of gutter metal as conductive contact points that allow the human body to complete the circuit. The circuit consists of a battery, a resistor, an LED, and two separated pieces of metal connected to different parts of the circuit. Normally, the circuit is open because the two metal pieces do not touch, so electricity cannot flow and the LED remains off. When a person touches both pieces of metal at the same time, their finger acts as a conductive bridge that closes the circuit. This allows electricity to flow from the battery, through the resistor and LED, and across the metal contacts through the person’s finger, turning the LED on.

The concept behind this switch explores the relationship between the human body and electricity, showing how the body itself can become part of the circuit. Using gutter metal emphasizes the use of unconventional, everyday materials and transforms a simple electrical function into a more interactive and engaging experience.

Unconventional Switch - Electronics Team 12

 

For our team’s unconventional switch, we decided to go the aesthetic inquiry route to test our ability to bridge electronics and art. While discussing ideas for the switch, we came upon the idea of making some sort of slot to interact with, which led to a classic piece of mythology: The Sword in the Stone. We approached this piece using methods from narrative sculpture and simplified it using basic materials. For the “stone”, we used an eight-inch foam half-sphere, as it would just cover the board. The inside was hollowed with carving techniques, allowing all the necessary components to fit inside. This was used on the front to leave a thin layer of foam that would allow the interior LED’s light to be visible. A notch was made in the back for the USB port, and a small slot was carved into the top to insert the aluminum “sword”. Small pieces of EVA foam were attached inside the sphere to guide the “sword” into place. A coin was taped to both foam pieces and attached to alligator clips. When the aluminum foil “sword” is placed in the “stone”, it will react to the coins and light the symbol from within.

Unconventional Switch - Electronics Team 7

    For our unconventional switch we used an already conductive beverage can and a coaster wrapped in some foil to make it conductive. With one clip connected to the can and another connected to the coaster the circuit becomes completed when the can is placed onto the coaster, lighting up the LED. This system gives a visual indicator for when the beverage has been placed onto or is removed from the coaster. This can help remind the user to place their drink onto the coaster instead of the table, which could result in a mess. The light can make it easier to tell if the beverage can has been placed in the correct spot and helps to remind the user each time they lift their beverage and place it back down.

Unconventional Switch - Electronics Team 17

 Hello, for our unconventional switch, we developed a concept that uses the conductivity of a key and the partial conductivity of a water bottle. Parts of the water bottle are not conductive so for the LED to turn on like a switch, the key has to touch the metal parts of the water bottle, while of cours,e the other end of the alligator clip has to be connected to the metal parts of the water bottle at the same time for the touching to act as an unconventional switch. Our concept of using the key to “turn on the switch” by using the bottle as a conductor to turn on the LED explores the materiality of the conductivity of both objects and where each is conductive.