Intro to Mechatronics Elec -10: 2016

Saturday, February 13, 2016

Day 15 to 18 - Fire Fight Challenge

Our objective was to autonomously program a Vex Squarebot robot to navigate throughout a maze and blow out a candle. There were four rooms and the candle was randomly placed in one of the rooms. In order to have the candle detect the candle we used an IR detector to sense the heat from the candle and we used encoders on the wheels to make sure that the robot could have been commanded to go through the maze.

Here is the code for our robot.#pragma config(Sensor, in1, rightEncoder, sensorRotation)
#pragma config(Sensor, in3, leftEncoder, sensorRotation)
#pragma config(Sensor, in4, fan, sensorDigitalOut)
#pragma config(Sensor, in6, frontIRSensor, sensorAnalog)
#pragma config(Sensor, in14, frontSonarSensor, sensorSONAR, int1)
#pragma config(Motor, port2, rightMotor, tmotorServoContinuousRotation, openLoop, reversed)
#pragma config(Motor, port3, leftMotor, tmotorServoContinuousRotation, openLoop)

void clearEncoders();
void forward(int x);
void tleft(int x);
void tright(int x);
void backwards(int x);
void stop(int x);
void search();
void flame();

task main()
{
wait1Msec(2000);
bMotorReflected[port2] = true;
while(true)
{
//approach room 1//
clearEncoders();
stop(200);
forward(200);
stop(800);
tright(85);
stop(800);
forward(190);
stop(800);
tright(70);
stop(800);

//enter room 1 //
forward(130);
stop(800);
flame();
stop(800);
tleft(115);
stop(100);

//exit room 1 and approach room 2//
backwards(290);
stop(800);
forward(15);
stop(800);
tright(90);
stop(800);
backwards(110);
stop(800);
forward(205);
stop(800);
tright(80);
stop(800);
forward(290);
stop(800);
tright(65);
stop(800);

//enter room 2//
forward(120);
stop(800);
flame();
stop(800);
tleft(115);
stop(800);

//exit room 2 approach room 3//
backwards(150);
stop(800);
tleft(55);
stop(800);
backwards(360);
stop(800);
forward(25);
stop(800);
tright(85);
stop(800);
backwards(180);
stop(800);

//enter room 3//
forward(150);
stop(800);
tright(80);
stop(800);
forward(300);
stop(800);
flame();
stop(800);
tleft(115);
stop(800);

//exit room 3 and approach room 4//
backwards(450);
stop(800);
forward(50);
stop(800);
tleft(55);
stop(800);
forward(100);
stop(800);
tright(85);
stop(800);
forward(200);
stop(800);
tleft(75);
stop(800);

//enter room 4//
forward(150);
stop(800);
flame();
tleft(145);
stop(100);

}

}

void clearEncoders()
{
SensorValue[leftEncoder] = 0;
SensorValue[rightEncoder] = 0; //function for encoders to reset their count; therefore, to ensure that encoders are accurate at keeping consistent movements.
}

void forward(int x)
{
clearEncoders();
while(SensorValue[leftEncoder] < x && SensorValue[rightEncoder] < x) //function ensures that both encoders are working
{
motor[leftMotor] = 65;
motor[rightMotor] = 60;
}
}
void tleft(int x)
{
clearEncoders();
while(SensorValue[leftEncoder] < x && SensorValue[rightEncoder] < x)
{
motor[leftMotor] = -50;
motor[rightMotor] = 50;
}
}

void tright(int x)
{
clearEncoders();
while(SensorValue[leftEncoder] < x && SensorValue[rightEncoder] < x)
{
motor[leftMotor] = 50;
motor[rightMotor] = -40;
}
}

void backwards(int x)
{
clearEncoders();
while(SensorValue[leftEncoder] < x && SensorValue[rightEncoder] < x)
{
motor[leftMotor] = -60;
motor[rightMotor] = -60;
}
}

void stop(int x)
{
clearEncoders();
{
motor[leftMotor] = 0;
motor[rightMotor] = 0;
wait1Msec(x);
}
}

void flame() ******
{
int count=0;
while(SensorValue[frontIRSensor]==0 && count<30)//was this while function makes the IR sensor search for a flame
{
tright(5); // turns right 30 times at (5) power or in other words it is a tright(150); command if there is no IR value greater than one
stop(5);
count++;
}
if(SensorValue[frontIRSensor]>1)//loop until sonar finds an object <20 inches. // when the IR sensor detects a flame it should register a value greater than one.
{
while(SensorValue[frontIRSensor]<7) // The while function will not end until the IR sensor registers a value less than 7
{
forward(5); // keep going forward near the flame
}
stop(200);
SensorValue[fan]=true;
wait10Msec(1000);
SensorValue[fan]=false; // after the while statement above is fulfilled and the squarebot is close enough to the flame it will turn on the fan
wait10Msec(500000000);

}
}

Here is the video of this code in action with our sqaurebot

Day 13 - Ultra Sonic sensors on VEX squarebot

*The Lab today consisted of designing a squarebot that could navigate autonomously using functions and avoid walls forever or approach a can. The setup for this lab utilized encoders to consistently have the same movements; in addition, there were sonar sensors attached to the bot so it could "see" the walls and can to avoid or approach the items.

Autonomous robot that avoids the walls

Here is the code

#pragma config(Sensor, in2, rightEncoder, sensorRotation)

#pragma config(Sensor, in3, leftEncoder, sensorRotation)

#pragma config(Sensor, in9, sonarSensor, sensorSONAR, int1)

#pragma config(Motor, port2, rightMotor, tmotorServoContinuousRotation, openLoop, reversed)

#pragma config(Motor, port3, leftMotor, tmotorServoContinuousRotation, openLoop)

void clearEncoders();

void forward(int x);

void tleft(int x);

void tright(int x);

void backwards(int x);

void stop(int x);

task main()

{ wait1Msec(2000);

bMotorReflected[port2]=1;

while(1)

{

if (SensorValue[sonarSensor]>3 ||SensorValue[sonarSensor]==-1)//loop until sonar finds an object less than 3 inches.

{

forward(20);//go forward

}

else

{

backwards(20);

stop(1);

tleft(70);

}

void clearEncoders() //must clear encoders every time so that way their measurements are accurate

{

SensorValue[leftEncoder] = 0;

SensorValue[rightEncoder] = 0;

}

void forward(int x)

{

clearEncoders();

while(SensorValue[leftEncoder] < x && SensorValue[rightEncoder] <x) // read both the left && right encoders

{

motor[leftMotor] = 60;

motor[rightMotor] = 50;

}

void tleft(int x)

{

clearEncoders();

while(SensorValue[leftEncoder] < x && SensorValue[rightEncoder] <x)

{

motor[leftMotor] = -40;

motor[rightMotor] = 40;

}

void tright(int x)

{

clearEncoders();

while(SensorValue[leftEncoder] < x && SensorValue[rightEncoder] <x)

{

motor[leftMotor] = 60;

motor[rightMotor] = -40;

}

void backwards(int x)

{

clearEncoders();

while(SensorValue[leftEncoder] < x && SensorValue[rightEncoder] <x)

{

motor[leftMotor] = -40;

motor[rightMotor] = -40;

}

void stop(int x)

{

clearEncoders();

while(SensorValue[leftEncoder] < x && SensorValue[rightEncoder] <x)

{

motor[leftMotor] = 0;

motor[rightMotor] = 0;

}

Picture of avoiding walls

Today we assembled and programmed the squarebot to drive through a maze. We used commands to tell the robot where to go during the maze. This code is not autonomous because it is not dependent on any sensors.

Here is the code for our sqaure bot

/*************************************************************************

VEX - Point Turns

Description: This program instructs your robot turn right for .75 seconds

and then turn left for .75 seconds. There is a two second pause at the

beginning of the program.

Configuration: This program is written to work with the Squarebot model.

Right Motor - port2

Left Motor - port3

Additional Notes:

- The "bMotorReflected[port2] = 1;" is needed with the Squarebot model,

but may not be needed for all robot configurations.

- Point Turns, or turns in place, are achieved by having the motors spin

in opposite directions.

*************************************************************************/

void stop(int x);

task main()

{

wait1Msec(3000); //Robot waits for 2000 milliseconds before executing program

bMotorReflected[port2] = 1; //Reflects the direction of the motor on port2

motor[port2] = 70; //Motor forward 1

motor[port3] = 70; //Motor on port3 is run at full (127) power forward

wait1Msec(3000);

stop(500);

//Turn LEFT

motor[port2] = 78; //Motor on port2 is run at full (-127) power reverse 68

motor[port3] = -83; //Motor on port3 is run at full (127) power forward

wait1Msec(400);//Robot runs previous code for 750 milliseconds before moving on

stop(500);

motor[port2] = 95; //FORWARD 2

motor[port3] = 95; //Motor on port3 is run at full (127) power forward

wait1Msec(1000);

stop(500);

motor[port2] = 130; //Turn 2nd LEFT

motor[port3] = -100; //Motor on port3 is run at full (127) power forward

wait1Msec(300);

stop(500);

motor[port2] = 85; //Forward 3

motor[port3] = 85; //Motor on port3 is run at full (127) power forward

wait1Msec(1700);

stop(500);

motor[port2] = -70; //Turn RIGHT

motor[port3] = 70; //Motor on port3 is run at full (127) power forward 68-70

wait1Msec(500);

stop(500);

motor[port2] = 60; //Foward 4

motor[port3] = 60; //Motor on port3 is run at full (127) power forward

wait1Msec(1000);

stop(500);

motor[port2] = -88; //Turn RIGHT

motor[port3] = 88; //Motor on port3 is run at full (127) power forward

wait1Msec(400);

stop(500);

motor[port2] = 80; //Final Forwa

motor[port3] = 80; //Motor on port3 is run at full (127) power forward

wait1Msec(2000);

} //Program ends, and the robot stops

void stop(int x)

{

motor[port2] = 0;

motor[port3] = 0;

wait1Msec(x);

}

In addition here is a video that shows our square bot in action

Day 10 - Hack a toy

The objective of the Hack-a-Toy project was to buy an old toy and dismantle it then re configure it and program it to do similar functions with the arduino.

Here is the toy before it was was dismantled. It is the bunny on the left.
The first step to hacking the toy was to take it apart. Here is a descriptive video that shows the toy's electronic components after it was taken apart. An interesting part about the toy's anatomy is that it is that the system used transistors, motors, resistors, speakers, and other components.

The plan to reconfigure the toy involved making the toy so that the temperature of a human body could trigger the motor of the bunny.

Here is a picture of how, mechanically, this was achieved.

For this lab we used the arduino, along with IR Detector and Ultrasonic Sensors to view heat and distance values using the Arduino.

Here is the code for the IR sensor portion of the lab.

#define sensorPin A0 // select the input pin (pin2)
int sensorValue = 0; // variable to store the value coming from the sensor

void setup() {
Serial.begin(9600);//9600
}
void loop() {
sensorValue = analogRead(sensorPin); // read the value fromt he sensor:
Serial.println(sensorValue);
delay(300);
// while (Serial.available()){
// int inChar = Serial.read();
// Serial.print(inChar);
// delay(300);
//}
}

Picture of IR Sensor in action

Code for Sonar Sensor.

const int trigPin = 2;
const int echoPin = 4;

void setup() {
// initialize serial communication:
Serial.begin(9600);
}

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

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

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

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

Serial.print(inches);
Serial.print("in, ");
Serial.print(cm);
Serial.print("cm");
Serial.println();

delay(100);
}

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

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

Video for Sonar Sensor

Day 6 - Intro to Sensors and Microcontroller inputs and outputs

Microcontrollers, input and outputs

Demonstrate Push button LED using if/else statement

Here is how it was built in the video and what the end result was.

In addition here is the code that helped achieve this

#define buttonPin 8 //# of pushbutton pin

#define ledPin 6 //# of LED pin

int buttonState = 0; //variable for reading the pushbutton status

void setup() {

pinMode(ledPin, OUTPUT); //initialize the LED pin as output:

pinMode(buttonPin, INPUT); //initialize push button as input:

}

void loop() {

buttonState = digitalRead(buttonPin); //read the state of the pushbutton value:

// check if push buton is pressed. If it is, the buttonState is HIGH:

if (buttonState == HIGH) {

digitalWrite(ledPin, HIGH); // turn LED on:

}

else {

digitalWrite(ledPin, LOW); // turn LED off

}

Driving Motors and Other Output Devices

Demonstrate microcontroller controlling signal lamp

Here is the picture of the contraption In addition here is the code that allowed the microcontroller to control the signal lamp.

void setup() {

pinMode(9, OUTPUT); //Initialize Digital Pin 9 as an output

}

void loop() {

digitalWrite(9, HIGH); // turn the LED on (HIGH is the voltage level)

delay(5000); // wait for a second

digitalWrite(9, LOW); // turn the LED off by making the voltage LOW

delay(3000); // wait for a second

}

2. Demonstrate Darlington controlling signal lamp

3. Demonstrate microcontroller controlling motor

void setup() {

pinMode(9, OUTPUT); //Initialize Digital Pin 9 as an output

}

void loop() {

digitalWrite(9, HIGH); // turn the motor on (HIGH is the voltage level)

delay(5000); // wait for a second

digitalWrite(9, LOW); // turn the motor off by making the voltage LOW

delay(3000); // wait for a second

}

4. Demonstrate PWM signal driving motor

#define motorPin 9 //Motor connected to dig. pin 9

void setup() {

// nothing happens in set up

}

void loop() {

analogWrite (motorPin, 90);//set motor to 20%

delay (1000);

analogWrite (motorPin, 50);//set motor to 90%

delay (1000);

}

Bi-directional Motor Control

This first video demonstrates DPDT relay controlled the motor in both directions.
In addition, this next picture and video shows a motor being controlled in opposing directions because of the arduino programming.Here is the code for this achievement
void setup() {

pinMode (13, OUTPUT) ; //Initialize Digital Pin 13 as an output

    pinMode (12, OUTPUT) ; //Initialize Digital Pin 12 as an output

}

void loop () {

digitalWrite (13,HIGH) ; //Set the motor On ClockWise

delay (100);           //Wait for 1000 ms (1 Second)

digitalWrite(13,LOW); //Set the LED off

delay (1000);   //Wait for 1 second

digitalWrite (12,HIGH) ; //Set the motor On CounterClockWise

delay (100);           //Wait for 1000 ms (1 Second)

digitalWrite(12,LOW); //Set the LED off

delay (1000);   //Wait for 1 second

}

Sunday, January 31, 2016

Day 4 - Intro to Transistors and Arduino

This lab explored how transistors work and required us to assemble several systems with transistors and programmed by the Arduino

A transistor is very similar to a relay. There are three pins in a transistor and the pins serve as a collector (where positive electricity flows), base(where electricity may travel to), and emitter (where ground electricity flows). This photo is a visual representation of how electricity flows in both types of transistors PNP and NPN.
We utilized the capabilities through this assembly.
Next, we removed the push button and used a human finger as a conductor for the electricity to pass through. It may difficult to tell from the video but when the finger is wet the light shone brighter.
For this next part we used a potentiometer and a variable screw resistor to change the current flowing through the transistors. In this picture A1 is on the right side and A2 is on the left side.. Similarly, in this picture A1 is on the right side and A2 is on the left side.
We started at a low current and slowly increased the amount of current that could pass into the transistor. The relationship that was discovered was that the more low the milli amps that were permitted to travel through A1 the higher the gain was measured. Keep in mind that gain = (A2 current) /(A1 current).

Introduction to Microcontrollers

Here is the LED flashing band. For the next part we designed and powered 4 led lights and cycled them continuously.

video

code

void setup() {

pinMode (13, OUTPUT) ; //Initialize Digital Pin 13 as an output

pinMode (12, OUTPUT) ; //Initialize Digital Pin 12 as an output

pinMode (7, OUTPUT) ; //Initialize Digital Pin 7 as an output

pinMode (3, OUTPUT) ; //Initialize Digital Pin 3 as an output

}

void loop () {

digitalWrite (13,HIGH) ; //Set the LED On

delay (100); //Wait for 1000 ms (1 Second)

digitalWrite(13,LOW); //Set the LED off