The project this time around was especially challenging since it did not directly add on to previous builds. Google was especially helpful; I found a great resource for building the dice simulator on the Instructables website. After carefully assembling the circuit (with tweezers because of the small connectors on the resistors), I carefully re-typed the code to load to the Arduino board. I definitely have more appreciation for the coders that came up with this program after typing it line by line; especially with my affinity for transposing numbers. Picture of the Arduino Circuit
Arduino Schematics Circuit with the Switch
Circuit without the Switch
Dice Code int pinLeds1 = 10; int pinLeds2 = 9; int pinLeds3 = 7; int pinLed4 = 8; int buttonPin = 6; int buttonState; long ran; int time = 2000; void setup () { pinMode (pinLeds1, OUTPUT); pinMode (pinLeds2, OUTPUT); pinMode (pinLeds3, OUTPUT); pinMode (pinLed4, OUTPUT); pinMode (buttonPin, INPUT); randomSeed(analogRead(0)); } void loop() { buttonState = digitalRead(buttonPin); if (buttonState == HIGH){ ran = random(1, 7); if (ran == 1){ digitalWrite (pinLed4, HIGH); delay (time); } if (ran == 2){ digitalWrite (pinLeds1, HIGH); delay (time); } if (ran == 3){ digitalWrite (pinLeds3, HIGH); digitalWrite (pinLed4, HIGH); delay (time); } if (ran == 4){ digitalWrite (pinLeds1, HIGH); digitalWrite (pinLeds3, HIGH); delay (time); } if (ran == 5){ digitalWrite (pinLeds1, HIGH); digitalWrite (pinLeds3, HIGH); digitalWrite (pinLed4, HIGH); delay (time); } if (ran == 6){ digitalWrite (pinLeds1, HIGH); digitalWrite (pinLeds2, HIGH); digitalWrite (pinLeds3, HIGH); delay (time); } } digitalWrite (pinLeds1, LOW); digitalWrite (pinLeds2, LOW); digitalWrite (pinLeds3, LOW); digitalWrite (pinLed4, LOW);
} Videos Circuit with the Switch
Circuit without the Switch
Roll Distributions
You can see that the distribution is nearly normal; my guess is that the outcome of 4 would be on par with the 3 and the 5 if we were to do several more rolls. Commentary The complexities of each circuit have definitely increased from week to week. I have even more appreciation for those EE's that have impacted our life with the electronic tools that we use and love. Even something as simple as a Dice simulator took some considerable effort; I can only imagine the time and the manpower required to produce a smartphone! A good extension to this project would be to envision the programming and circuitry involved in a gaming machine (such as a slot machine) at a casino. Electronic slot machines or other gaming machines have more circuits than I can imagine with thousands upon thousands of lines of code. I would like to be able to peer inside of something a little more complex than our Dice simulator one day; perhaps a combination of multiple "Dice" banks would be a better simulation of these games of chance.
Time management was an issue this past week with upcoming PDAS observations and a sick wife. It seems that time diminishes as the semester progresses. My hope is that this next week lends to having a little more time to play around with the Arduino. Circuit 1 The first circuit involved adding the tri-color LED into a simple circuit. The circuit consisted of the Arduino controller connected to the LED via the breadboard with a 330-ohm resistor in the middle. The circuit was fairly simple to build but one of the problems that I discovered was that I had one of my digital outputs in the wrong place (I had the wire running to digital output 8 instead of digital output 11.) This shorted my program because it did not pass all of the way through the Red-Green-Blue color range. The lack of red can be seen in the video below. Circuit 1 Code /*
Example sketch 03
RGB LED
Make an RGB LED display a rainbow of colors!
Hardware connections:
An RGB LED is actually three LEDs (red, green, and blue) in one package. When you run them at different brightnesses, the red, green and blue mix to form new colors.
Starting at the flattened edge of the flange on the LED, the pins are ordered RED, COMMON, GREEN, BLUE.
Connect RED to a 330 Ohm resistor. Connect the other end of the resistor to Arduino digital pin 9.
Connect COMMON pin to GND.
Connect GREEN to a 330 Ohm resistor. Connect the other end of the resistor to Arduino digital pin 10.
Connect BLUE to a 330 Ohm resistor. Connect the other end of the resistor to Arduino digital pin 11.
This sketch was written by SparkFun Electronics, with lots of help from the Arduino community. Visit http://www.arduino.cc to learn about the Arduino.
Version 2.0 6/2012 MDG */
// First we'll define the pins by name to make the sketch // easier to follow.
// Here's a new trick: putting the word "const" in front of a // variable indicates that this is a "constant" value that will // never change. (You don't have to do this, but if you do, the // Arduino will give you a friendly warning if you accidentally // try to change the value, so it's considered good form.)
const int RED_PIN = 9; const int GREEN_PIN = 10; const int BLUE_PIN = 11;
// This variable controls how fast we loop through the colors. // (Try changing this to make the fading faster or slower.)
int DISPLAY_TIME = 100; // In milliseconds
void setup() { // Here we'll configure the Arduino pins we're using to // drive the LED to be outputs:
void loop() { // In this sketch, we'll start writing our own functions. // This makes the sketch easier to follow by dividing up // the sketch into sections, and not having everything in // setup() or loop().
// We'll show you two ways to run the RGB LED.
// The first way is to turn the individual LEDs (red, blue, // and green) on and off in various combinations. This gives you // a total of eight colors (if you count "black" as a color).
// We've written a function called mainColors() that steps // through all eight of these colors. We're only "calling" the // function here (telling it to run). The actual function code // is further down in the sketch.
mainColors();
// The above function turns the individual LEDs full-on and // full-off. If you want to generate more than eight colors, // you can do so by varying the brightness of the individual // LEDs between full-on and full-off.
// The analogWrite() function lets us do this. This function // lets you dim a LED from full-off to full-on over 255 steps.
// We've written a function called showSpectrum() that smoothly // steps through all the colors. Again we're just calling it // here; the actual code is further down in this sketch.
showSpectrum(); }
// Here's the mainColors() function we've written.
// This function displays the eight "main" colors that the RGB LED // can produce. If you'd like to use one of these colors in your // own sketch, you cancopy and paste that section into your code.
// Below are two more functions we've written, // showSpectrum() and showRGB().
// showRGB() displays a single color on the RGB LED. // You call showRGB() with the number of a color you want // to display.
// showSpectrum() steps through all the colors of the RGB LED, // displaying a rainbow. showSpectrum() actually calls showRGB() // over and over to do this.
// We'll often break tasks down into individual functions like // this, which makes your sketches easier to follow, and once // you have a handy function, you can reuse it in your other // programs.
// showSpectrum()
// This function steps through all the colors of the RGB LED. // It does this by stepping a variable from 0 to 768 (the total // number of colors), and repeatedly calling showRGB() to display // the individual colors.
// In this function, we're using a "for() loop" to step a variable // from one value to another, and perform a set of instructions // for each step. For() loops are a very handy way to get numbers // to count up or down.
// Every for() loop has three statements separated by semicolons:
// 1. Something to do before starting
// 2. A test to perform; as long as it's true, // it will keep looping
// 3. Something to do after each loop (usually // increase a variable)
// For the for() loop below, these are the three statements:
// 1. x = 0; Before starting, make x = 0.
// 2. x < 768; While x is less than 768, run the // following code.
// 3. x++ Putting "++" after a variable means // "add one to it". (You can also use "x = x + 1")
// Every time you go through the loop, the statements following // the loop (those within the brackets) will run.
// And when the test in statement 2 is finally false, the sketch // will continue.
void showSpectrum() { int x; // define an integer variable called "x"
// Now we'll use a for() loop to make x count from 0 to 767 // (Note that there's no semicolon after this line! // That's because the for() loop will repeat the next // "statement", which in this case is everything within // the following brackets {} )
for (x = 0; x < 768; x++)
// Each time we loop (with a new value of x), do the following:
{ showRGB(x); // Call RGBspectrum() with our new x delay(10); // Delay for 10 ms (1/100th of a second) } }
// showRGB()
// This function translates a number between 0 and 767 into a // specific color on the RGB LED. If you have this number count // through the whole range (0 to 767), the LED will smoothly // change color through the entire spectrum.
// The "base" numbers are: // 0 = pure red // 255 = pure green // 511 = pure blue // 767 = pure red (again)
// Numbers between the above colors will create blends. For // example, 640 is midway between 512 (pure blue) and 767 // (pure red). It will give you a 50/50 mix of blue and red, // resulting in purple.
// If you count up from 0 to 767 and pass that number to this // function, the LED will smoothly fade between all the colors. // (Because it starts and ends on pure red, you can start over // at 0 without any break in the spectrum).
void showRGB(int color) { int redIntensity; int greenIntensity; int blueIntensity;
// Here we'll use an "if / else" statement to determine which // of the three (R,G,B) zones x falls into. Each of these zones // spans 255 because analogWrite() wants a number from 0 to 255.
// In each of these zones, we'll calculate the brightness // for each of the red, green, and blue LEDs within the RGB LED.
if (color <= 255) // zone 1 { redIntensity = 255 - color; // red goes from on to off greenIntensity = color; // green goes from off to on blueIntensity = 0; // blue is always off } else if (color <= 511) // zone 2 { redIntensity = 0; // red is always off greenIntensity = 255 - (color - 256); // green on to off blueIntensity = (color - 256); // blue off to on } else // color >= 512 // zone 3 { redIntensity = (color - 512); // red off to on greenIntensity = 0; // green is always off blueIntensity = 255 - (color - 512); // blue on to off }
// Now that the brightness values have been set, command the LED // to those values
analogWrite(RED_PIN, redIntensity); analogWrite(BLUE_PIN, blueIntensity); analogWrite(GREEN_PIN, greenIntensity); } Circuit 1 Video
Circuit 2 In circuit 2, I tried to connect the potentiometer to the circuit to change the flash rate of the tri-color LED. I was not able to have success with this circuit; the potentiometer seemed loose in the breadboard and may not have made complete contact. I was not able to spend a lot of time troubleshooting the circuit; this project is one that is on the backburner to come back to at some point. Circuit 2 Code /*
Example sketch 03
RGB LED
Make an RGB LED display a rainbow of colors!
Hardware connections:
An RGB LED is actually three LEDs (red, green, and blue) in one package. When you run them at different brightnesses, the red, green and blue mix to form new colors.
Starting at the flattened edge of the flange on the LED, the pins are ordered RED, COMMON, GREEN, BLUE.
Connect RED to a 330 Ohm resistor. Connect the other end of the resistor to Arduino digital pin 9.
Connect COMMON pin to GND.
Connect GREEN to a 330 Ohm resistor. Connect the other end of the resistor to Arduino digital pin 10.
Connect BLUE to a 330 Ohm resistor. Connect the other end of the resistor to Arduino digital pin 11.
This sketch was written by SparkFun Electronics, with lots of help from the Arduino community. Visit http://www.arduino.cc to learn about the Arduino.
Version 2.0 6/2012 MDG */
// First we'll define the pins by name to make the sketch // easier to follow.
// Here's a new trick: putting the word "const" in front of a // variable indicates that this is a "constant" value that will // never change. (You don't have to do this, but if you do, the // Arduino will give you a friendly warning if you accidentally // try to change the value, so it's considered good form.)
const int sensorPin = 0; const int RED_PIN = 9; const int GREEN_PIN = 10; const int BLUE_PIN = 11;
// This variable controls how fast we loop through the colors. // (Try changing this to make the fading faster or slower.)
int DISPLAY_TIME = 100; // In milliseconds
void setup() { // Here we'll configure the Arduino pins we're using to // drive the LED to be outputs:
void loop() { // In this sketch, we'll start writing our own functions. // This makes the sketch easier to follow by dividing up // the sketch into sections, and not having everything in // setup() or loop().
// We'll show you two ways to run the RGB LED.
// The first way is to turn the individual LEDs (red, blue, // and green) on and off in various combinations. This gives you // a total of eight colors (if you count "black" as a color).
// We've written a function called mainColors() that steps // through all eight of these colors. We're only "calling" the // function here (telling it to run). The actual function code // is further down in the sketch.
mainColors();
// The above function turns the individual LEDs full-on and // full-off. If you want to generate more than eight colors, // you can do so by varying the brightness of the individual // LEDs between full-on and full-off.
// The analogWrite() function lets us do this. This function // lets you dim a LED from full-off to full-on over 255 steps.
// We've written a function called showSpectrum() that smoothly // steps through all the colors. Again we're just calling it // here; the actual code is further down in this sketch.
showSpectrum(); }
// Here's the mainColors() function we've written.
// This function displays the eight "main" colors that the RGB LED // can produce. If you'd like to use one of these colors in your // own sketch, you cancopy and paste that section into your code.
// Below are two more functions we've written, // showSpectrum() and showRGB().
// showRGB() displays a single color on the RGB LED. // You call showRGB() with the number of a color you want // to display.
// showSpectrum() steps through all the colors of the RGB LED, // displaying a rainbow. showSpectrum() actually calls showRGB() // over and over to do this.
// We'll often break tasks down into individual functions like // this, which makes your sketches easier to follow, and once // you have a handy function, you can reuse it in your other // programs.
// showSpectrum()
// This function steps through all the colors of the RGB LED. // It does this by stepping a variable from 0 to 768 (the total // number of colors), and repeatedly calling showRGB() to display // the individual colors.
// In this function, we're using a "for() loop" to step a variable // from one value to another, and perform a set of instructions // for each step. For() loops are a very handy way to get numbers // to count up or down.
// Every for() loop has three statements separated by semicolons:
// 1. Something to do before starting
// 2. A test to perform; as long as it's true, // it will keep looping
// 3. Something to do after each loop (usually // increase a variable)
// For the for() loop below, these are the three statements:
// 1. x = 0; Before starting, make x = 0.
// 2. x < 768; While x is less than 768, run the // following code.
// 3. x++ Putting "++" after a variable means // "add one to it". (You can also use "x = x + 1")
// Every time you go through the loop, the statements following // the loop (those within the brackets) will run.
// And when the test in statement 2 is finally false, the sketch // will continue.
void showSpectrum() { int x; // define an integer variable called "x"
// Now we'll use a for() loop to make x count from 0 to 767 // (Note that there's no semicolon after this line! // That's because the for() loop will repeat the next // "statement", which in this case is everything within // the following brackets {} )
for (x = 0; x < 768; x++)
// Each time we loop (with a new value of x), do the following:
{ showRGB(x); // Call RGBspectrum() with our new x delay(10); // Delay for 10 ms (1/100th of a second) } }
// showRGB()
// This function translates a number between 0 and 767 into a // specific color on the RGB LED. If you have this number count // through the whole range (0 to 767), the LED will smoothly // change color through the entire spectrum.
// The "base" numbers are: // 0 = pure red // 255 = pure green // 511 = pure blue // 767 = pure red (again)
// Numbers between the above colors will create blends. For // example, 640 is midway between 512 (pure blue) and 767 // (pure red). It will give you a 50/50 mix of blue and red, // resulting in purple.
// If you count up from 0 to 767 and pass that number to this // function, the LED will smoothly fade between all the colors. // (Because it starts and ends on pure red, you can start over // at 0 without any break in the spectrum).
void showRGB(int color) { int sensorValue; sensorValue = analogRead(sensorPin); int redIntensity; int greenIntensity; int blueIntensity;
// Here we'll use an "if / else" statement to determine which // of the three (R,G,B) zones x falls into. Each of these zones // spans 255 because analogWrite() wants a number from 0 to 255.
// In each of these zones, we'll calculate the brightness // for each of the red, green, and blue LEDs within the RGB LED.
if (color <= 255) // zone 1 { redIntensity = 255 - sensorValue; // red goes from on to off greenIntensity = sensorValue; // green goes from off to on blueIntensity = 0; // blue is always off } else if (color <= 511) // zone 2 { redIntensity = 0; // red is always off greenIntensity = 255 - (sensorValue - 256); // green on to off blueIntensity = (sensorValue - 256); // blue off to on } else // color >= 512 // zone 3 { redIntensity = (sensorValue - 512); // red off to on greenIntensity = 0; // green is always off blueIntensity = 255 - (sensorValue - 512); // blue on to off }
// Now that the brightness values have been set, command the LED // to those values
Circuit 3 In circuit 3, I programmed the tri-color LED to remain flashing blue and added a red LED to the circuit. The two LEDs flashed in an alternate pattern that looked like the type of lights that one would see in a police car. I also changed up the timing to the LEDs flashed at a more rapid pace. Circuit 3 Code /*
Example sketch 03
RGB LED
Make an RGB LED display a rainbow of colors!
Hardware connections:
An RGB LED is actually three LEDs (red, green, and blue) in one package. When you run them at different brightnesses, the red, green and blue mix to form new colors.
Starting at the flattened edge of the flange on the LED, the pins are ordered RED, COMMON, GREEN, BLUE.
Connect RED to a 330 Ohm resistor. Connect the other end of the resistor to Arduino digital pin 9.
Connect COMMON pin to GND.
Connect GREEN to a 330 Ohm resistor. Connect the other end of the resistor to Arduino digital pin 10.
Connect BLUE to a 330 Ohm resistor. Connect the other end of the resistor to Arduino digital pin 11.
This sketch was written by SparkFun Electronics, with lots of help from the Arduino community. Visit http://www.arduino.cc to learn about the Arduino.
Version 2.0 6/2012 MDG */
// First we'll define the pins by name to make the sketch // easier to follow.
// Here's a new trick: putting the word "const" in front of a // variable indicates that this is a "constant" value that will // never change. (You don't have to do this, but if you do, the // Arduino will give you a friendly warning if you accidentally // try to change the value, so it's considered good form.)
const int RED_LED = 8; const int RED_PIN = 9; const int GREEN_PIN = 10; const int BLUE_PIN = 11;
// This variable controls how fast we loop through the colors. // (Try changing this to make the fading faster or slower.)
int DISPLAY_TIME = 100; // In milliseconds
void setup() { // Here we'll configure the Arduino pins we're using to // drive the LED to be outputs:
void loop() { // In this sketch, we'll start writing our own functions. // This makes the sketch easier to follow by dividing up // the sketch into sections, and not having everything in // setup() or loop().
// We'll show you two ways to run the RGB LED.
// The first way is to turn the individual LEDs (red, blue, // and green) on and off in various combinations. This gives you // a total of eight colors (if you count "black" as a color).
// We've written a function called mainColors() that steps // through all eight of these colors. We're only "calling" the // function here (telling it to run). The actual function code // is further down in the sketch.
mainColors();
digitalWrite(RED_LED, HIGH); // Turn on the LED
delay(100); // Wait for one second
digitalWrite(RED_LED, LOW); // Turn off the LED
delay(100); // Wait for one second
// The above function turns the individual LEDs full-on and // full-off. If you want to generate more than eight colors, // you can do so by varying the brightness of the individual // LEDs between full-on and full-off.
// The analogWrite() function lets us do this. This function // lets you dim a LED from full-off to full-on over 255 steps.
// We've written a function called showSpectrum() that smoothly // steps through all the colors. Again we're just calling it // here; the actual code is further down in this sketch.
//showSpectrum(); }
// Here's the mainColors() function we've written.
// This function displays the eight "main" colors that the RGB LED // can produce. If you'd like to use one of these colors in your // own sketch, you cancopy and paste that section into your code.
// Below are two more functions we've written, // showSpectrum() and showRGB().
// showRGB() displays a single color on the RGB LED. // You call showRGB() with the number of a color you want // to display.
// showSpectrum() steps through all the colors of the RGB LED, // displaying a rainbow. showSpectrum() actually calls showRGB() // over and over to do this.
// We'll often break tasks down into individual functions like // this, which makes your sketches easier to follow, and once // you have a handy function, you can reuse it in your other // programs.
// showSpectrum()
// This function steps through all the colors of the RGB LED. // It does this by stepping a variable from 0 to 768 (the total // number of colors), and repeatedly calling showRGB() to display // the individual colors.
// In this function, we're using a "for() loop" to step a variable // from one value to another, and perform a set of instructions // for each step. For() loops are a very handy way to get numbers // to count up or down.
// Every for() loop has three statements separated by semicolons:
// 1. Something to do before starting
// 2. A test to perform; as long as it's true, // it will keep looping
// 3. Something to do after each loop (usually // increase a variable)
// For the for() loop below, these are the three statements:
// 1. x = 0; Before starting, make x = 0.
// 2. x < 768; While x is less than 768, run the // following code.
// 3. x++ Putting "++" after a variable means // "add one to it". (You can also use "x = x + 1")
// Every time you go through the loop, the statements following // the loop (those within the brackets) will run.
// And when the test in statement 2 is finally false, the sketch // will continue.
void showSpectrum() { int x; // define an integer variable called "x"
// Now we'll use a for() loop to make x count from 0 to 767 // (Note that there's no semicolon after this line! // That's because the for() loop will repeat the next // "statement", which in this case is everything within // the following brackets {} )
for (x = 0; x < 768; x++)
// Each time we loop (with a new value of x), do the following:
{ showRGB(x); // Call RGBspectrum() with our new x delay(10); // Delay for 10 ms (1/100th of a second) } }
// showRGB()
// This function translates a number between 0 and 767 into a // specific color on the RGB LED. If you have this number count // through the whole range (0 to 767), the LED will smoothly // change color through the entire spectrum.
// The "base" numbers are: // 0 = pure red // 255 = pure green // 511 = pure blue // 767 = pure red (again)
// Numbers between the above colors will create blends. For // example, 640 is midway between 512 (pure blue) and 767 // (pure red). It will give you a 50/50 mix of blue and red, // resulting in purple.
// If you count up from 0 to 767 and pass that number to this // function, the LED will smoothly fade between all the colors. // (Because it starts and ends on pure red, you can start over // at 0 without any break in the spectrum).
void showRGB(int color) { int redIntensity; int greenIntensity; int blueIntensity;
// Here we'll use an "if / else" statement to determine which // of the three (R,G,B) zones x falls into. Each of these zones // spans 255 because analogWrite() wants a number from 0 to 255.
// In each of these zones, we'll calculate the brightness // for each of the red, green, and blue LEDs within the RGB LED.
if (color <= 255) // zone 1 { redIntensity = 255 - color; // red goes from on to off greenIntensity = color; // green goes from off to on blueIntensity = 0; // blue is always off } else if (color <= 511) // zone 2 { redIntensity = 0; // red is always off greenIntensity = 255 - (color - 256); // green on to off blueIntensity = (color - 256); // blue off to on } else // color >= 512 // zone 3 { redIntensity = (color - 512); // red off to on greenIntensity = 0; // green is always off blueIntensity = 255 - (color - 512); // blue on to off }
// Now that the brightness values have been set, command the LED // to those values
Circuit 4 In circuit 4, added a series of yellow LEDs to the "police car" circuit. The most difficult part of building this circuit was making sure the LED's were wired in series and making a complete path to the power source and the Arduino board.
Circuit 4 Code Circuit 4 Code did not differ from that of Circuit 4; the yellow LEDs were wired to the output of the Red LED.
Circuit 4 Video
The circuits that were constructed this week were a step above the previous circuits. I enjoyed being able to piece together the previous circuits that we built to come up with a unique circuit that encompasses previous knowledge. This is the essence of making - building on prior knowledge to create a design or project to impact others.
I did not experience as much "technical difficulty" in the setup of my circuit but I did have a more challenging week as far as getting all of the components to work together properly. Once I diverged from the instructions in the book and branching out on my own with the code, I discovered that one must be thorough when working with variables. In one instance, I changed a variable value in the global headers but I did not bother to change anything else in the implementation (when working with switching analog/digital inputs.) After a few trial runs, I discovered the error of my ways, though, and made the proper corrections. Circuit 1 Code: Default Code for 1 Blinking LED with Potentiometer Control int sensorPin = 0; // The potentiometer is connected to // analog pin 0 int ledPin = 13; // The LED is connected to digital pin 13 void setup() // this function runs once when the sketch starts up { pinMode(ledPin, OUTPUT); } void loop() // this function runs repeatedly after setup() finishes { int sensorValue; sensorValue = analogRead(sensorPin); digitalWrite(ledPin, HIGH); // Turn the LED on delay(sensorValue); // Pause for sensorValue digitalWrite(ledPin, LOW); // Turn the LED off delay(sensorValue); // Pause for sensorValue
}
Circuit 1 Schematic:
Circuit 1 Video:
My apologies for the lack of voice editing. The hoarseness of my voice after being overly enthusiastic at a sporting event this week would not have worked very well for narration. Please see the text comments for my videos. In this video, I demonstrate the blinking LED that is controlled by the potentiometer in the circuit. The blinking ranged from very slow to so fast that my eyes (and the camera from my phone) could not pick up the blinks. in the video, I turned the potentiometer back from the max so the camera could pick up the blinking. Circuit 2 Code: Code for 2 Blinking LEDs with Potentiometer Control int sensorPin = 0; // The potentiometer is connected to // analog pin 0 int ledPin = 13; // The LED is connected to digital pin 13 void setup() // this function runs once when the sketch starts up { pinMode(ledPin, OUTPUT); } void loop() // this function runs repeatedly after setup() finishes { int sensorValue; sensorValue = analogRead(sensorPin); digitalWrite(ledPin, HIGH); // Turn the LED on delay(sensorValue); // Pause for sensorValue digitalWrite(ledPin, LOW); // Turn the LED off delay(sensorValue); // Pause for sensorValue
} Circuit 2 Schematic:
Circuit 2 Photo:
Circuit 2 Video:
For the second circuit, I was able to add an LED to have them both blink in tandem. I added the second LED in series with the first LED so I did not need to add another resistor to the circuit. I also added a third LED in the same fashion but was not able to upload the video. Circuit 3 Code: Code for 2 Blinking LEDs with Digital Potentiometer Control int sensorPin = 7; // The potentiometer is connected to // digital pin 7 int ledPin = 13; // The LED is connected to digital pin 13 void setup() // this function runs once when the sketch starts up { pinMode(ledPin, OUTPUT); } void loop() // this function runs repeatedly after setup() finishes { int sensorValue; sensorValue = digitalRead(sensorPin); digitalWrite(ledPin, HIGH); // Turn the LED on delay(sensorValue); // Pause for sensorValue digitalWrite(ledPin, LOW); // Turn the LED off delay(sensorValue); // Pause for sensorValue
} Circuit 3 Schematic
Circuit 3 Video
I was not successful in getting the potentiometer to control the blinking in this circuit. I am not sure if it was a code problem or if it was a problem in the way that I wired the circuit. I checked the Arduino reference site online and it appears that my implementation of digitalRead() is proper. I will keep experimenting with this circuit Reflection Although I was not able to make everything work this week, I felt like I was able to learn more than I knew previously about circuits. I had built circuits in the past (in physics classes) that involved potentiometers but had never seen what went on behind the scenes in the software. I can think of many uses for a potentiometer (including those mentioned in eCollege) but one of the most common uses I can think of is in a car windshield wiper (one that has the intermittent setting.) The timing of the wiper is adjusted by the potentiometer which translates to the timing interval between wipes being varied.
The first round of experimenting with this week's challenge was a "challenge" to say the least. After playing around with the Arduino board for a day or two, it was inadvertently dropped on the ground and cracked. Fortunately, Amazon came to the rescue and had another one on my door within three days. This week's project was to build a simple circuit consisting of one LED, one 330 ohm resistor, and the Arduino controller board. The project build went very smoothly and without a hitch. The code (seen below) was compiled and loaded to the Arduino controller and the output was captured in the following video.
// Circuit #1 Code
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
This example code is in the public domain.
*/
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;
// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
}
// the loop routine runs over and over again forever:
void loop() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
Video of Controller running Initial Code
In doing further exploration, I added an LED and resistor to the circuit and the code. The LED was
set (in the software) to blink 1s after the original LED shut off. This was done by adding the code
for the second LED inside the loop structure and keeping the same time interval. Here is the code
for the second circuit:
// Circuit #1 Code with Second LED
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
This example code is in the public domain.
*/
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led1 = 13;
int led2 = 12;
// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pin as an output.
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
}
// the loop routine runs over and over again forever:
void loop() {
digitalWrite(led1, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led1, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
digitalWrite(led2, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led2, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
Video of Controller with Secondary LED
For the third circuit, I kept the same physical setup but changed the order of execution
in the code. Although the two LEDs were still blinking, the timing was set differently.
// Circuit #1 Code with Second LED changed flashing
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
This example code is in the public domain.
*/
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led1 = 13;
int led2 = 12;
// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pin as an output.
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
}
// the loop routine runs over and over again forever:
void loop() {
digitalWrite(led1, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led2, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led1, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
digitalWrite(led2, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
Video of Controller with Secondary LED and changed timing
I initially thought that the projects would be very simplistic for someone that had previous
programming experience. I actually found value in these exercises, though, because of the
complexity of implementing hardware with software. It was fun seeing more than simple
program output change when code is updated. One extension that I would like to make is
creating a traffic light (once I obtain a green LED.)
