The most successful Tinkercad circuit we built, for testing and learning the LCD screen and the LiquidCrystal library. See below for our full Tinkercad circuit and why it didn’t work.
To begin this assignment, we discussed various ideas of how we could transduce orientation to light. After a couple hours of excited general brainstorming, we found it very helpful to use then maker cards to narrow down our conversation in terms of input and output. This focus allowed us to see what was necessary in the middle steps of the operation , and what parts may lend themselves well to working together.
An overview of our 3 more refined ideas
Our favorite of the 0ur 3 more refined ideas was the following:
A potentiometer sets the angle for a servo for a stepper motor. A cable sticking out from the motor turns with the motor and glides on a layer of graphite drawn around the motor. A current is always flowing through the graphite, and depending on the position of the cable along the graphite trail, it’ll measure more or less current. Essentially like a homemade potentiometer whose position is determined by a stepper motor. Depending on the current read by the cable, an LED lights up more or less.
Jubbies’ concept sketch for our idea
We had gotten some good feedback from our professor as well, since this idea seemed to be a good balance between exciting and feasible. To proceed forward, we broke down our problem into several steps so we could focus on individual components before be assembled them together . The first step we needed to confirm was working independently was the one that was most unfamiliar – using a graphite resistor. To learn how to do this, Jubbies used YouTube to find a concise demonstration of this idea.
The following video was very helpful as it demonstrated some of the affordances of using graphite circuit .
Using this video as guidance, Jubbies recreated this graphite circuit with alligator clips in a 9-volt battery. This demonstration proved successful, although there was not as much variance in the light as was desired. We found that this issue was resolved as we eventually used a longer graphite resistor.
Demonstration of the graphite circuit
After proving that the graphite circuit could work, the next issue to tackle was controlling the stepper motor accurately with a potentiometer. This pursuit proved to be far more difficult than we first predicted. A huge barrier that we had to figure out how to overcome Rose making the stepper motor turn the correct direction. For some reason the stepper motor seems to only cumulatively turn to the right no matter the direction that the potentiometer was turned. it was as if the stepper motor turn only two the amount that was equivalent to the total value that the potentiometer was turned , regardless of whether that value was left or right. We tried editing the code and checking our wiring for hours, but none of this seemed to help.
here’s an example of the potentiometer moving to stepper motor only to the right depsite the direction that the potentiometer turned.
It wasn’t until receiving help directly from our professor that we were able to proceed forward. The thing that fixed this issue was in the end, simply replacing both the stepper motor and a stepper motor driver. We have not yet identified what the issue was particularly, but using the new parts with the same code achieve the results that we had wanted.
finally our stepper motor turned right AND left!!
While this issue was frustrating and strange, it did allow us to use a stepper motor that was far more robust than the one we were using before. This helped with the construction of our circuit since we did not have to worry that the arm would not move quick enough. however oh, I believe the use of outside power source led to the following image – Jubbies accidentally blew up an LED while accidentally connecting the power and ground of the LED without the graphite circuit in-between. This was a good lesson, as it reminded her to be very conscientous of these wires not connecting again.
Another strange issue that was not ideal but did not hinder the intended mechanism was an ever present jitter in the stepper motor arm. This jitter was likely due to analog interference and could be resolved in the future with a threshold or other tool to smooth the data recieved by the potentiomenter. I had considered using a rotary encoder mid-project over the potentiometer as I heard that it was less susceptible to analog interference, but I was unable to quickly implement this and ended up just using the potentiometer.
Bonus: I strapped a pen onto the stepper motor arm and found this jitter made for an interesting drawing tool to be explored further in the future – Jubbies
Carlos’s progress
My (Carlos’s) Tinkercad code somehow became ridden with invisible special characters \302 and \240, maybe after copying and pasting the code from iMessage. They were nearly impossible to remove without retyping those lines word for word all over again. Because of this, the code wouldn’t compile, and I couldn’t check if the rest of the code was correct.
Tinkercad does not have a stepper motor, so I used the larger, grey DC Motor with Encoder as a mere placeholder, not even connected to anything.
Block Diagram & Schematic:
/*
60-223, Double Transducer: The Convoluted Potentiometer
Jubbies Steinweh-Adler
Carlos Ortega
Collaboration and sources:
1) I collaborated with Carlos to figure out the order of the code
2) Referenced heavily Circuit Digest stepper motor with Potentiometer
https://circuitdigest.com/microcontroller-projects/stepper-motor-control-with-potentiometer-arduino
3) The maker cards really helped me understand the parts
https://nsfsmartmakerspaces.github.io/physcomp/parts/4005/#starter-code--connection
4) I referenced Household Hacker's youtube video about paper and graphite
circuits to get started with this idea.
5) Tate gave me some advice on how to use the LCD display since I could
not figure it out.
Challenge(s): Remote collaboration was difficult, as was
working through unknown bugs with the Stepper Motor. The
stepper motor and driver did not work and simply had to be
replaced. Additionally, I could not get the LCD working in
time.
Next time: It was extremely helpful to segment the process
of solving this code, proving that each mechanism works
independently of the whole rig. I will certainly do this again
as it really sped things up and made them less stressful.
In terms of issues, I think I should have given more time
to the physical assembly of all the parts, since this took
way longer than I thought. I spent a lot of time trying to
fashion non-destructive mounts. It was hard to physically arrange
the parts together in a semi-elegant way. I also want to give
more time to the small final details, like resolving the
stepper motor jitter.
Another thing I want to take forward from this project was using
a clearly understood visual indicator of the process like the
graphite semicircle, since I found this helped people make sense
of this project quickly.
Description:
Pin mapping:
Arduino pin | type | description
------------|------------|-------------
A0 Input Potentiometer input
12 LCD Pin Used for the LiquidCrystal Library
11 LCD Pin Used for the LiquidCrystal Library
2 Input Stepper Motor driver
3 Input Stepper motor driver, direction
7 LCD Pin used for the LCD
6 LCD Pin used for the LCD
5 LCD Pin used for the LCD
4 LCD Pin used for the LCD
*/
//Initialize the LCD
#include <LiquidCrystal.h> //include the LCD library code
// initialize the library by associating any needed LCD interface pin
// with the arduino pin number it is connected to
const int rs = 12, en = 11, d4 = 7, d5 = 6, d6 = 5, d7 = 4;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
//Initialize the Stepper
#include <AccelStepper.h> // including the accelstepper library for more control of motor
const int POTPIN = A0; //potentiometer input pin
const int STEP_PIN = 2; // A4988 "STEP" pin wired to Arduino pin 2 (you can change this)
const int DIR_PIN = 3; // A4988 "DIRECTION" pin wired to Arduino pin 3 (you can change this)
int pos = 100; // variable to store motor position instruction, 100 is half rotation
// Modified from:
//https://courses.ideate.cmu.edu/60-223/s2021/tutorials/stepper
AccelStepper stepper(1, STEP_PIN, DIR_PIN);
// Will compare this to currStepMotPos later, inside loop.
int prevStepMotPos = 0;
unsigned long timerVar = 0;
const int WAIT = 200; //does not change
int LCDupdate = 0;
void setup() {
int BAUD = 9600; //serial comm value
int maxSpeedVar = 100; //measured in steps per second
int accel = 500; //measured in steps per second
Serial.begin(BAUD); //begin serial communication
//---LCD Setup---
lcd.begin(16, 2);
// Modified from:
// https://nsfsmartmakerspaces.github.io/physcomp/parts/4005/#starter-code--connection
//---Stepper Motor setup---
stepper.setMaxSpeed(maxSpeedVar); // measured in steps per second
stepper.setAcceleration(accel); // measured in steps per second squared
// while there is still a distance to go,
stepper.run(); // make the motor run
}
void loop() {
unsigned long currentTime = millis();
unsigned long previousTime = 0;
}
int inLo = 0; //lowest value of potentiometer range
int inHi = 1023; //max value of potentiometer range
int outLo = 0; //lowest value of stepper motor range
int outHi = 100; //200 per rev, so half revolution
int potPos = analogRead(POTPIN); //potPos assigned position of potentiometer
//map pot pos range to stepper motor range
int long currStepMotPos = map(potPos, inHi, inLo, outLo, outHi);
//Change destination of stepper to potentiometer input
stepper.moveTo(currStepMotPos); //tell motor to go to new position
prevStepMotPos = currStepMotPos; //save current value into previous value
stepper.run();
//Serial.println(prevStepMotPos); //for debugging
LCDPotVal =
LCDStepperVal =
//LCD Update
/*if (currentTime - timerVar >= WAIT) {
lcd.clear();
lcd.home();
lcd.print("i:");
lcd.print(LCDPotVal0;
lcd.setCursor(6, 0);
lcd.print("m:");
*/
previousTime = currentTime;
}
Discussion:
This project was an exciting introduction to many new concepts such as assembling separate components into one operation, using graphite as a resistor, learning how to debug in context, soldering, and collaborating remotely. Since we were both excited about this idea, it was easier to push through these bugs. Learning hands-on was a great experience , since somebody can tell you what it’s like to explode an LED, but before you actually do it, I would argue that it is far less likely to sticks with you.
The biggest barriers we faced had to do with significant bugs and remote collaboration. The stepper motor/ stepper motor driver bug , although circumnavigated, was never resolved. Only with the help of our professors are we able to move on from that point through replacing our parts.
Additionally, since Carlos is studying remotely and never received his Arduino kit from customs, there was simply not an option to collaborate on the hardware issues. Since the software and hardware are delicately intertwined, this also made it extremely difficult to collaboratively resolve software issues as well. While on paper, tinkercad seems to be a good option to ease this situation, the lack of a stepper motor, stepper motor driver, and graphite resistor on the platform, as well as the inability to import libraries, made this tool unhelpful.
That being said, we were able to have rewarding discussions about conceptual development and enjoyed the process of translating our idea to a real tangible thing.
]]>This simulation helped us plan our physical project. Here we have a potentiometer as the input, an RGB LED and photo-resistor as our middle step, and a pancake vibration motor as our output.
Dani’s Project
Dani’s final project
Demonstration:
Nish’s Project
Nish’s Final Project image
Demonstration:
Project Images
The RGB LED and the Color Sensor (purple chip) act as our middle transduction step
The accelerometer is the input to detect position change
Project Description
The user holds a position sensor and can move and tilt it in all directions. This will make and LED light up in different colors, depending on the position of the sensor. A color sensor picks up what color the LED is at that moment. The color sensor will then determine how much to vibrate the output based on what color it sees.
Progress Images
I thought the power/ground connections went all the way to both sides of the board, but there is a small gap at the bottom. It took me a while to realize I needed to bridge the gap to close the electrical connection.
We were getting negative values on our LCD and we realized it was because we were mapping to incorrect ranges that were causing values outside of the 0-99 range.
I wasn’t able to get the LCD to display correctly for a while. It turned out the wires weren’t matched up exactly to how I had described them in the Arduino code, and the LCD pins were not fully inserted into the breadboard. It was difficult to get the pins to stay in consistently. – Nish
I was having some difficulty soldering because I decided to solder in the RGB LED first. However, this was a bad idea as it made the rest of the board uneven for me to solder the resistors and other components on. Therefore, a lot of the resistors look uneven and like they’re sticking out, as demonstrated in this picture. Also, even though it doesn’t really matter, I was upset that I had soldered upside down on the protoboard. – Nish
Discussion
The easiest parts of this project including the brainstorming and ideation as well as the actual wiring of the parts. We felt there was only a limited number of options for our middle step since it would be difficult to physically modulate anything in our middle step to use something like distance/distance sensor. However, upon seeing what other groups have completed, we realized we could have been more creative in this project by using outputs and motors we do have to create a physical middle step, perhaps something similar to our wind sensor idea but more practical for this class. However, using color as a middle step did invoke some challenges as well that we didn’t think we would run into.
Though the soldering overall was easy, Nish did learn something that should have been intuitive. Although RGB LEDs individually have different current values they need in order to not blow up, if you use different resistors on each one, the intensity of each color will show up differently. She had already soldered in her resistors when she realized this, and this mistake was reflected when the color sensor was not able to sense as much red as should have been outputted in the LED.
Learning how to use the color sensor was an interesting challenge, though not a difficult one. Since we were using a sensor that was not a part of our kit, there wasn’t necessarily a module that described how to wire it and code it, so our team had to use our own research to find our model and other projects that had used the same sensor. Since this is a common sensor it was not that difficult to find Arduino code online that we could model ours after. While we probably don’t understand why it’s coded in the way it is and didn’t fully utilize all the functions, we were able to successfully sense the output of our RGB LED.
The most difficult part of our project was figuring out how to go from three inputs (X, Y, Z orientation) to just one final output, where different combinations of the three inputs would lead to a meaningful differences in the final output. Several different input positions can lead to the same output, as we discovered that the X, Y, Z inputs tend to vary around the same values for the most part (between 200 and 300, though their individual ranges can go between 0 and 500). Therefore, if we mapped the entire 0 to 500 value to a 0-255 range for our RGB values, we would end up with very similar colors no matter what the orientation is, so we chose to map our X, Y, and Z values of only 200-300 to a 0-255 range for later use. However, for some reason when we tried to map to a 0-99 range for our output into the LCD, the Arduino program did not like that and we had to change our range of the X, Y, Z inputs from 200-300 to 0-500, resulting in the LCD representation for our input having a very small range that was not consistent with the rest of the numbers that had been calculated from a 200-300 range mapping. We are still unsure as to why the Arduino program did not let us map from a 200-300 range in this portion, and hope to eventually get more consistent numbers between our four outputs on the LCD.
We also ran into a problem where despite using code similar to our previous outputs to the LCD, the representation of the vibration output was coming out negative. Both of us individually solved this in different ways, with one of us using “constrain” from 0 to 99, and the other changing this output from an int to an unsigned int. While we learned different methods to solve the problem, we are still unsure of the root cause of why we got a negative output in the first place, since I don’t believe we caused any overflow and we were only working with positive numbers that had worked fine up until that calculation. Throughout these several issues with mapping, we were able to pick up handy debugging skills, such as using the Serial.print() function for both strings and variables in intermediate steps to see what our numbers were before we mapped them, and to find the appropriate typical range for each of our sensors.
We probably could have used more features of the color sensor if we had explored more. Since we were going from three inputs to one output, and our X, Y, Z ideally directly maps to an RGB value, respectively, we perhaps could have utilized the “lux” sensor. Our color sensor was able to sense not only red, green, and blue values, but also the intensity. Looking back, this may have made more sense to use it’s a more direct way of going from the color itself to a single property of the color, rather than trying to arithmetically calculate a single output value for vibration from three values of red, green, and blue. It also would have made our middle step more significant in calculating the final output, rather than just something we had to put in for this project since we definitely could have used a similar formula to directly calculate vibration from the X, Y, Z coordinates.
Functional Block Diagram and Schematic
The Functional Block Diagram for our project shows a high level of the inputs and outputs.
The Schematic of our project presents a more detailed view of how the components are connected to each other.
Code
#include <Wire.h>
#include "Adafruit_TCS34725.h" // for color sensor
#include <LiquidCrystal.h> // for LCD
/*
Daniela Castleburg & Nish Nilakantan
Double Transducer: Orientation to Color to Vibration
This code takes in X, Y, Z coordinates of an input sensor and maps them to RGB values which create a color outputted by the RGB LED, which is then sensed by the color sensor and mapped to a single value that represents the strength of output vibration.
Pin Table:
pin | mode | description
--------------------------------------
A0 input x position
A1 input y position
A2 input z position
A4 input color sensor (SDA)
A5 input color sensor (SCL)
3 output pancake vibrator
4 output d4 LCD
5 output d5 LCD
6 output d6 LCD
7 output d7 LCD
9 output Blue LED
10 output Green LED
11 output Red LED
12 output EN LCD
13 output RS LCD
Credits for Color Sensor code: https://learn.adafruit.com/adafruit-color-sensors/arduino-code
*/
// INPUT //
// Accelerometer pins
const int accelXPin = A0; // Analog input pin for X movement
const int accelYPin = A1; // Analog input pin for Y movement
const int accelZPin = A2; // Analog input pin for Z movement
// Variables to keep track of the current positions
int accelXPos = 0;
int accelYPos = 0;
int accelZPos = 0;
// MIDDLE STEP //
// RGB LED pins
const int RED = 11;
const int GREEN = 10;
const int BLUE = 9;
/* Initialise with specific int time and gain values */
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_700MS, TCS34725_GAIN_1X);
// OUTPUT //
const int PANCAKE = 3;
// initialize the library by associating any needed LCD interface pin
// with the arduino pin number it is connected to
const int rs = 12, en = 13, d4 = 4, d5 = 5, d6 = 6, d7 = 7;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Other variables
const int WAIT = 200;
unsigned long lastTime = 0;
// MQTT
int inVal, outVal;
void setup() {
// begin serial communication
Serial.begin(115200);
Serial.setTimeout(50);
// finding the color sensor
if (tcs.begin()) {
Serial.println("Found sensor");
} else {
Serial.println("No TCS34725 found ... check your connections");
while (1);
}
// RGB LED as output
pinMode(RED, OUTPUT);
pinMode(GREEN, OUTPUT);
pinMode(BLUE, OUTPUT);
// Setup the accelerometer inputs
pinMode(accelXPin, INPUT);
pinMode(accelYPin, INPUT);
pinMode(accelZPin, INPUT);
// Pancake Vibration Motor as output
pinMode(PANCAKE, OUTPUT);
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
}
void loop() {
uint16_t r, g, b, c, colorTemp, lux;
// Get the current states of accelerometer
accelXPos = analogRead(accelXPin);
accelYPos = analogRead(accelYPin);
accelZPos = analogRead(accelZPin);
int accelAbs = sqrt(accelXPos ^ 2 + accelYPos ^ 2 + accelZPos ^ 2); // absolute acceleration for LCD
// map acceleration input to LED output
int redVal = map(analogRead(accelXPin), 200, 300, 0, 255);
int greenVal = map(analogRead(accelYPin), 200, 300, 0, 255);
int blueVal = map(analogRead(accelZPin), 200, 300, 0, 255);
// Use mqtt to get input data
// int redVal = map(inVal,0,99,0,255);
// int greenVal = map(inVal,0,99,0,150);
// int blueVal = map(inVal,0,99,0,100);
int LEDAbs = sqrt(redVal ^ 2 + greenVal ^ 2 + blueVal ^ 2); // combination of LED values for LCD
// update LED color based on accelerometer position
analogWrite(RED, redVal);
analogWrite(GREEN, greenVal);
analogWrite(BLUE, blueVal);
// data from color sensor
tcs.getRawData(&r, &g, &b, &c);
int colorSensorAbs = sqrt(r ^ 2 + g ^ 2 + b ^ 2); // combination of color sensor values for LCD
// map color sensor data to pancake input
int pancakeVal = map(colorSensorAbs, 100, 250, 0, 255);
// update pancake vibration motor based on color sensor
analogWrite(PANCAKE, pancakeVal);
// get pancake value
//int normOutput = analogRead(PANCAKE);
// normalize all variables to 0-->99 range
int normInput = map(accelAbs, 0, 500, 0, 99); // Accelerometer
int normMiddleOutput = map(LEDAbs, 0, 255, 0, 99); // RGB LED
int normMiddleInput = map(colorSensorAbs, 0, 500, 0, 99); // Color Sensor
int normOutput = map(pancakeVal,-350,350,0,99); // Pancake Vibration motor
// print information to LCD
if (millis() - lastTime > WAIT) {
lcd.setCursor(0, 0);
lcd.print("i:");
lcd.setCursor(2, 0);
lcd.print(normInput);
lcd.setCursor(6, 0);
lcd.print("m:");
lcd.setCursor(8, 0);
lcd.print(normMiddleOutput);
lcd.setCursor(8, 1);
lcd.print(normMiddleInput);
lcd.setCursor(12, 1);
lcd.print("o:");
lcd.setCursor(14,1);
lcd.print(normOutput);
outVal = normOutput;
transmitSerialSignal();
lastTime = millis(); // update timer variable
}
}
// Mqtt functions
void serialEvent(){
while(Serial.available() > 0){
inVal = Serial.parseInt();
}
}
void transmitSerialSignal(){
Serial.println(outVal);
}
]]>
Distance to pressure double transducer.
Double Transducer IRL:
Daniel Zhu:
Sunjana:
TinkerCAD:
Final Project Images:
Daniel Zhu:
Distance to Pressure Double Transducer – Daniel Zhu
Sunjana:
Close Up Images
Close up of the method servo used to apply pressure to the paper
Close up of servo in position to press the lever switch intermittently when its shaft is turned programmatically
Simple Narrative Description:
As the distance between the Ultrasonic Distance Sensor and an object decreases, the rate at which a servo motor presses a lever switch increases. As the lever switch registers a faster and faster rate of being triggered, a second servo motor presses a stack of cardboard more closely to the table, applying more pressure. Conversely, as the distance between the Ultrasonic Distance Sensor and an object increases, the rate at which a servo motor presses a lever switch decreases. As the lever switch registers slower rate of being triggered, a second servo motor presses a stack of cardboard less closely to the table, relieving pressure.
Progress Images:
Daniel Zhu:
Noise in Ultrasonic Distance sensor data.
Sunjana:
Converting rotational motion into pressure
Unsoldered prototype
Discussion:
This project introduced numerous physical, coding, and conceptual difficulties. Conceptually, it was difficult for us to come up with an idea to convert distance into pressure: while we had spent a lot of time working with light as a medium (LEDs) and movement, we hadn’t ever worked with any electrical components that had a specific function of exerting pressure. After speaking with the professor, we learned that in order to exert pressure, we could take inspiration from a crank that used a circular turning motion to push and pull an object. We then decided upon the idea of our second transducer outputting an angle change for a motor so it could turn like a crank and push and pull an object we created. The object in turn would apply pressure to a piece of paper as it was being pushed.
Physically, our challenge lay in orienting the different components of the machine (i.e. the servos and the button) so that they would form a chain reaction (i.e. a servo pressing a button intermittently, causing the other servo to intermittently apply pressure to a piece of paper). It took some trial and error to figure out which button was most responsive to the servo’s touch, as well as whether a servo or stepper motor was better suited to our task. It became too technically difficult for us to implement the crank with the stepper motor providing the circular turning motion, like we had originally intended, so we ended up going with the servo. In the future, we would want to be able to utilize the stepper motor as it would allow for more creativity in our output, since it turns 360 degrees.
Coding-wise, our challenge lay in figuring out the relationship between the first servo, the button, and the second servo, and how to pass information through each of these components. Specifically, we had to figure out how to convert the digital intermittent pressing of the button into an analog angle for the second servo. This also took a lot of debugging and trial and error, as we didn’t immediately know which angles of the servo were most optimal for pressing on the paper, and we didn’t know how we could change the angles such that the servo would be intermittently pressing down and intermittently going back up based on the button-pressing speed of the first servo.
Even though this project was extremely difficult, since we were relative Arduino beginners, we were able to go far out of our comfort zone and learn to put together various moving parts, as well as how to convert an analog signal to a digital signal and back to an analog signal.
Diagrams:
Block Diagram:
Block Diagram
Schematic Diagram:
Schematic Diagram
Code:
/*
60-223, Project 1: Double Transducer
Daniel Zhu (dszhu)
time spent: 6+ hrs
Collaboration and sources:
1) Code for LCD taken from the course website.
2) Code for Servo Motor take from course website.
Challenge(s): A faulty barrel jack charger as well as
noise in the LCD Display due to it being connected to
a power source shared by servo motors caused it to display
egyption hieroglyphics for several hours.
Description: As the distance between the Ultrasonic Distance Sensor
and an object decreases, the rate at which a servo motor presses a
lever switch increases. As the lever switch registers a faster and
faster rate of being triggered, a second servo motor presses a stack
of cardboard more closely to the table, applying more pressure.
Pin mapping:
Arduino pin | type | description
------------|--------|-------------
2 output LCD Display Coding Pin
3 output LCD Display Coding Pin
4 output LCD Display Coding Pin
5 output LCD Display Coding Pin
6 output LCD Display E
7 input LCD Display RS
8 output Output Servo Motor (Pressure)
9 output Middle Servo Motor (Morse)
10 input Lever Switch Input
11 output TRIGGER_PIN - Ultrasonic Distance Sensor
*/
#include <Servo.h> //Servo Library
#include <NewPing.h> //Ultrasonic Distance Finder Library
#include <LiquidCrystal.h> //LCD Library
#include <Wire.h> //LCD Library
//Ultrasonic Distance Sensor Pins
const int TRIGGER_PIN = 12; // Arduino pin tied to trigger pin on the ultrasonic sensor.
const int ECHO_PIN = 11; // Arduino pin tied to echo pin on the ultrasonic sensor.
const int MAX_DISTANCE = 200; // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); //Createing a new Sonar object for use.
const int SDELAY = 50; // Minimum amount of delay between sonar pings
long sTimeSince = 0; // Time since last sonar ping
int dist = sonar.ping_cm(); // Keeps track of object distance from sensor
//Servo Motor Pins
const int BTN = 10; // Lever Switch
const int SERVO_IN = 9; // Middle Servo
const int SERVO_OUT = 8; // Output Servo
Servo Morse;
Servo Pressure;
long mTimeSince = 0; // Time since Middle Servo Triggered
bool mSwitch = false; // Keeps track of whether the servo is in the motion of pressing or returning
long pTimeSince = 0; // Time since Output Servo Triggered
int prsRate = 0; // Lever Switch input press rate
//LCD Display
const int rs = 7, en = 6, d4 = 2, d5 = 3, d6 = 4, d7 = 5;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
long lTimeSince = 0; //Time Since LCD Display was last updated
const int lcdDelay = 250; // Minimum time between LCD updates
void setup() {
pinMode(BTN, INPUT);
Morse.attach(SERVO_IN);
Pressure.attach(SERVO_OUT);
Serial.begin(115200);
lcd.begin(16, 2);
}
void loop() {
if (millis() - sTimeSince > SDELAY) { // Triggering the Ultrasonic Sensor + Finding the Distance
dist = sonar.ping_cm();
sTimeSince = millis();
}
int pause = map(dist, 0, 50, 500, 1000); // Converts distance into how long the middle servo pauses between presses
if (int(millis() - mTimeSince) > pause) { //pressing the middle servo motor
if (mSwitch == false) { // Pressing the Lever Switch
Morse.write(40);
mSwitch = true;
}
else { // Unpressing the Lever Switch
Morse.write(45);
mSwitch = false;
}
prsRate -= 10; // Automatically Subtracting from the Pressrate of the Lever Switch
Serial.print("Delay: ");
Serial.println(pause);
mTimeSince = millis();
}
if (digitalRead(BTN) == 1) { // Detecting LEvel Switch Input
prsRate += 20;
}
if (prsRate > 100) { // Capping the pressrate before its conversion to angle to prevent servo failure
prsRate = 100;
}
if (prsRate < 0) {
prsRate = 0;
}
int angle = map(prsRate, 0, 100, 30, 20); // Converting the Pressrate of the Lever Switch to an Angle
if (millis() - pTimeSince > 500) {
Pressure.write(angle); // Moving the output motor to that angle
}
if (int(millis() - lTimeSince) > lcdDelay) { // LCD Display delay
// Converting Middle values into 0-99 range for LCD
int input = map(dist, 0, 50, 0, 99);
int middleA = map(pause, 500, 1000, 0, 99);
int middleS = map(prsRate, 0, 100, 0, 99);
int output = map(angle, 20, 30, 0, 99);
lcd.setCursor(0, 0);
lcd.print((String)"i:" + input + " m:" + middleA);
lcd.setCursor(8, 2);
lcd.print((String)middleS + " o:" + output);
lTimeSince = millis();
}
}
]]>
Tinkercad does not have a lot of components that are present in the real life version, so there are some fake data simulation. In real life, our first sensor is an accelerometer, but we simulated it with a potentiometer. The values are mapped to be in between 0-100 to mimic values we could get from our accelerometer. From there, the data is mapped to a value between 130-180 so serve as an angle for the servo motor. In real life, the servo motor would move an object in front of an ultrasonic ranger, but instead, we have to fake the simulation. The distance output from the ultrasonic ranger is then mapped to a value between 100 and 600 to serve as tone for the buzzer.
Photos for Scale:
Shuyu:
Vishnu:
Detail Photos
Initially, getting data from the accelerometer was a little foreign, so it took some thinking on how we would utilize the data.
The accelerometer was a new tool to us, so we had to research on how to wire and write code for it.
Testing everything with a pancake motor at the end.
Building the arm that extend back and forth had its mechanical difficulties. It took a while to troubleshoot how far the arm could extend.
Videos:
Shuyu:
Vishnu:
Narrative Description:
Our double transducer takes in vibration as an input (via a 3-axis accelerometer), and converts that input to an angle for a servo motor. The servo motor is attached to a popsicle stick “arm” that extends based on the angle. An ultrasonic ranger detects how far the popsicle sticks are from it and the resulting distance (cm) is converted into a tone for an 8-ohm speaker.
Progress Photos:
Shuyu: This was when I first successfully wired and ran some code through the LCD display. It was super exciting because the wiring was a little intense and something could have easily gone wrong.
Shuyu: Using a transistor to wire a speaker was a new concept and wiring it correctly was a major step in the overall project.
Vishnu: Troubleshooting the popsicle arm and trying to find a good angle range. I ended up building barriers for it.
Vishnu: Wiring the speaker had some challenges because wires were not connected into the right ports.
Discussion:
The entire process of brainstorming, planning, and creating the double transducer was filled with its unique set of problems and triumphs. From the beginning, we were not familiar with vibration as an input and we were not sure how ambitious we should be with our middle step. We played around with a couple of ideas, including a basic vibration to light to sound workflow. Excluding the vibration portion, we were confident we could get the “light” middle step (LED + photoresistor) to work and output sound; this would serve as a good backup plan in case a more ambitious setup failed.
The ambitious idea we settled on was a system of vibration to movement to sound. We decided to split the “movement” into two parts: One part performing the movement (a Servo motor with a lever attached), and the other part sensing proximity and outputting a distance value (via an ultrasonic ranger). We found that while the idea was simple enough, the middle step ran into significant challenges.
Most notably, we had to restrict the servo motor from its total range, in order to constrain it to the board as well as prevent it from ripping out of its supports. This was mainly achieved through trial and error, and each of us had slightly different ranges based on the physical layout of our board and device.
With help from Zach, we realized that a good stand-in for a vibration sensor was a 3-axis accelerometer. The accelerometer senses the position (X,Y, Z) of the device if it is even slightly shifted. We realized that this could work to our advantage, although we needed to manually manipulate it to achieve the output. We found that because we had to twist the accelerometer around, we had to make sure to bolt the apparatus down through soldering and tape.
This project definitely pushed us to understand the real-world limitations of theoretical concepts. While there were chunks of the project we could neatly resolve in software, there were other parts we simply had to stress-test through empirical trials (such as the servo extension). Overall, we came away with a solid understanding of the relationship between different mediums, as well as the interlocking nature of software and hardware in electronics.
Functional Block Diagram:
Schematic:
Code:
/*
60-223, Double Transducer : Vibration to Movement to Sound
Shuyu Zhang, Vishnu Raghavan
Description: Our doubel transducer takes in vibration as an input.
The input is measured by a 3-axis accelerometer. The difference between
the input from the x-axis and y-axis is then mapped to an angle
for a servo motor (130-180 degrees). In real life, the servo motor is
attached to a popsicle arm that will extend based on the angle the servo
motor moves to. An ultrasonic ranger sits in front of the popsicle arm
and measures how close or far the arm is from it. The data from the
ultrasonic ranger is then mapped to a tone (100-600) which is the output
for a speaker.
Sources:
1) Heavily referenced the program on the maker cards website when programming the
accelerometer
2) Incorporated some of the code of an example from the HCSR04 library in order
to read distance with the ultrasonic ranger
3) Referenced the Servo Motor example from class to program the servo motor
4) Used LCD Display wiring and program from Arudino Website to program the
LCD Display
Pin mapping:
Arduino pin | type | description
------------|--------|-------------
12 LCD Pin Used to initialize the LiquidCrystal Library
11 LCD Pin Used to initialize the LiquidCrystal Library
5 LCD Pin Used to initialize the LiquidCrystal Library
4 LCD Pin Used to initialize the LiquidCrystal Library
3 LCD Pin Used to initialize the LiquidCrystal Library
2 LCD Pin Used to initialize the LiquidCrystal Library
9 Output Servo Motor pin
6 Output Buzzer pin
13 Input Trigger Pin in the Ultrasonic ranger
7 Input Echo Pin in the Unltrasonic ranger
A0 Input Analog input pin for X movement
A1 Input . Analog input pin for Y movement
A2 Input Analog input pin for Z movement
*/
#include <HCSR04.h>
#include <Servo.h>
#include <LiquidCrystal.h>
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
Servo motor;
byte triggerPin = 13;
byte echoPin = 7;
const int SERVOPIN = 9; //Analog
const int BUZZER = 6; //Analog output in for 8Ω Speaker
const int ACCELXPIN = A0; // Analog input pin for X movement
const int ACCELYPIN = A1; // Analog input pin for Y movement
const int ACCELZPIN = A2; // Analog input pin for Z movement
const int TIMERWAIT = 1000;
const int MOTORWAIT = 200;
// Variables to keep track of the current positions
int accelXPos = 0;
int accelYPos = 0;
int accelZPos = 0;
int dist;
int angle;
int currTone;
int accelData;
unsigned long timer = 0;
unsigned long motorTimer = 0;
void setup() {
Serial.begin(9600);
//Set up for ultrasonic ranger
HCSR04.begin(triggerPin, echoPin);
//Set up for servo motor
motor.attach(SERVOPIN);
// Setup the accelerometer inputs
pinMode(ACCELXPIN, INPUT);
pinMode(ACCELYPIN, INPUT);
pinMode(ACCELZPIN, INPUT);
//Setup for buzzer output
pinMode(BUZZER, OUTPUT);
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
}
void loop() {
// Get the current states
accelXPos = analogRead(ACCELXPIN);
accelYPos = analogRead(ACCELYPIN);
accelZPos = analogRead(ACCELZPIN);
//declares a variable to read distance for ultrasonic ranger
double* distances = HCSR04.measureDistanceCm();
accelData = abs(accelXPos - accelYPos); //Gives range of (0-90)
//Mapping Accelerometer data to an angle
angle = map(accelData, 0, 90, 130, 180);
//Set at a delay of 200 milliseconds
//c
if (millis() - motorTimer > MOTORWAIT) {
motorTimer = millis();
dist = (int)(distances[0]);
currTone = map(dist, 0, 30, 100, 600);
tone(BUZZER, currTone);
//changes angle based on accelerometer input
//changes tone based on distance
motor.write(angle);
delay(200);
tone(BUZZER, currTone);
motor.write(angle);
delay(200);
}
//LCD Display Code
if (millis() - timer > TIMERWAIT) {
timer = millis();
lcd.setCursor(8, 1);
int midSen = map(dist, 0, 30, 0, 99);
lcd.print(midSen);
if (midSen > 100) {
lcd.clear();
}
//First Row on LCD
lcd.setCursor(0, 0);
lcd.print("i:");
int input = map(accelData, 0, 90, 0, 99);
lcd.print(input);
lcd.setCursor(7, 0);
lcd.print("m:");
int midAct = map(angle, 130, 180, 0, 99);
lcd.print(midAct);
//Second Row on LCD
lcd.setCursor(12, 1);
lcd.print("o:");
int output = map(currTone, 200, 600, 0, 99);
lcd.print(output);
}
}
]]>
Double Transducer
Images
Overall Photos
(Jud)
(Jun)
Detail Photos
Transducers in Action
TinkerCAD Simulation
Narrative Description
The cardboard stand on the left of the transducer has a pressure sensor attached to it which senses how hard it is pressed. Based off of this pressure, a light inside of the cardboard box turns on to a specific brightness. If the pressure sensor is pushed hard, then the light turns on very bright, and if it is pressed lightly, then the light is very dim. Inside of this box is also a light sensor that senses this change in the clear light’s brightness. According to the amount of change that occurs, a servo on the left side of the mechanism turns around. If the amount of light in the box increases, then the servo rotates counter-clockwise to match this amount of change. As all of this is happening, a display at the bottom of the machine shows the numeric values of all of these actions starting with the pressure sensor in the top left and ending with the servo in the bottom right of the screen.
Process
This image shows the soldering of the color sensor that we were originally going to use. The soldering was successfully done, and the device was working, but we decided not to use this sensor.
This image depicts the testing of the color output using three different color LED’s to see what was causing our multi-colored LED issue discussed later on.
This image shows the final step of the soldering process where our switch from color sensing to brightness became permanent.
This image shows the process of adding the potentiometer to the LCD in order to adjust its brightness. Initially, the v0 was connected to the ground instead of the potentiometer, and we were not able to adjust its brightness.
Discussion
The hardest part about this project was understanding how to use each of the components and figure out accurate mapping functions to make sure each component was being used to its full potential. The hardest component accomplish this with was the color sensor because of its 3 inputs. Since the color sensor has red, green, and blue inputs, the Force Sensitive Resistor’s (FSR) single output made connecting these two elements very challenging. In the end, after relentlessly searching for algorithms that would accomplish this goal for us, we decided to pursue an alternative method utilizing brightness instead. Reflecting back on this decision, however, it would’ve been a better idea to start out with trying to understand this conversion process and write our own algorithm as opposed to searching the internet for one we could implement. This could have possibly improved our ability to understand these converting algorithms later on if we needed to use them which may have resulted in the final product including this middle sensor.
Apart from this color sensing dilemma, we also ran into issues while trying to use the servo library and analogWrite functionality together. During our first testing stages of the different components, we had the multi-colored LED wired in such a way that it would receive PWM signals from pins 6, 9, and 10. Upon plugging everything in and trying to change the color of the LED, only the LED plugged into pin 6 would produce the desired effect. After lots of time spent trying to debug the circuit, we finally figured out that the issue existed with the way that the servo library interacts with the Arduino. In order for the servo library to function, part of the code disables the analogWrite function for pins 9 and 10 making our original circuit diagram invalid. Just switching the input pin placement for these LED’s fixed our problem entirely.
Reflecting back on the creativity of the project, it would’ve been both easier and more exciting/interesting to only use the red and blue LED’s for the middle step of the transducer. This would not only make the code simpler by removing the need to map one input to three values and back, but it would also have a more physical meaning aligning closer to traditional ways of depicting pressure. Adding this element could have made the transducer a little bit more interactive helping to produce a more meaningful interaction than what this final version creates.
Functional Block Diagram
Electrical Schematic
Code
/*
60-223, Double Transducer
Judson Kyle (judsonk)
Hyojun Jeong (hyojunj)
Collaboration and sources:
1) Used sample from Code Bites page on the 60-223 Intro to Physical
Computing website for serial communication to the MQTT bridge application
Description: This double transducer will convert pressure to light
to orientation through the use of a Force Sensitive Resistor (FSR),
a photoresistor, and a servo. The input of the FSR will drive the
brightness of an LED which is in an enclosed box with the photoresistor.
The photoresistor will read the LED brghtness and map it to an angle
which the servo can travel to. This will continuously happen until
the system is turned off. In addition, the input and output values for
each sensor and output will be mapped to a value from 0-99 and then
displayed in an LCD screen with the FSR reading on the top left, the
LED birghtness in the middle top, the photoresistor reading in the bottom
middle, and the servo output in the bottom right.
Pin mapping:
Arduino pin | type | description
------------|--------|-------------
A0 input Force Sensitive Resistor for sensing pressure
A1 input Photoresistor for sensing birhgtness ofLED
3 output LED pin for controlling brightness
4 output LCD enable pin
7 output LCD register select pin
8 output LCD pin D4
9 output LCD pin D3
10 output LCD pin D6
11 output Servo pin for control of servo's angle
12 output LCD pin D7
*/
//Include Libraries for LCD and Servo Motor
#include <LiquidCrystal.h>
#include <Servo.h>
//FSR pins
const int FSRPIN = A0;
//Photoresistor and LED pins
const int PHOTOPIN = A1, LEDPIN = 3;
//Servo object and variable creation
Servo gauge; //Create servo object "gauge"
int pos = 0; //Set pos varible to 0 (stores position of servo)
const int SERVOPIN = 5; //Variable holding servo pin number
//LCD object creation and pin attachment
const int en = 4, rs = 7, d7 = 12, d6 = 10, d5 = 9, d4 = 8;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
//Prepare timing values to reduce delay of writing to LCD
const int waitingValue = 100; // Time delay between readings
unsigned long lastTime = 0; // Variable to store the most recent time
//MQTT Variables
const unsigned long WAIT = 250; //25sec
unsigned long timer;
int inVal, outVal;
//Code to run once
void setup() {
//LCD Initialization
lcd.begin(16, 2);
lcd.print("Hello");
//Define inputs
pinMode(FSRPIN, INPUT);
pinMode(PHOTOPIN, INPUT);
//Define outputs
pinMode(LEDPIN, OUTPUT);
//Set gauge object to read from SERVOPIN
gauge.attach(SERVOPIN);
Serial.begin(115200); // qt_arduino_mqtt_bridge uses this rate
Serial.setTimeout(50); // wait ≤ 50 milliseconds to parse incoming data
}
//Code to loop through
void loop() {
// //Recieve input from previous transducer
// int ledVal = map(inVal, 0, 99, 0, 255);
//Convert pressure into light
int fsrValue = analogRead(FSRPIN); //Read FSR value and sotre in fsrValue
int ledVal = map(fsrValue, 0, 1000, 0, 255); //convert pressure to PWM signal
analogWrite(LEDPIN, ledVal); //Display brightness
//Convert light into servo orientation
int photoVal = analogRead(PHOTOPIN); //Read photoresistor to get brightness
int servoAngle = map(photoVal, 0, 750, 0, 180); //Convert brightss to degreeof rotation
//Rotate servo to correct angle and wait for it to get there
gauge.write(servoAngle);
delay(15);
//Output to LCD after every time interval
if (millis() - lastTime > waitingValue) {
lcd.clear();
lcd.print("i:" + String(map(fsrValue, 0, 1000, 0, 99))); //Print FSR input value in 0-99 range
//Set location of next print line to middle of the first row
lcd.setCursor(6, 0);
lcd.print("m:" + String(map(ledVal, 0, 255, 0, 99))); // Print LED value in 0-99 range
//Set location of next print to be the bottom middle of the LCD
lcd.setCursor(6, 1);
lcd.print(String(map(photoVal, 0, 750, 0, 99))); //color sensor output value in 0-99 range
//Set location of next print to be the bottom right of the LCD
lcd.setCursor(11, 1);
lcd.print("o:" + String(map(servoAngle, 0, 170, 0, 99))); // Print servo output value in 0-99 range
lastTime = millis();
}
//Transmit output data to next device
if (millis() - timer > WAIT){
outVal = map(servoAngle, 0, 170, 0, 99);
transmitSerialSignal();
timer = millis();
}
}
void serialEvent(){
/* You do *not* need to call this function in your loop;
it is a special function that will run whenever serial
data flows into the Arduino. */
/* The function assumes your machine's input value
is called "inVal" (change that variable name as needed) */
// if there is incoming serial data, read it
while (Serial.available() > 0){
// interpret incoming digits as integer and save into inVal
inVal = Serial.read();
}
}
void transmitSerialSignal(){
/* You should call this function 2-4 times/second in your
main loop to transmit information to the next Arduino
in the transmission chain. */
/* Assumes your machine's outgoing value is called outVal
(change that variable name as needed) */
Serial.println(outVal);
}
]]>
Tinkercad:
* the potentiometer on the left is representative of the rotary encoder. The DC motor and driver are representative of the stepper motor and driver
Overall:
Nicole’s final double transducer
Kevin’s Final Double Transducer
Detail Photos:
LCD input/output values
Servo motor “dial” (from 0º – 180º)
Close up of the connection between the stepper motor and rotary encoder
Final protoboard wiring
Brief Movies:
Description:
This device detects the amount of light through a photoresistor, and sends that signal to the stepper motor driver and stepper motor, which turns the rotary encoder at a certain speed. The rotary encoder determines how far it was rotated, and sends that data to the servo motor, which based on the data, turns to a certain angle (orientation).
Progress Images:
Figuring out the connection between the stepper motor and rotary encoder [Nicole]
An LCD that needs to be debugged [Nicole]
LCD setup with “Hello World” starter code from library [Kevin]
In-progress picture of soldering the photoresistor and encoder circuits onto a protoboard [Kevin]
Testing all the individual components put together for the first time! [Kevin]
Discussion:
I think one of the biggest hurdles for us was dealing with the unknown. We chose to use a rotary encoder, something that we weren’t really familiar with, causing a lot of uncertainty. We also had no idea how we were going to connect the stepper motor and rotary encoder together, so we winged that as well. In hindsight, I think we should’ve fleshed out our plan to the smallest detail before starting rather than going in with a vague idea. That would’ve saved a lot of headaches. However, on the other hand, going in with vague idea was a great way to force one to solidify their idea, since planning can only do so much.
Nicole: Planning first would’ve also helped me with my wiring, since once the LCD Display came along with its 6 more pins, I was just sticking them wherever there was available space. Ideally, if I had planned it out, I would have the pins consecutive with each other.
One of our challenges was that we needed 12 digital pins, meaning that we were either forced to do some challenging wiring to use something like a shift register or sacrifice one of the TX/RX pins. At first neither of us knew exactly what the implications of that would be, but we found out that we could not upload code to the Arduino or use serial communication while using these pins. This ended up being a headache when we were debugging issues with our code and wiring as if we forgot to unplug the TX pin the code failed to upload. The wire ended up breaking inside the pin, although luckily some needle nose pliers saved the day. I will be trying my best to avoid using these pins in the future by using a shift register or investing in an Arduino board with more pins.
Diagrams:
Functional Block Diagram
Functional Block Diagram
Schematic Diagrams
Nicole’s electrical schematic
*a few of Kevin’s pins are slightly different (see code), but the wiring is identical otherwise
Code:
Nicole’s Code
/*
60-223, Project 1: Double Transducer
Nicole Yu (nvy) Kevin Bender (kbender1)
Description:
This device detects the amount of light through a photoresistor, and
sends that signal to the stepper motor driver and stepper motor,
which turns the rotary encoder at a certain speed. The rotary encoder
determines how far it was rotated in the span of 2 seconds, and sends
that data to the servo motor, which based on the data, turns to a
certain angle (orientation).
Pin mapping:
Arduino pin | type | description
------------|--------|-------------
A0 input photoresistor
2 input rotary encoder pin A
3 input rotary encoder pin B
5 output servo motor
7 input stepper motor IN1
8 input stepper motor IN2
9 input stepper motor IN3
10 input stepper motor IN4
A1 output LCD RS
4 output LCD Enable
6 output LCD D4
11 output LCD D5
12 output LCD D6
13 output LCD D7
Sources:
1) How to wire and program the LCD from the Elgoo website:
https://drive.google.com/drive/folders/1BUe40Ibb9Bzi1JwRKywO1PCXBMzkFXm7?usp=sharing
2) I borrowed heavily from this Stepper motor library
and code: https://www.arduino.cc/en/Tutorial/LibraryExamples/StepperSpeedControl
3) I followed this tutorial and borrowed heavily its code:
https://www.seeedstudio.com/blog/2020/01/19/rotary-encoders-how-it-works-how-to-use-with-arduino/
4) I referenced the Canvas modules to refresh on how to wire and
code for a photoresistor and servo
*/
// LIBRARIES
#include <Encoder.h>
#include <Stepper.h>
#include <Servo.h>
#include <LiquidCrystal.h>
// VARIABLES
const int PHOTOPIN = A0; // photoresistor pin
const int DOORMOTORPIN = 5; // servo motor pin
const int stepsPerRevolution = 200; // stepper motor's
const int WAIT = 2000; // 2 seconds
unsigned long timerVariable = 0;
int orientation;
long oldPosition = -999;
// initialize library code
LiquidCrystal lcd(A1, 4, 6, 11, 12, 13);
Stepper myStepper(stepsPerRevolution, 7, 8, 9, 10);
Encoder myEnc(2, 3);
Servo doorMotor;
void setup() {
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
// servo
doorMotor.attach(DOORMOTORPIN);
}
void loop() {
// PHOTORESISTOR
int photoVal = analogRead(PHOTOPIN);
// STEPPER MOTOR
int motorSpeed = map(photoVal, 0, 1023, 0, 100);
if (motorSpeed > 0) {
myStepper.setSpeed(motorSpeed);
myStepper.step(stepsPerRevolution / 100);
// ROTARY ENCODER
long newPosition = myEnc.read();
// SERVO
int orientation = map(newPosition, 0, 17, 10, 170); // the 17 is a placeholder,
// I haven't seen the rotary encoder go past 16
// Sees at 2 seconds how far rotary encoder turned
if (millis() - timerVariable > WAIT) {
doorMotor.write(orientation);
myEnc.write(0); // resets encoder to 0
// LCD
// update LCD here
lcd.setCursor(0, 0);
lcd.print("i:"); // input
lcd.print(photoVal);
lcd.print(" "); // solution to non erasing problem
lcd.setCursor(8, 0);
lcd.print("m1:"); // middle step 1
lcd.print(motorSpeed);
lcd.print(" ");
lcd.setCursor(0, 1);
lcd.print("m2:"); // middle step 2
lcd.print(newPosition);
lcd.print(" ");
lcd.setCursor(8, 1);
lcd.print("o:"); // output
lcd.print(orientation);
lcd.print(" ");
timerVariable = millis();
}
// not > 2 seconds, update the old position
else {
if (newPosition != oldPosition) {
oldPosition = newPosition;
}
}
}
}
/*
* 60-223, Project 1
* Kevin Bender (kbender1)
* time spent: ~8 hours
*
* Collaboration and sources:
* 1) Nicole Yu and I worked together on the idea and
* electrical design, coded separately (other than tinkercad)
* 2) I borrowed from the Elegoo starter kit lesson 2.3 for the
* LCD
* 3) I borrowed from the Encoder library examples
* 6) I borrowed from the stepper library examples
*
* Challenge(s): This project took a lot of learning and research
* as it combined everything we had learned so far about
* Arduino and electronics. The challenges came in the form
* of trying to figure out how to use the LCD which didn't work
* with the manufacturer-recommended wiring of 3.3v and with the
* stepper motor which was much weaker than expected.
*
* Next time: I will try to learn more about potential inputs/outputs
* and possibly try them out in advance. A lot of suffering could
* have been saved by doing this with the stepper motor
*
* Description: Object detects light level, based on how intense light is it would cause a motor to spin fast/slow,
* and that speed would then affect the orientation of the servo motor “dial” (from encoder)
*
* Pin mapping:
*
* Arduino pin | type | description
* ------------|--------|-------------
* A0 input Photoresistor as initial input
* 1 input rotary encoder pin A for middle step input
* 13 input rotary encoder pin B
* 2 output Stepper motor driver pin A as middle step output
* 3 output Stepper motor driver pin B
* 4 output Stepper motor driver pin C
* 5 output Stepper motor driver pin D
* 6 output servo motor for final output
* 7 input pushbutton to activate lights
* 8 output LCD pin A
* 9 output LCD pin B
* 10 output LCD pin C
* 11 output LCD pin D
* 12 output LCD pin E
*/
// include the library code:
#include <LiquidCrystal.h>
#include <Encoder.h>
#include <Stepper.h>
#include <Servo.h>
const int stepsPerRevolution = 200;
const int ENC1 = 1;
const int ENC2 = 13;
const int LCD1 = 7;
const int LCD2 = 8;
const int LCD3 = 9;
const int LCD4 = 10;
const int LCD5 = 11;
const int LCD6 = 12;
const int STEP1 = 2;
const int STEP2 = 3;
const int STEP3 = 4;
const int STEP4 = 5;
const int SERVOPIN = 6;
const int PHOTORESISTOR = A0;
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(LCD1, LCD2, LCD3, LCD4, LCD5, LCD6);
Encoder myEnc(ENC1, ENC2);
Stepper myStepper(stepsPerRevolution, STEP1, STEP2, STEP3, STEP4);
Servo myservo;
void setup() {
myservo.attach(SERVOPIN);
// put your setup code here, to run once:
lcd.begin(16, 2);
// Print a message to the LCD.
pinMode(PHOTORESISTOR, INPUT);
}
void loop() {
long t0 = millis();
long speed = 0;
long lastPos = myEnc.read();
while (true) {
long t = millis();
myEnc.read();
int motorSpeed = map(analogRead(PHOTORESISTOR), 0, 1023, 0, 100);
// set the motor speed:
if (motorSpeed > 0) {
myStepper.setSpeed(motorSpeed);
// step 1/100 of a revolution:
myStepper.step(stepsPerRevolution / 100);
}
if (t - t0 > 1000) {
long curPos = myEnc.read();
speed = abs(curPos-lastPos);
long pos = map(speed,0,15,0,180);
myservo.write(pos);
lastPos = curPos;
lcd.setCursor(0, 0);
lcd.print( "i: " + String(map(analogRead(PHOTORESISTOR), 0, 1023, 0, 99)) + " m: "+String(motorSpeed));
lcd.setCursor(0, 1);
lcd.print(" " + String(speed)+ " o: " + String(map(pos,0,180,0,99)));
// print the number of seconds since reset:
t0 = t;
}
}
}
]]>
Initial Sketches and Block Diagram:
For the middle step on our transducer, we were deciding between having a servo drive a potentiometer, having a servo drive a platform with an accelerometer, and having a speaker output measured by a microphone. We ended up deciding on the servo – accelerometer pair, but also made a servo – potentiometer prototype as an initial version to test various components on.
TinkerCAD Exploration
Ultrasonic to Potentiometer to LED
Erica’s Version
This was the initial double transducer design we had. My project was barely held together. I had to tape the micro servo to the Maker Cards and used the wire cutter to hold the breadboard down so that the board wouldn’t lift when the servo motor turned the potentiometer.
Using an ultrasonic ranger, I detected the distance from the build. The ranger determined the angle of the servo motor which was attached to the potentiometer. This potentiometer then determined the brightness of the LED.
By replacing the small breadboard with a bigger version, I was able to make a less cluttered double transducer.
Here is a video of my working double transducer. I displayed the input and output values using the Serial Monitor on Arduino. Through the video, you can see that the light turns brighter when the box is closer to the ultrasonic sensor and dimmer when the box is further away.
Eric’s Version
Similar to Erica’s version, I connected the servo to the potentiometer through a paperclip and servo mount.
Due to the noisiness of the ultrasonic data, I added a moving average filter to smooth that out. Also, I found out the analog input pins do not have PWM capabilities which was a helpful reference for later.
Ultrasonic to Accelerometer to LED
Erica’s Contribution
We soldered the 3-axis accelerometer and a terminal, ensuring a strong connection for our middle step in the transducer. The final configuration of the objects on the board was tightly put together, with the 3-axis accelerometer acting like a protective hood over the terminal.
For the final project, I also configured the LCD to display the outputs. Working with the LCD was difficult because of the intense amount of wiring, but through following tutorials online, I was able to successfully have the LCD display our input and output values.
Eric’s Contribution
To convert the accelerometer’s 3-axis acceleration readings into an angle value that could be interpreted as a parallel to the servo’s rotation, there was a little trig involved (taking an inverse tangent of two axes, modeled after the unit circle). The above clip is me testing the accelerometer’s analog inputs and figuring out the range of raw inputs to map to -1 and 1 for both x and y values on the unit circle.
For the final transducer, I soldered part of the proto-board that the accelerometer attaches to and mounted the the board onto the servo arm via paper clips.
Detail Shots of Final Project
Code
/*
* 60-223, Project 1
* Eric Zhao (ezhao2), Erica Fu (efu)
* time spent: 20 hours
*
* Collaboration and sources:
* 1) Eric and Erica worked together from planning, coding, to building the final project
* 2) Zach assisted many times throughout the process
* 3) We borrowed heavily from the Arduino guide to use the LiquidCrystal library
* website link: https://www.arduino.cc/en/Tutorial/LibraryExamples/HelloWorld
* 4) We implemented this moving average filter to smooth out ultrasonic data values:
* https://courses.ideate.cmu.edu/60-223/s2021/tutorials/code-bites#exponential-moving-average-filter
* Challenge(s): Since there are many wires, the wiring often became jumbled and confusing.
* Also, the LCD display could only use certain pins, causing us to have to rewire the whole project.
* The connection from the servo motor to the 3-axis-accelerometer was also quite difficult since
* we had to customize parts and eventually settle for using a paperclip to make a mechanical connection.
*
* Next time: We will organize wiring better so that the circut is clearer so that any change
* of wiring will be less confusing.
*To prevent breaking any more Arduinos, Erica will double check the wiring to ensure that
* there is minimal damage caused in the future.
*
* Description: The entire breadboard is mounted to a servo motor whose output shaft is connected to a
* rigid vertical structure. Depending on the input voltage from the ultrasonic sensor, the servo motor
* will output a corresponding angle, causing the entire breadboard to rotate. An accelerometer attached
* to the breadboard will read the tilt angle of the breadboard caused by the servo. The input voltage
* will determine the output voltage of the LED.
*
* Pin mapping:
*
* Arduino pin | type | description
* ------------|--------|-------------
* A0 input xInput of the 3-axis accelerometer
* A1 input yInput of the 3-axis accelerometer
* A2 input zInput of the 3-axis accelerometer
* 9 output mini servo motor
* 6 output red LED
* 12 output rs pin for the LCD monitor
* 11 output en pin for the LCD monitor
* 5 output d4 pin for the LCD monitor
* 4 output d5 pin for the LCD monitor
* 3 output d6 pin for the LCD monitor
* 2 output d7 pin for the LCD monitor
*
*/
#include <Servo.h>
#include <NewPing.h>
#include <LiquidCrystal.h>
#define TRIGGER_PIN 8
#define ECHO_PIN 7
#define MAX_DISTANCE 75
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
const int waitTime = 250;
long prevTime = 0;
const int xInput = A0;
const int yInput = A1;
const int zInput = A2;
const int SERVOPIN = 9;
const int LED = 6;
Servo SERVO;
float filtered_val = 0; // this variable, of type float (decimal), holds the filtered sensor value
const float PREV_WEIGHT = 0.8; // this variable, of type float (decimal), determines the previously filtered value's weight.
const float CUR_WEIGHT = 1 - PREV_WEIGHT; // this variable, of type float (decimal), determines the current sample's weight.
const int SENSOR_PIN = A0; // this variable, of type int, determines the sensor's pin.
// initialize the library by associating any needed LCD interface pin
// with the arduino pin number it is connected to
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
void setup() {
// put your setup code here, to run once:
pinMode(xInput, INPUT);
pinMode(yInput, INPUT);
pinMode(zInput, INPUT);
pinMode(LED, OUTPUT);
SERVO.attach(SERVOPIN);
Serial.begin(115200);
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
}
void loop() {
// put your main code here, to run repeatedly:
delay(50);
//raw data by axis from accelerometer
int x = analogRead(xInput);
int y = analogRead(yInput);
int z = analogRead(zInput);
//data from accelerometer, mapped to units -1000 to 1000
int xVect = map(x, 260, 390, -1000, 1000);
int yVect = map(y, 250, 380, -1000, 1000);
int zVect = map(z, 320, 385, 0, 1000);
//below variables are the above vars but divided by 1000 to achieve unit circle
float xVectUnbound = xVect/1000.0;
float yVectUnbound = yVect/1000.0;
float zVectUnbound = zVect/1000.0;
//constraining final readings to unit circle -1 to 1
float xVectFinal = constrain(xVectUnbound, -1, 1);
float yVectFinal = constrain(yVectUnbound, -1, 1);
float zVectFinal = constrain(zVectUnbound, 0, 1);
//final arctan value (takes two axes and converts into degrees)
float degreeVal = atan2(xVectFinal, zVectFinal) * 180/PI;
//creates a weighted reading
float cur_reading = sonar.ping_cm();
if(cur_reading != 0){
filtered_val = filtered_val * PREV_WEIGHT + cur_reading * CUR_WEIGHT;
}
//takes a smoothed out sonar reading and converts to servo degrees
int servoVal = map(filtered_val, 0, 75, 0, 180);
//takes accelerometer degree reading and converts to
int outputVal = map(degreeVal, -55, 90, 0, 255);
if(cur_reading != 0 && servoVal > 0){
SERVO.write(servoVal);
}
if(outputVal > 0){
analogWrite(LED, outputVal);
}
int inputDisplay = map(filtered_val, 0, 75, 0, 100);
int middleActDisplay = map(servoVal, 0, 180, 0, 100);
int middleSensorDisplay = map(outputVal, 0, 255, 0, 100);
if(millis() - prevTime > waitTime){
//outputs data to LCD display 4 times a second
lcd.setCursor(0,0);
lcd.print((String)"i:"+ inputDisplay);
lcd.setCursor(5,0);
lcd.print((String)"m:" + middleActDisplay);
lcd.setCursor(7,1);
lcd.print(middleSensorDisplay);
lcd.setCursor(11,1);
lcd.print((String)"o:" + middleSensorDisplay);
prevTime = millis();
}
}
Reflection
We found a lot more issues throughout the span of this project than either of us imagined would happen! Different libraries conflicted with each other (for example, the Servo library shut down certain pins that the NewPing ultrasonic library utilized). Mechanical connections between certain parts were difficult to make robust enough to handle the servo’s torque; we ended up using paperclips for a lot of these as compared to tape, which was a lot weaker.
]]>The potentiometer in this video is representative of our joystick middle step.
Overall photos for proportion and scale
Tate
Tate’s final board
My final version had correct transduction and displayed values at good fidelity, but even with an added transistor to the vibration motor it drew so much current that it would dim the LCD screen, but otherwise, this version had a functioning double transduction.
Dominique
Dominique’s final board
At first I thought my final version had some wiring issues surrounding the vibration motor, but upon closer inspection, and the addition of a replacement vibration motor, my double transducer actually worked fine. The LCD sensor and actuator values were being displayed properly, and luckily, it did not dim when the vibration motor was triggered, and I did not use a transistor, so this was a peculiar but happy outcome.
Final Working Version in Chain
Prototype Details
At first our LCD had many display issues. First the backlight would not turn on, then the values flashed too fast, and so forth. After implementing a special delay in void loop and switching libraries, we were able to fix the problems, at least on one of our prototypes.
Servo-joystick prototyping
We used our two prototypes to test different things, Dominique’s explored the LCD more and mine focused on the mechanical interface from servo to the joystick.
Prototype video
Hopefully, you can hear the vibration motor buzzing in this video as I move the flashlight closer to the photoresistor on the other end of the board. And you can see the middle step (servo moving a joystick) as well. I had to cover the photoresistor with my hand in order to block out ambient light (that was really messing with the sensory data because it was a very bright room and my flashlight was dying), so you can’t quite see the flashlight action, but it’s happening, please trust me.
Simple narrative description
Our double transducer first takes in light in a room and records the brightness through the Arduino. That value is then used to determine the rotation degree of a servo motor; more light equals a higher degree up within a specified range. The servo pushes on a joystick, from which a y-Axis position is read and stored in Arduino. Finally, a vibration motor receives that output and vibrates more as the y-axis position increases.
Progress images
Tate
LCD hieroglyph issues
I struggled a lot with my LCD displaying odd values because of the vibration motor current draw creating noise in the circuit.
Servo-Joystick interface and soldering to protoboard
I also struggled a lot with soldering, as I accidentally grabbed a non-powered protoboard so after soldering my adapters for the servo and joystick I had a long period of debugging to find the cause of that. It was good soldering practice because I had to bridge connections with quarter-inch lengths of wire.
Dominique
Prototyping popsicle stick connection
The hardware for this circuit was actually relatively simple to build, at least on the breadboard. The hard part was configuring the delicate servo to properly trigger the joystick. So as you can see here, that problem has not been solved yet.
LCD prototyping
This was when the LCD still was not working properly. As you can see, it is not displaying anything, and that’s due to a number of reasons which are explained in detail in the Discussion section. The biggest problem here was that the LCD was wired incorrectly.
Discussion
Even though we went into the project anticipating the hardware components for wiring a transducer that involved a joystick would be complex, that part ended up not being that difficult and only took a short amount of time to configure.
As far as the difficult aspects of the project, we ran into a lot of hiccups with writing to the LCD. One of the issues was especially mundane and we did not realize it; for the longest time, the LCD would not display any coherent information, despite the code looking to be fine. After consulting with Zach, we discovered that we were not using the right library the whole time. We were using commands from LiquidCrystal_I2C and but the LCD we have does not have the I2C backpack. So not only did we not realize we had a different LCD than the tutorials, we were wiring it wrong. Anyway, we sorted this, fortunately, but the LCD on one of the two double transducers we built still had issues we could not troubleshoot.
We also had a strange issue where as our joystick value went up, the vibration intensity went down. We wanted both to increase in direct proportion. Turns out there was a typo for one of our map() functions where the value was reversed. Also we ended up writing a bit of extra code that constrained the max value of joystickVal which helped to keep our values in line.
Tinkercad also had its own set of issues. because some inputs could not be sensed by Tinkercad, we had to “fake it.” It was interesting figuring out how to do this, but ultimately not too challenging. Since the first input is light, we could simply make that value increase and decrease automatically and the rest of the sensors and actuators respond accordingly. Because there’s no joystick in Tinkercad, we replaced it with a potentiometer, just to clarify.
There’s also the issue of figuring out how to get the tiny servo arm to push the joystick, which does not budge very easily. We used superglue to glue half a popsicle stick to the arm, as you can see in the photos, and we taped down the motor, which did help. The motor on one transducer pushed sideways on the joystick, and the motor on the other was configured to push downward, and both seemed to work fine.
Finally, for one of the two double transducers we built, it unfortunately broke after working properly a few times. The cause of the break is still kind of unknown even after checking the serial monitor and wiring. Because it was only the vibration motor that stopped responding even though the vibration value was displaying appropriately, we figured it was a wiring issue, one of the complications from a less-than-stellar soldering technique. It did look like the vibration wires were burned and not very attached, but after replacing the vibration motor and still finding issues, we figured the problem was deeper in the hardware. That was until I switched power sources and everything was completely fine. I agonized for hours over this very simple issue (Dominique).
For future projects it certainly would be useful to get a better grasp on soldering with a steady hand. That did not seem to be my strong suit, and I’m sure it will be a useful skill for the future (Dominique).
Functional block diagram and schematic
Block diagram
Schematic drawing
Here is the code
/*
Double Transducer: Light to Position to Movement
Dominique Aruede and Tate Johnson
Description:
Takes in a light value which informs the degree rotation
of a servo arm which pushes a joystick which informs the
vibration intensity of a vibration motor.
Pin mapping:
Arduino pin | type | description
------------|--------|-------------
A0 input photoresistor for initial input
A2 input reads joystick x axis (only needed in this sketch to keep the y axis stable)
A3 input reads joystick y axis
A4 input reads vibration motor output
2 output writes to pin D7 on LCD
3 output writes to pin D6 on LCD
4 output writes to pin D5 on LCD
5 output writes to pin D4 on LCD
6 output writes to vibration motor
8 output writes to servo motor
11 output writes to enable pin on LCD
12 output writes to RS pin on LCD
Collaboration and sources:
- https://www.arduino.cc/en/Tutorial/LibraryExamples/HelloWorld
- https://canvas.cmu.edu/courses/22031/modules (photoresistor asynchronous lecture)
*/
#include <Wire.h>
#include <LiquidCrystal.h>
#include <Servo.h>
//pin constants
const int PHOTORESPIN = A0;
const int SERVOARMPIN = 8;
const int JOYSTICKPINx = A2;
const int JOYSTICKPINy = A3;
const int VIBRATIONPIN = 6;
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
const int WAIT = 300;
unsigned long timerVariable = 0;
int lightVal = 0;
int armVal = 0;
int joystickVal = 0;
int vibVal = 0;
/* Create an LCD display object called "screen" with I2C address 0x27
which is 16 columns wide and 2 rows tall.*/
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
Servo arm; // make a servo object
void setup()
{
// initiate pins
pinMode(PHOTORESPIN, INPUT);
pinMode(JOYSTICKPINy, INPUT);
pinMode(VIBRATIONPIN, OUTPUT);
// servo is plugged into the assigned pin on Arduino
arm.attach(SERVOARMPIN);
//LCD setup
lcd.begin(16, 2);
}
void loop()
{
//digitalWrite(VIBRATIONPIN, HIGH);
//convert light sensing to right range
lightVal = analogRead(PHOTORESPIN);
int LCDlightVal = 0;
LCDlightVal = map(lightVal, 0, 1023, 0, 99);
//write to the transducer first part
armVal = map(lightVal, 0, 1023, 0, 170);
int LCDarmVal = 0;
LCDarmVal = map(lightVal, 0, 1023, 0, 99);
arm.write(armVal);
//read the second transducer part
joystickVal = analogRead(JOYSTICKPINy);
if (joystickVal >= 512) {
joystickVal = joystickVal - 512;
}
else {
joystickVal = 0;
}
int LCDjoystickVal = 0;
LCDjoystickVal = map(joystickVal, 0, 512, 0, 99);
// write to output
vibVal = map(joystickVal, 0, 512, 0, 255);
analogWrite(VIBRATIONPIN, vibVal);
int LCDvibVal = 0;
LCDvibVal = map(vibVal, 0, 255, 0, 99);
if (millis() - timerVariable > WAIT) {
lcd.clear();
lcd.home();
lcd.print("i:");
lcd.print(LCDlightVal);
lcd.print(" m:");
lcd.print(LCDarmVal);
lcd.setCursor(8, 1);
lcd.print(LCDjoystickVal);
lcd.setCursor(12, 1);
lcd.print("o:");
lcd.print(LCDvibVal);
timerVariable = millis();
}
}
]]>
Images:
James’ final build
Amelia’s final build
Taped connection between vibration motor and accelerometer for best transfer of signal
Cover for the light sensing part of transducer to get rid of noise from environment
Slot restricting the motion of Popsicle stick to mostly linear movement to create a change in distance
Narrative:
A vibrator is attached to a sensor which senses the rate of vibration. Based on this vibration, a light is turned on underneath a box. How much the vibrator vibrates determines how bright the light gets. So if the vibrator vibrates a lot, the light gets really bright, and if the vibrator does not vibrate a lot, the light does not get as bright. The brightness of the light is captured by another sensor which senses how bright the light is. The sensor then tells the computer how much to turn a motor to move a stick. So if the light is really bright, the motor is told to move the stick very far, and if the light is not as bright, the motor is told to move the stick not as far. The states of all of these inputs and outputs (i.e. the level of change) is fed to a display that shows how much each step has changed.
Progress images:
Diagnosing the noise in the analog input pins with an oscilloscope
Vibration motor connected to two wires with male ends to make better and more maneuverable connection to bread board
One of the many ways we tried to sense vibration frequency. Here we are trying to measure the duty cycle of the PWM type input from the vibration motor.
Putting together the distance component for the first time to get the layout
Discussion:
Throughout the development process, the easiest part was definitely the planning stage. The stage where we brainstormed three different ideas and paid little attention towards the actual build. It was a time where we let our imaginations run wild and had little to debug since the projects weren’t fully implemented, only idealized. Once we finally got to the building and coding stage however, we found implementing past the planning phase is much harder. It involved having to build the circuit while making sure none of the wires had loose connections, building a connection between the vibration motor and Arduino which meant stripping two male- to-female wires as well as the vibration motor and securing them together with athletic tape (neither of us had electrical tape on standby), measuring the value of the accelerometer with a broken accelerometer (which we only later realized), soldering an LED and photoresistor, building a linkage system out of popsicle sticks, and figuring out the code to tie these pieces together. All of these steps came with their own frustrating challenges that allowed us to grown our knowledge of sensors and Arduino development
The most frustrating thing that we learned was that analog input pins on the Arduino can pick up a lot of noise from other parts of the board. In particular, adjacent analog input pins can read signals from each other almost as if they were connected. In our case, we thought the accelerometer was wired to the Arduino and we were reading a signal from it, but it turned out to not be connected to the Arduino at all. Despite this fact, we still read an analog input from that pin and when compared to the signal produced by the potentiometer, the signals matched exactly in how they changed with input into the potentiometer. Instead of reading the accelerometer data, we were actually reading ghost signals from the adjacent potentiometer input pin which was only solved by moving the accelerometer input pin to the opposite side of the analog input pin array.
We also learned the importance of data structures in signal processing, especially when performing arithmetic operations. While trying to write values to our stepper motor, we came into a problem where we couldn’t get our code to run for more than 1 loop. This was caused by the way in which we were storing the variables used to calculated step count. We chose to store the all our variables as type “int” by default which meant that it would round down to the nearest integer when it stored the step value. The some of the values we were setting as the used to calculate the number of steps, however, were on a scale of 0 to π which meant that they were frequently in between 0 and 1. Because these values were rounded down even if they were 0.9, this meant that we ended up with division by zero causing our program to break and only run once. Storing the variables used to calculate step number solved this problem.
Looking back now, there are several factors that would’ve changed the direction of the project completely. For instance, the first time we met to work on the project was the Sunday before the project was due because we thought it was plenty of time before the deadline. This was a mistake on our part and we should’ve been more proactive about meeting before Sunday (i.e. on Friday and Saturday). This would’ve given us more time to realize where we were going wrong and what we could’ve done to fix the problem. Another factor would’ve been a better sensor to detect the frequency of the vibration coming from the vibration motor. We noticed that the accelerometer was pretty noisy and we had trouble reading the sensor. Maybe these changes would have improved our project, or possibly caused new problems, but these are just a few we’ve chosen to reflect on.
Functional Block Diagram and Schematic
Code Submission
/*
60-223, Project 1
Amelia Lopez (aelopez)
James Kyle (jkyle1)
Time spent: 8 hours
Description:
Takes in a vibration input, transforms that analog input value
into an LED brightness, which is then transformed into a distance
controlled by the stepper motor. Vibration input is read through
an accelerometer and LED intensity value is read through a photoresistor.
Challenges:
The stepper motor isn't responding to the photoresistor's value as
we intended, so that half of the code is buggy. Since the vibration
motor works on a pulse, this causes the light to blink fairly fast but
it still dims/brightens as a result of the vibration motor speed.
Next time:
Definitely take more time to understand what went wrong between the
photoresistor value and the stepper motor desired output. I think
looking at the Arduino libraries is a good place to start with this
because maybe someone else had the same problem and published their
solution for open source use that we can cite and tweak to the specs
of our project
Collaboration and Sources:
1) For the accelerometer readings (line 163-167), used code from
https://tinyurl.com/Accelerometerlink
2) For LCD display, used code from http://www.arduino.cc/en/Tutorial/LiquidCrystalHelloWorld
3) For stepper motor, used code from https://tinyurl.com/StepperMotorLink
Inputs: Potentiometer (which varies vibration motor rate)
In-between: LED
Output: Stepper motor, LCD display
Pin mapping:
Arduino pin | type | description
------------|--------|-------------
A0 input potentiometer
A1 input X-pin Accelerometer
A2 input Y-pin Accelerometer
A3 input Z-pin Accelerometer
A4 input photoresistor
13 output Stepper Motor Driver IN1
12 output Stepper Motor Driver IN2
~11 output Vibration motor
~10 output Stepper Motor Driver IN3
~9 output Stepper Motor Driver IN4
8 output LCD RS
7 output LCD E
~6 output LED
~5 output LCD D4
4 output LCD D5
~3 output LCD D6
2 output LCD D7
(digital PWM~)
LCD circuit:
LCD RS pin to digital pin 8
LCD Enable pin to digital pin 7
LCD D4 pin to digital pin 5
LCD D5 pin to digital pin 4
LCD D6 pin to digital pin 3
LCD D7 pin to digital pin 2
LCD R/W pin to ground
LCD VSS pin to ground
LCD VCC pin to 5V
10K resistor:
ends to +5V and ground
wiper to LCD VO pin (pin 3)
*/
#include <Stepper.h>
#include <LiquidCrystal.h>
//DECLARING ARDUINO PINS
const int POTENT = A0;
const int ACCE_X = A1;
const int ACCE_Y = A2;
const int ACCE_Z = A3;
const int PHOTORES = A4;
const int STEP_IN1 = 13;
const int STEP_IN2 = 12;
const int VIBRATION_MOTOR = 11;
const int STEP_IN3 = 10;
const int STEP_IN4 = 9;
const int LCD_RS = 8;
const int LCD_E = 7;
const int LED_PIN = 6;
const int LCD_D4 = 5;
const int LCD_D5 = 4;
const int LCD_D6 = 3;
const int LCD_D7 = 2;
//DECLARING INTS FOR ACCELOREMETER AND LED
int accel_xVal = 0;
int lightVal = 0;
//DECLARING MISC. CONSTANTS USEFUL TO STEPPER MOTOR
const int maxAnalogValue = 1023;
const int stepsPerRevolution = 64; //fits the specification of our motor
const int motorSpeed = 20;
float currentDistance = distOfString / 2; //PRECONDITION: OBJECT HAS TO BE HALFWAY
int targetDistance;
float steps;
bool stepMotor = false;
//DECLARING INTS FOR LCD WAITING TIMES
const int WAIT_TIME = 300;
unsigned long timeVariable = 0;
// initialize the library by associating any needed LCD interface pin
// with the Arduino pin number it is connected to
LiquidCrystal lcd(LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7);
Stepper myStepper(stepsPerRevolution, STEP_IN1, STEP_IN2, STEP_IN3, STEP_IN4);
void setup() {
//INPUT PINS
pinMode(POTENT, INPUT);
pinMode(VIBRATION_MOTOR, OUTPUT);
pinMode(ACCE_X, INPUT);
pinMode(ACCE_Y, INPUT);
pinMode(ACCE_Z, INPUT);
pinMode(PHOTORES, INPUT);
//OUTPUT PINS
pinMode(LED_PIN, OUTPUT);
pinMode(VIBRATION_MOTOR, OUTPUT);
//MOTOR functions
myStepper.setSpeed(motorSpeed);
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
//print constant letters on screen
lcd.print("i:");
lcd.setCursor(6, 0);
lcd.print("m:");
lcd.setCursor(8, 1);
lcd.print("0");
lcd.setCursor(12, 1);
lcd.print("o:");
}
void loop() {
//READING POTENTIOMETER VALUE
//POTENTIOMETER VALUE DETERMINES VIBRATION MOTOR RATE
int potentValue = analogRead(POTENT); // 0 <= potentValue <= 1023
int vibrationStrength = map(potentValue, 0, 1023, 0, 153); // 0 <= vibrationStrength <= 155
analogWrite(VIBRATION_MOTOR, vibrationStrength); //using PWM
int xVal = analogRead(ACCE_X);
//ACCELEROMETER MEASURES VIBRATION MOTOR RATE (x-axis)
//RATE MEASURED IS USED TO LIGHT UP AN LED A CERTAIN INTENSITY
int oldX = accel_xVal;
accel_xVal = analogRead(ACCE_X);
int dif = abs(oldX - accel_xVal);
int lightVal = map(dif, 0, 520, 0, 255);
analogWrite(LED_PIN, lightVal);
//PHOTORESISTOR TAKES IN LED INTENSITY VALUE
//PHOTORESISTOR VALUE USED TO CHANGE STEPPER MOTOR
int photoValue = analogRead(PHOTORES); // 0 <= potentValue <= 1023
int lowbound = 700; //bright light
int highbound = 990; //no light
//int stepVal = map(photoValue, lowbound, highbound,
targetDistance = map(photoValue, 850, 1000, 0, 60);
//Convert photoresistor value into desired distance into rotations for stepper motor
if (targetDistance != currentDistance) {
steps = (targetDistance - currentDistance) * stepsPerRevolution / 360;
currentDistance = targetDistance;
stepMotor = true;
}
//Setting step stepper motor to desired distance
if (stepMotor == true) {
myStepper.step(steps);
delay(500); //Wait 0.5s for motor to finish moving
stepMotor = false;
}
//UPDATING VALUES ON LCD
if (millis() - timeVariable > WAIT_TIME) {
//updating input sensor value
lcd.setCursor(2, 0);
lcd.print(map(xVal, 0, 525, 0, 99));
//updating middle step actuator
lcd.setCursor(8, 0);
lcd.print(map(lightVal, 0, 255, 0, 99));
//updating middle step sensor value
lcd.setCursor(8, 1);
lcd.print(map(photoValue, lowbound, highbound, 0, 99));
//updating output actuator value
lcd.setCursor(14, 1);
lcd.print(map(steps, 0, currentDistance, 0, 99));
delay(200);
timeVariable = millis();
}
}
]]>