KevinMidboe/Arduino
1
0
Fork 0
mirror of https://github.com/KevinMidboe/Arduino.git synced 2026-04-24 15:54:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

Init commit with many years of arduino sketches and projects. I dont know if the esp8266 includes much, but there are also libraries. I hope they dont have crazy automatic versioning through the Arduino IDE.

Browse Source
This commit is contained in:
Kevin
2019-05-30 23:41:53 +02:00
parent 2d047634f2
commit 6c84b31f2c
1480 changed files with 198581 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

477
Projects/7 Segment Main/The_Final_Coutdown_/The_Final_Coutdown_.ino Executable file
View File

@@ -0,0 +1,477 @@
/* ---------------------------------------------------------
* | Arduino Experimentation Kit Example Code |
* | CIRC-05 .: 8 More LEDs :. (74HC595 Shift Register) |
* ---------------------------------------------------------
*
* We have already controlled 8 LEDs however this does it in a slightly
* different manner. Rather than using 8 pins we will use just three
* and an additional chip.
*
*
*/
//Pin Definitions
//Pin Definitions
//The 74HC595 uses a serial communication
//link which has three pins
int data = 11;
int clock = 13;
int latch = 12;
//Used for single LED manipulation
int ledState = 0;
const int ON = HIGH;
const int OFF = LOW;
int ledDigitalOne[] = {10, 9, 8, 7, 6, 5, 4}; //the three digital pins of the digital LED
//9 = redPin, 10 = greenPin, 11 = bluePin
//Predefined Colors
const boolean One[] = {ON, OFF, OFF, OFF, OFF, OFF, ON};
const boolean Two[] = {OFF, ON, ON, ON, OFF, ON, ON};
const boolean Three[] = {ON, ON, OFF, ON, OFF, ON, ON};
const boolean Four[] = {ON, OFF, OFF, ON, ON, OFF, ON};
const boolean Five[] = {ON, ON, OFF, ON, ON, ON, OFF};
const boolean Six[] = {ON, ON, ON, ON, ON, ON, OFF};
const boolean Seven[] = {ON, OFF, OFF, OFF, OFF, ON, ON};
const boolean Eight[] = {ON, ON, ON, ON, ON, ON, ON};
const boolean Nine[] = {ON, ON, OFF, ON, ON, ON, ON};
const boolean Zero[] = {ON, ON, ON, OFF, ON, ON, ON};
//An Array that stores the predefined colors (allows us to later randomly display a color)
const boolean* NUMBERS[] = {One, Two, Three, Four, Five, Six, Seven, Eight, Nine, Zero};
void setup()
{
pinMode(data, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(latch, OUTPUT);
for(int i = 0; i < 9; i++)
{
pinMode(ledDigitalOne[i], OUTPUT); //Set the three LED pins as outputs
}
}
void loop()
{
int delayTime = 500;
for (int i = 0; i < 5; i++)
{
changeLED(0,ON); // - 9
changeLED(1,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Nine);
delay(1000);
setNumber(ledDigitalOne, Eight);
delay(1000);
setNumber(ledDigitalOne, Seven);
delay(1000);
setNumber(ledDigitalOne, Six);
delay(1000);
setNumber(ledDigitalOne, Five);
delay(1000);
setNumber(ledDigitalOne, Four);
delay(1000);
setNumber(ledDigitalOne, Three);
delay(1000);
setNumber(ledDigitalOne, Two);
delay(1000);
setNumber(ledDigitalOne, One);
delay(1000);
setNumber(ledDigitalOne, Zero);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 8
changeLED(1,ON);
changeLED(2,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Nine);
delay(1000);
setNumber(ledDigitalOne, Eight);
delay(1000);
setNumber(ledDigitalOne, Seven);
delay(1000);
setNumber(ledDigitalOne, Six);
delay(1000);
setNumber(ledDigitalOne, Five);
delay(1000);
setNumber(ledDigitalOne, Four);
delay(1000);
setNumber(ledDigitalOne, Three);
delay(1000);
setNumber(ledDigitalOne, Two);
delay(1000);
setNumber(ledDigitalOne, One);
delay(1000);
setNumber(ledDigitalOne, Zero);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(3,ON); // - 7
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Nine);
delay(1000);
setNumber(ledDigitalOne, Eight);
delay(1000);
setNumber(ledDigitalOne, Seven);
delay(1000);
setNumber(ledDigitalOne, Six);
delay(1000);
setNumber(ledDigitalOne, Five);
delay(1000);
setNumber(ledDigitalOne, Four);
delay(1000);
setNumber(ledDigitalOne, Three);
delay(1000);
setNumber(ledDigitalOne, Two);
delay(1000);
setNumber(ledDigitalOne, One);
delay(1000);
setNumber(ledDigitalOne, Zero);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 6
changeLED(1,ON);
changeLED(2,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
setNumber(ledDigitalOne, Nine);
delay(1000);
setNumber(ledDigitalOne, Eight);
delay(1000);
setNumber(ledDigitalOne, Seven);
delay(1000);
setNumber(ledDigitalOne, Six);
delay(1000);
setNumber(ledDigitalOne, Five);
delay(1000);
setNumber(ledDigitalOne, Four);
delay(1000);
setNumber(ledDigitalOne, Three);
delay(1000);
setNumber(ledDigitalOne, Two);
delay(1000);
setNumber(ledDigitalOne, One);
delay(1000);
setNumber(ledDigitalOne, Zero);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 5
changeLED(1,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
setNumber(ledDigitalOne, Nine);
delay(1000);
setNumber(ledDigitalOne, Eight);
delay(1000);
setNumber(ledDigitalOne, Seven);
delay(1000);
setNumber(ledDigitalOne, Six);
delay(1000);
setNumber(ledDigitalOne, Five);
delay(1000);
setNumber(ledDigitalOne, Four);
delay(1000);
setNumber(ledDigitalOne, Three);
delay(1000);
setNumber(ledDigitalOne, Two);
delay(1000);
setNumber(ledDigitalOne, One);
delay(1000);
setNumber(ledDigitalOne, Zero);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 4
changeLED(3,ON);
changeLED(4,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Nine);
delay(1000);
setNumber(ledDigitalOne, Eight);
delay(1000);
setNumber(ledDigitalOne, Seven);
delay(1000);
setNumber(ledDigitalOne, Six);
delay(1000);
setNumber(ledDigitalOne, Five);
delay(1000);
setNumber(ledDigitalOne, Four);
delay(1000);
setNumber(ledDigitalOne, Three);
delay(1000);
setNumber(ledDigitalOne, Two);
delay(1000);
setNumber(ledDigitalOne, One);
delay(1000);
setNumber(ledDigitalOne, Zero);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 3
changeLED(1,ON);
changeLED(3,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Nine);
delay(1000);
setNumber(ledDigitalOne, Eight);
delay(1000);
setNumber(ledDigitalOne, Seven);
delay(1000);
setNumber(ledDigitalOne, Six);
delay(1000);
setNumber(ledDigitalOne, Five);
delay(1000);
setNumber(ledDigitalOne, Four);
delay(1000);
setNumber(ledDigitalOne, Three);
delay(1000);
setNumber(ledDigitalOne, Two);
delay(1000);
setNumber(ledDigitalOne, One);
delay(1000);
setNumber(ledDigitalOne, Zero);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - 2
changeLED(2,ON);
changeLED(0,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Nine);
delay(1000);
setNumber(ledDigitalOne, Eight);
delay(1000);
setNumber(ledDigitalOne, Seven);
delay(1000);
setNumber(ledDigitalOne, Six);
delay(1000);
setNumber(ledDigitalOne, Five);
delay(1000);
setNumber(ledDigitalOne, Four);
delay(1000);
setNumber(ledDigitalOne, Three);
delay(1000);
setNumber(ledDigitalOne, Two);
delay(1000);
setNumber(ledDigitalOne, One);
delay(1000);
setNumber(ledDigitalOne, Zero);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(3,ON); // - 1
changeLED(6,ON);
setNumber(ledDigitalOne, Nine);
delay(1000);
setNumber(ledDigitalOne, Eight);
delay(1000);
setNumber(ledDigitalOne, Seven);
delay(1000);
setNumber(ledDigitalOne, Six);
delay(1000);
setNumber(ledDigitalOne, Five);
delay(1000);
setNumber(ledDigitalOne, Four);
delay(1000);
setNumber(ledDigitalOne, Three);
delay(1000);
setNumber(ledDigitalOne, Two);
delay(1000);
setNumber(ledDigitalOne, One);
delay(1000);
setNumber(ledDigitalOne, Zero);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(3,ON); // - 0
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Nine);
delay(1000);
setNumber(ledDigitalOne, Eight);
delay(1000);
setNumber(ledDigitalOne, Seven);
delay(1000);
setNumber(ledDigitalOne, Six);
delay(1000);
setNumber(ledDigitalOne, Five);
delay(1000);
setNumber(ledDigitalOne, Four);
delay(1000);
setNumber(ledDigitalOne, Three);
delay(1000);
setNumber(ledDigitalOne, Two);
delay(1000);
setNumber(ledDigitalOne, One);
delay(1000);
setNumber(ledDigitalOne, Zero);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
}
}
/*
* updateLEDs() - sends the LED states set in ledStates to the 74HC595
* sequence
*/
void updateLEDs(int value){
digitalWrite(latch, LOW); //Pulls the chips latch low
shiftOut(data, clock, MSBFIRST, value); //Shifts out the 8 bits to the shift register
digitalWrite(latch, HIGH); //Pulls the latch high displaying the data
}
/*
* updateLEDsLong() - sends the LED states set in ledStates to the 74HC595
* sequence. Same as updateLEDs except the shifting out is done in software
* so you can see what is happening.
*/
void updateLEDsLong(int value){
digitalWrite(latch, LOW); //Pulls the chips latch low
for(int i = 0; i < 8; i++){ //Will repeat 8 times (once for each bit)
int bit = value & B10000000; //We use a "bitmask" to select only the eighth
//bit in our number (the one we are addressing this time through
value = value << 1; //we move our number up one bit value so next time bit 7 will be
//bit 8 and we will do our math on it
if(bit == 128){digitalWrite(data, HIGH);} //if bit 8 is set then set our data pin high
else{digitalWrite(data, LOW);} //if bit 8 is unset then set the data pin low
digitalWrite(clock, HIGH); //the next three lines pulse the clock pin
delay(1);
digitalWrite(clock, LOW);
}
digitalWrite(latch, HIGH); //pulls the latch high shifting our data into being displayed
}
//These are used in the bitwise math that we use to change individual LEDs
//For more details http://en.wikipedia.org/wiki/Bitwise_operation
int bits[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000};
int masks[] = {B11111110, B11111101, B11111011, B11110111, B11101111, B11011111, B10111111, B01111111};
/*
* changeLED(int led, int state) - changes an individual LED
* LEDs are 0 to 7 and state is either 0 - OFF or 1 - ON
*/
void changeLED(int led, int state){
ledState = ledState & masks[led]; //clears ledState of the bit we are addressing
if(state == ON){ledState = ledState | bits[led];} //if the bit is on we will add it to ledState
updateLEDs(ledState); //send the new LED state to the shift register
}
void setNumber(int* led, boolean* number)
{
for(int i = 0; i < 7; i++)
{
digitalWrite(led[i], number[i]);
}
}
/* A version of setColor that allows for using const boolean colors
*/
void setNumber(int* led, const boolean* number)
{
boolean tempNumber[] = {number[0], number[1], number[2], number[3], number[4], number[5], number[6]};
setNumber(led, tempNumber);
}

323
Projects/7 Segment Main/_2x7_Segment_74HC_HEI_ELIAS_/_2x7_Segment_74HC_HEI_ELIAS_.ino Executable file
View File

@@ -0,0 +1,323 @@
/* ---------------------------------------------------------
* | Arduino Experimentation Kit Example Code |
* | CIRC-05 .: 8 More LEDs :. (74HC595 Shift Register) |
* ---------------------------------------------------------
*
* We have already controlled 8 LEDs however this does it in a slightly
* different manner. Rather than using 8 pins we will use just three
* and an additional chip.
*
*
*/
//Pin Definitions
//Pin Definitions
//The 74HC595 uses a serial communication
//link which has three pins
int data = 2;
int clock = 3;
int latch = 4;
//Used for single LED manipulation
int ledState = 0;
const int ON = HIGH;
const int OFF = LOW;
int ledDigitalOne[] = {13, 12, 11, 10, 9, 8, 7, 6}; //the three digital pins of the digital LED
//9 = redPin, 10 = greenPin, 11 = bluePin
const boolean ON1 = HIGH; //Define on as LOW (this is because we use a common
//Anode RGB LED (common pin is connected to +5 volts)
const boolean OFF1 = LOW; //Define off as HIGH
//Predefined Colors
const boolean One[] = {ON1, OFF1, OFF1, OFF1, OFF1, OFF1, ON1};
const boolean Two[] = {OFF1, ON1, ON1, ON1, OFF1, ON1, ON1};
const boolean Three[] = {ON1, ON1, OFF1, ON1, OFF1, ON1, ON1};
const boolean Four[] = {ON1, OFF1, OFF1, ON1, ON1, OFF1, ON1};
const boolean Five[] = {ON1, ON1, OFF1, ON1, ON1, ON1, OFF1};
const boolean Six[] = {ON1, ON1, ON1, ON1, ON1, ON1, OFF1};
const boolean Seven[] = {ON1, OFF1, OFF1, OFF1, OFF1, ON1, ON1};
const boolean Eight[] = {ON1, ON1, ON1, ON1, ON1, ON1, ON1};
const boolean Nine[] = {ON1, ON1, OFF1, ON1, ON1, ON1, ON1};
const boolean Zero[] = {ON1, ON1, ON1, OFF1, ON1, ON1, ON1};
const boolean A[] = {OFF1, ON1, ON1, OFF1, ON1, ON1, OFF1};
const boolean B[] = {ON1, ON1, ON1, OFF1, ON1, ON1, ON1};
const boolean C[] = {ON1, ON1, OFF1, OFF1, OFF1, OFF1, ON1};
const boolean D[] = {ON1, ON1, OFF1, ON1, OFF1, OFF1, OFF1};
const boolean E[] = {ON1, ON1, ON1, OFF1, OFF1, OFF1, ON1};
const boolean F[] = {OFF1, ON1, OFF1, OFF1, OFF1, OFF1, OFF1};
const boolean G[] = {ON1, ON1, OFF1, OFF1, ON1, ON1, ON1};
const boolean H[] = {OFF1, ON1, ON1, OFF1, ON1, ON1, OFF1};
const boolean I[] = {OFF1, OFF1, OFF1, ON1, OFF1, OFF1, OFF1};
const boolean J[] = {ON1, ON1, OFF1, OFF1, OFF1, ON1, ON1};
const boolean K[] = {OFF1, ON1, ON1, ON1, OFF1, OFF1, ON1};
const boolean L[] = {ON1, ON1, OFF1, OFF1, OFF1, OFF1, ON1};
const boolean M[] = {OFF1, ON1, OFF1, OFF1, OFF1, ON1, OFF1};
const boolean N[] = {OFF1, ON1, OFF1, ON1, OFF1, ON1, ON1};
const boolean O[] = {ON1, ON1, OFF1, OFF1, OFF1, ON1, ON1};
const boolean P[] = {OFF1, ON1, OFF1, OFF1, OFF1, OFF1, OFF1};
const boolean Q[] = {ON1, ON1, OFF1, OFF1, OFF1, ON1, OFF1};
const boolean R[] = {OFF1, ON1, OFF1, ON1, OFF1, OFF1, ON1};
const boolean S[] = {ON1, OFF1, OFF1, OFF1, OFF1, ON1, ON1};
const boolean T[] = {OFF1, OFF1, OFF1, ON1, OFF1, OFF1, OFF1};
const boolean U[] = {ON1, ON1, OFF1, OFF1, OFF1, ON1, ON1};
const boolean V[] = {OFF1, OFF1, OFF1, ON1, OFF1, OFF1, OFF1};
const boolean W[] = {ON1, ON1, OFF1, ON1, OFF1, ON1, ON1};
const boolean X[] = {OFF1, ON1, OFF1, OFF1, OFF1, ON1, OFF1};
const boolean Y[] = {OFF1, OFF1, OFF1, ON1, OFF1, OFF1, OFF1};
const boolean Z[] = {ON1, ON1, ON1, OFF1, OFF1, OFF1, ON1};
const boolean EXCLA[] = {OFF1, ON1, OFF1, OFF1, OFF1, OFF1, OFF1, ON1};
const boolean BLANK[] = {OFF1, OFF1, OFF1, OFF1, OFF1, OFF1, OFF1, OFF1};
//An Array that stores the predefined colors (allows us to later randomly display a color)
const boolean* NUMBERS[] = {One, Two, Three, Four, Five, Six, Seven, Eight, Nine, Zero};
void setup()
{
pinMode(data, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(latch, OUTPUT);
for(int i = 0; i < 9; i++)
{
pinMode(ledDigitalOne[i], OUTPUT); //Set the three LED pins as outputs
}
}
/*
* loop() - this function will start after setup finishes and then repeat
* we set which LEDs we want on then call a routine which sends the states to the 74HC595
*/
void loop() // run over and over again
{
int delayTime = 500;
for (int i = 0; i < 31; i++)
{
changeLED(0,ON); // -- H
changeLED(1,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, H);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // -- E
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
setNumber(ledDigitalOne, E);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(3,ON); // - I
setNumber(ledDigitalOne, I);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
setNumber(ledDigitalOne, BLANK);
delay(1000);
changeLED(0,ON); // -- E
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
setNumber(ledDigitalOne, E);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - L
setNumber(ledDigitalOne, L);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(3,ON); // - I
setNumber(ledDigitalOne, I);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - A
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, A);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // -- S
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, S);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - EXCLA
changeLED(7,ON);
setNumber(ledDigitalOne, EXCLA);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(7,OFF);
}
}
/*
* updateLEDs() - sends the LED states set in ledStates to the 74HC595
* sequence
*/
void updateLEDs(int value){
digitalWrite(latch, LOW); //Pulls the chips latch low
shiftOut(data, clock, MSBFIRST, value); //Shifts out the 8 bits to the shift register
digitalWrite(latch, HIGH); //Pulls the latch high displaying the data
}
/*
* updateLEDsLong() - sends the LED states set in ledStates to the 74HC595
* sequence. Same as updateLEDs except the shifting out is done in software
* so you can see what is happening.
*/
void updateLEDsLong(int value){
digitalWrite(latch, LOW); //Pulls the chips latch low
for(int i = 0; i < 8; i++){ //Will repeat 8 times (once for each bit)
int bit = value & B10000000; //We use a "bitmask" to select only the eighth
//bit in our number (the one we are addressing this time through
value = value << 1; //we move our number up one bit value so next time bit 7 will be
//bit 8 and we will do our math on it
if(bit == 128){digitalWrite(data, HIGH);} //if bit 8 is set then set our data pin high
else{digitalWrite(data, LOW);} //if bit 8 is unset then set the data pin low
digitalWrite(clock, HIGH); //the next three lines pulse the clock pin
delay(1);
digitalWrite(clock, LOW);
}
digitalWrite(latch, HIGH); //pulls the latch high shifting our data into being displayed
}
//These are used in the bitwise math that we use to change individual LEDs
//For more details http://en.wikipedia.org/wiki/Bitwise_operation
int bits[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000};
int masks[] = {B11111110, B11111101, B11111011, B11110111, B11101111, B11011111, B10111111, B01111111};
/*
* changeLED(int led, int state) - changes an individual LED
* LEDs are 0 to 7 and state is either 0 - OFF or 1 - ON
*/
void changeLED(int led, int state){
ledState = ledState & masks[led]; //clears ledState of the bit we are addressing
if(state == ON){ledState = ledState | bits[led];} //if the bit is on we will add it to ledState
updateLEDs(ledState); //send the new LED state to the shift register
}
void setNumber(int* led, boolean* number)
{
for(int i = 0; i < 7; i++)
{
digitalWrite(led[i], number[i]);
}
}
/* A version of setColor that allows for using const boolean colors
*/
void setNumber(int* led, const boolean* number)
{
boolean tempNumber[] = {number[0], number[1], number[2], number[3], number[4], number[5], number[6]};
setNumber(led, tempNumber);
}

324
Projects/7 Segment Main/_2x7_Segment_74HC_Self/_2x7_Segment_74HC_Self.ino Executable file
View File

@@ -0,0 +1,324 @@
/* ---------------------------------------------------------
* | Arduino Experimentation Kit Example Code |
* | CIRC-05 .: 8 More LEDs :. (74HC595 Shift Register) |
* ---------------------------------------------------------
*
* We have already controlled 8 LEDs however this does it in a slightly
* different manner. Rather than using 8 pins we will use just three
* and an additional chip.
*
*
*/
//Pin Definitions
//Pin Definitions
//The 74HC595 uses a serial communication
//link which has three pins
int data = 2;
int clock = 3;
int latch = 4;
//Used for single LED manipulation
int ledState = 0;
const int ON = HIGH;
const int OFF = LOW;
int ledDigitalOne[] = {13, 12, 11, 10, 9, 8, 7}; //the three digital pins of the digital LED
//9 = redPin, 10 = greenPin, 11 = bluePin
const boolean ON1 = HIGH; //Define on as LOW (this is because we use a common
//Anode RGB LED (common pin is connected to +5 volts)
const boolean OFF1 = LOW; //Define off as HIGH
//Predefined Colors
const boolean One[] = {ON1, OFF1, OFF1, OFF1, OFF1, OFF1, ON1};
const boolean Two[] = {OFF1, ON1, ON1, ON1, OFF1, ON1, ON1};
const boolean Three[] = {ON1, ON1, OFF1, ON1, OFF1, ON1, ON1};
const boolean Four[] = {ON1, OFF1, OFF1, ON1, ON1, OFF1, ON1};
const boolean Five[] = {ON1, ON1, OFF1, ON1, ON1, ON1, OFF1};
const boolean Six[] = {ON1, ON1, ON1, ON1, ON1, ON1, OFF1};
const boolean Seven[] = {ON1, OFF1, OFF1, OFF1, OFF1, ON1, ON1};
const boolean Eight[] = {ON1, ON1, ON1, ON1, ON1, ON1, ON1};
const boolean Nine[] = {ON1, ON1, OFF1, ON1, ON1, ON1, ON1};
const boolean Zero[] = {ON1, ON1, ON1, OFF1, ON1, ON1, ON1};
//An Array that stores the predefined colors (allows us to later randomly display a color)
const boolean* NUMBERS[] = {One, Two, Three, Four, Five, Six, Seven, Eight, Nine, Zero};
void setup()
{
pinMode(data, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(latch, OUTPUT);
for(int i = 0; i < 9; i++)
{
pinMode(ledDigitalOne[i], OUTPUT); //Set the three LED pins as outputs
}
}
/*
* loop() - this function will start after setup finishes and then repeat
* we set which LEDs we want on then call a routine which sends the states to the 74HC595
*/
void loop() // run over and over again
{
int delayTime = 500;
for (int i = 0; i < 8; i++)
{
changeLED(0,ON); // - 9
changeLED(1,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Nine);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 8
changeLED(1,ON);
changeLED(2,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Eight);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 7
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Seven);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 6
changeLED(1,ON);
changeLED(2,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
setNumber(ledDigitalOne, Six);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 5
changeLED(1,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
setNumber(ledDigitalOne, Five);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 4
changeLED(3,ON);
changeLED(4,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Four);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 3
changeLED(1,ON);
changeLED(3,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Three);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - 2
changeLED(2,ON);
changeLED(3,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Two);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 1
changeLED(6,ON);
setNumber(ledDigitalOne, One);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 0
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Zero);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
}
}
/*
* updateLEDs() - sends the LED states set in ledStates to the 74HC595
* sequence
*/
void updateLEDs(int value){
digitalWrite(latch, LOW); //Pulls the chips latch low
shiftOut(data, clock, MSBFIRST, value); //Shifts out the 8 bits to the shift register
digitalWrite(latch, HIGH); //Pulls the latch high displaying the data
}
/*
* updateLEDsLong() - sends the LED states set in ledStates to the 74HC595
* sequence. Same as updateLEDs except the shifting out is done in software
* so you can see what is happening.
*/
void updateLEDsLong(int value){
digitalWrite(latch, LOW); //Pulls the chips latch low
for(int i = 0; i < 8; i++){ //Will repeat 8 times (once for each bit)
int bit = value & B10000000; //We use a "bitmask" to select only the eighth
//bit in our number (the one we are addressing this time through
value = value << 1; //we move our number up one bit value so next time bit 7 will be
//bit 8 and we will do our math on it
if(bit == 128){digitalWrite(data, HIGH);} //if bit 8 is set then set our data pin high
else{digitalWrite(data, LOW);} //if bit 8 is unset then set the data pin low
digitalWrite(clock, HIGH); //the next three lines pulse the clock pin
delay(1);
digitalWrite(clock, LOW);
}
digitalWrite(latch, HIGH); //pulls the latch high shifting our data into being displayed
}
//These are used in the bitwise math that we use to change individual LEDs
//For more details http://en.wikipedia.org/wiki/Bitwise_operation
int bits[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000};
int masks[] = {B11111110, B11111101, B11111011, B11110111, B11101111, B11011111, B10111111, B01111111};
/*
* changeLED(int led, int state) - changes an individual LED
* LEDs are 0 to 7 and state is either 0 - OFF or 1 - ON
*/
void changeLED(int led, int state){
ledState = ledState & masks[led]; //clears ledState of the bit we are addressing
if(state == ON){ledState = ledState | bits[led];} //if the bit is on we will add it to ledState
updateLEDs(ledState); //send the new LED state to the shift register
}
void setNumber(int* led, boolean* number)
{
for(int i = 0; i < 7; i++)
{
digitalWrite(led[i], number[i]);
}
}
/* A version of setColor that allows for using const boolean colors
*/
void setNumber(int* led, const boolean* number)
{
boolean tempNumber[] = {number[0], number[1], number[2], number[3], number[4], number[5], number[6]};
setNumber(led, tempNumber);
}

603
Projects/7 Segment Main/_2x7_Segment_74HC_Write/_2x7_Segment_74HC_Write.ino Executable file
View File

@@ -0,0 +1,603 @@
/* ---------------------------------------------------------
* | Arduino Experimentation Kit Example Code |
* | CIRC-05 .: 8 More LEDs :. (74HC595 Shift Register) |
* ---------------------------------------------------------
*
* We have already controlled 8 LEDs however this does it in a slightly
* different manner. Rather than using 8 pins we will use just three
* and an additional chip.
*
*
*/
//Pin Definitions
//Pin Definitions
//The 74HC595 uses a serial communication
//link which has three pins
int data = 2;
int clock = 3;
int latch = 4;
//Used for single LED manipulation
int ledState = 0;
const int ON = HIGH;
const int OFF = LOW;
int ledDigitalOne[] = {13, 12, 11, 10, 9, 8, 7, 6}; //the three digital pins of the digital LED
//9 = redPin, 10 = greenPin, 11 = bluePin
const boolean ON1 = HIGH; //Define on as LOW (this is because we use a common
//Anode RGB LED (common pin is connected to +5 volts)
const boolean OFF1 = LOW; //Define off as HIGH
//Predefined Colors
const boolean One[] = {ON1, OFF1, OFF1, OFF1, OFF1, OFF1, ON1};
const boolean Two[] = {OFF1, ON1, ON1, ON1, OFF1, ON1, ON1};
const boolean Three[] = {ON1, ON1, OFF1, ON1, OFF1, ON1, ON1};
const boolean Four[] = {ON1, OFF1, OFF1, ON1, ON1, OFF1, ON1};
const boolean Five[] = {ON1, ON1, OFF1, ON1, ON1, ON1, OFF1};
const boolean Six[] = {ON1, ON1, ON1, ON1, ON1, ON1, OFF1};
const boolean Seven[] = {ON1, OFF1, OFF1, OFF1, OFF1, ON1, ON1};
const boolean Eight[] = {ON1, ON1, ON1, ON1, ON1, ON1, ON1};
const boolean Nine[] = {ON1, ON1, OFF1, ON1, ON1, ON1, ON1};
const boolean Zero[] = {ON1, ON1, ON1, OFF1, ON1, ON1, ON1};
const boolean A[] = {OFF1, ON1, OFF1, OFF1, OFF1, ON1, OFF1};
const boolean B[] = {ON1, ON1, ON1, OFF1, ON1, ON1, ON1};
const boolean C[] = {ON1, ON1, OFF1, OFF1, OFF1, OFF1, ON1};
const boolean D[] = {ON1, ON1, OFF1, ON1, OFF1, OFF1, OFF1};
const boolean E[] = {ON1, ON1, ON1, OFF1, OFF1, OFF1, ON1};
const boolean F[] = {OFF1, ON1, OFF1, OFF1, OFF1, OFF1, OFF1};
const boolean G[] = {ON1, ON1, OFF1, OFF1, ON1, ON1, ON1};
const boolean H[] = {OFF1, ON1, ON1, OFF1, ON1, ON1, OFF1};
const boolean I[] = {OFF1, OFF1, OFF1, ON1, OFF1, OFF1, OFF1};
const boolean J[] = {ON1, ON1, OFF1, OFF1, OFF1, ON1, ON1};
const boolean K[] = {OFF1, ON1, ON1, ON1, OFF1, OFF1, ON1};
const boolean L[] = {ON1, ON1, OFF1, OFF1, OFF1, OFF1, ON1};
const boolean M[] = {OFF1, ON1, OFF1, OFF1, OFF1, ON1, OFF1};
const boolean N[] = {OFF1, ON1, OFF1, ON1, OFF1, ON1, ON1};
const boolean O[] = {ON1, ON1, OFF1, OFF1, OFF1, ON1, ON1};
const boolean P[] = {OFF1, ON1, OFF1, OFF1, OFF1, OFF1, OFF1};
const boolean Q[] = {ON1, ON1, OFF1, OFF1, OFF1, ON1, OFF1};
const boolean R[] = {OFF1, ON1, OFF1, ON1, OFF1, OFF1, ON1};
const boolean S[] = {ON1, OFF1, OFF1, OFF1, OFF1, ON1, ON1};
const boolean T[] = {OFF1, OFF1, OFF1, ON1, OFF1, OFF1, OFF1};
const boolean U[] = {ON1, ON1, OFF1, OFF1, OFF1, ON1, ON1};
const boolean V[] = {OFF1, OFF1, OFF1, ON1, OFF1, OFF1, OFF1};
const boolean W[] = {ON1, ON1, OFF1, ON1, OFF1, ON1, ON1};
const boolean X[] = {OFF1, ON1, OFF1, OFF1, OFF1, ON1, OFF1};
const boolean Y[] = {OFF1, OFF1, OFF1, ON1, OFF1, OFF1, OFF1};
const boolean Z[] = {ON1, ON1, ON1, OFF1, OFF1, OFF1, ON1};
const boolean EXCLA[] = {OFF1, ON1, OFF1, OFF1, OFF1, OFF1, OFF1, ON1};
//An Array that stores the predefined colors (allows us to later randomly display a color)
const boolean* NUMBERS[] = {One, Two, Three, Four, Five, Six, Seven, Eight, Nine, Zero};
void setup()
{
pinMode(data, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(latch, OUTPUT);
for(int i = 0; i < 9; i++)
{
pinMode(ledDigitalOne[i], OUTPUT); //Set the three LED pins as outputs
}
}
/*
* loop() - this function will start after setup finishes and then repeat
* we set which LEDs we want on then call a routine which sends the states to the 74HC595
*/
void loop() // run over and over again
{
int delayTime = 500;
for (int i = 0; i < 31; i++)
{
changeLED(0,ON); // - A
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, A);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - B
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, B);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - C
changeLED(2,ON);
changeLED(4,ON);
setNumber(ledDigitalOne, C);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - D
changeLED(2,ON);
changeLED(3,ON);
setNumber(ledDigitalOne, D);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // -- E
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
setNumber(ledDigitalOne, E);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // -- F
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
setNumber(ledDigitalOne, F);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // -- G
changeLED(2,ON);
changeLED(4,ON);
setNumber(ledDigitalOne, G);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // -- H
changeLED(1,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, H);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(3,ON); // - I
setNumber(ledDigitalOne, I);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(5,ON); // - j
setNumber(ledDigitalOne, J);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // -- K
changeLED(1,ON);
changeLED(3,ON);
changeLED(4,ON);
setNumber(ledDigitalOne, K);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - L
setNumber(ledDigitalOne, L);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - M
changeLED(2,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
setNumber(ledDigitalOne, M);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - N
changeLED(2,ON);
changeLED(3,ON);
changeLED(5,ON);
setNumber(ledDigitalOne, N);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - 0
changeLED(2,ON);
changeLED(4,ON);
changeLED(5,ON);
setNumber(ledDigitalOne, O);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // -- P
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, P);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - Q
changeLED(2,ON);
changeLED(4,ON);
changeLED(5,ON);
setNumber(ledDigitalOne, Q);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // -- R
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, R);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // -- S
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, S);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(2,ON); // - T
changeLED(3,ON);
changeLED(4,ON);
setNumber(ledDigitalOne, T);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - U
changeLED(5,ON);
setNumber(ledDigitalOne, U);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - V
changeLED(5,ON);
setNumber(ledDigitalOne, V);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - W
changeLED(5,ON);
setNumber(ledDigitalOne, W);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - X
changeLED(5,ON);
setNumber(ledDigitalOne, X);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // -- Y
changeLED(1,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Y);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(2,ON); // - Z
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
setNumber(ledDigitalOne, Z);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - EXCLA
changeLED(7,ON);
setNumber(ledDigitalOne, EXCLA);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(7,OFF);
}
}
/*
* updateLEDs() - sends the LED states set in ledStates to the 74HC595
* sequence
*/
void updateLEDs(int value){
digitalWrite(latch, LOW); //Pulls the chips latch low
shiftOut(data, clock, MSBFIRST, value); //Shifts out the 8 bits to the shift register
digitalWrite(latch, HIGH); //Pulls the latch high displaying the data
}
/*
* updateLEDsLong() - sends the LED states set in ledStates to the 74HC595
* sequence. Same as updateLEDs except the shifting out is done in software
* so you can see what is happening.
*/
void updateLEDsLong(int value){
digitalWrite(latch, LOW); //Pulls the chips latch low
for(int i = 0; i < 8; i++){ //Will repeat 8 times (once for each bit)
int bit = value & B10000000; //We use a "bitmask" to select only the eighth
//bit in our number (the one we are addressing this time through
value = value << 1; //we move our number up one bit value so next time bit 7 will be
//bit 8 and we will do our math on it
if(bit == 128){digitalWrite(data, HIGH);} //if bit 8 is set then set our data pin high
else{digitalWrite(data, LOW);} //if bit 8 is unset then set the data pin low
digitalWrite(clock, HIGH); //the next three lines pulse the clock pin
delay(1);
digitalWrite(clock, LOW);
}
digitalWrite(latch, HIGH); //pulls the latch high shifting our data into being displayed
}
//These are used in the bitwise math that we use to change individual LEDs
//For more details http://en.wikipedia.org/wiki/Bitwise_operation
int bits[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000};
int masks[] = {B11111110, B11111101, B11111011, B11110111, B11101111, B11011111, B10111111, B01111111};
/*
* changeLED(int led, int state) - changes an individual LED
* LEDs are 0 to 7 and state is either 0 - OFF or 1 - ON
*/
void changeLED(int led, int state){
ledState = ledState & masks[led]; //clears ledState of the bit we are addressing
if(state == ON){ledState = ledState | bits[led];} //if the bit is on we will add it to ledState
updateLEDs(ledState); //send the new LED state to the shift register
}
void setNumber(int* led, boolean* number)
{
for(int i = 0; i < 7; i++)
{
digitalWrite(led[i], number[i]);
}
}
/* A version of setColor that allows for using const boolean colors
*/
void setNumber(int* led, const boolean* number)
{
boolean tempNumber[] = {number[0], number[1], number[2], number[3], number[4], number[5], number[6]};
setNumber(led, tempNumber);
}

288
Projects/7 Segment Main/_7_Segment/_7_Segment.ino Executable file
View File

@@ -0,0 +1,288 @@
/*
Make Projects: How to Drive a 7 Segment LED
URL:
By: Riley Porter
This is an introduction on how to drive a 7 Segment LED using only a Arduino. This is
not the best way to do this. This is meant to be a learning excercise. In later tutorials
I will show you how to use an dedicated IC using SPI or a Shift Register. Enjoy.
*/
digitalWrite(A, HIGH) = turn off the "A" segment in the LED display
digitalWrite(B, LOW) = turn on the "B" segment in the LED display
#define A 8
#define B 9
#define C 2
#define D 3
#define E 4
#define F 5
#define G 6
void clr()
{
//Clears the LED
digitalWrite(A, HIGH);
digitalWrite(B, HIGH);
digitalWrite(C, HIGH);
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, HIGH);
}
void char_A()
{
digitalWrite(D, HIGH);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOg9tW);
}
z
void char_B()
{
//Displays B
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
digitalWrite(A, HIGH);
digitalWrite(B, HIGH);
digitalWrite(C, LOW);
}
void char_C()
{
//Displays C
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, HIGH);
digitalWrite(A, LOW);
digitalWrite(B, HIGH);
digitalWrite(C, HIGH);
}
void char_D()
{
//Displays D
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, HIGH);
digitalWrite(G, LOW);
digitalWrite(A, HIGH);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
}
void char_E()
{
//Displays E
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
digitalWrite(A, LOW);
digitalWrite(B, HIGH);
digitalWrite(C, HIGH);
}
void char_F()
{
//Displays F
digitalWrite(D, HIGH);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
digitalWrite(A, LOW);
digitalWrite(B, HIGH);
digitalWrite(C, HIGH);
}
void one()
{
//Displays 1
digitalWrite(D, HIGH);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, HIGH);
digitalWrite(A, HIGH);
digitalWrite(B, HIGH);
digitalWrite(C, HIGH);
}
void two()
{
//Displays 2
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, HIGH);
digitalWrite(G, LOW);
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, HIGH);
}
void three()
{
//Displays 3
digitalWrite(D, LOW);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, LOW);
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
}
void four()
{
//Displays 4
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
digitalWrite(A, HIGH);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
}
void five()
{
//Displays 5
digitalWrite(D, LOW);
digitalWrite(E, HIGH);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
digitalWrite(A, LOW);
digitalWrite(B, HIGH);
digitalWrite(C, LOW);
}
void six()
{
//Displays 6
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
digitalWrite(A, LOW);
digitalWrite(B, HIGH);
digitalWrite(C, LOW);
}
void seven()
{
//Displays 7
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, HIGH);
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
}
void eight()
{
//Displays 8
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
}
void nine()
{
//Displays 9
digitalWrite(D, LOW);
digitalWrite(E, HIGH);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
}
void zero()
{
//Displays 0
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, HIGH);
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
}
void LoopDisplay()
{
//Loop through all Chars and Numbers
char_A();
delay(1000);
char_B();
delay(1000);
char_C();
delay(1000);
char_D();
delay(1000);
char_E();
delay(1000);
char_F();
delay(1000);
one();
delay(1000);
two();
delay(1000);
three();
delay(1000);
four();
delay(1000);
five();
delay(1000);
six();
delay(1000);
seven();
delay(1000);
eight();
delay(1000);
nine();
delay(1000);
zero();
delay(1000);
}
void setup()
{
//Setup our pins
pinMode(A, OUTPUT);
pinMode(B, OUTPUT);
pinMode(C, OUTPUT);
pinMode(D, OUTPUT);
pinMode(E, OUTPUT);
pinMode(F, OUTPUT);
pinMode(G, OUTPUT);
Serial.begin(9600); //Begin serial communcation
}
void loop()
{
Serial.println("Starting\n");
LoopDisplay();
}

98
Projects/7 Segment Main/_7_Segment_Letters/_7_Segment_Letters.ino Executable file
View File

@@ -0,0 +1,98 @@
int ledDigitalOne[] = {1, 2, 3, 4, 5, 6, 7}; //the three digital pins of the digital LED
//9 = redPin, 10 = greenPin, 11 = bluePin
const boolean ON = HIGH; //Define on as LOW (this is because we use a common
//Anode RGB LED (common pin is connected to +5 volts)
const boolean OFF = LOW; //Define off as HIGH
//Predefined Colors
const boolean One[] = {OFF, ON, OFF, OFF, OFF, OFF, ON};
const boolean Two[] = {ON, OFF, ON, ON, OFF, ON, ON};
const boolean Three[] = {ON, ON, OFF, ON, OFF, ON, ON};
const boolean Four[] = {OFF, ON, OFF, ON, ON, OFF, ON};
const boolean Five[] = {ON, ON, OFF, ON, ON, ON, OFF};
const boolean Six[] = {ON, ON, ON, ON, ON, ON, OFF};
const boolean Seven[] = {OFF, ON, OFF, OFF, OFF, ON, ON};
const boolean Eight[] = {ON, ON, ON, ON, ON, ON, ON};
const boolean Nine[] = {ON, ON, OFF, ON, ON, ON, ON};
const boolean Zero[] = {ON, ON, ON, OFF, ON, ON, ON};
//An Array that stores the predefined colors (allows us to later randomly display a color)
const boolean* NUMBERS[] = {One, Two, Three, Four, Five, Six, Seven, Eight, Nine, Zero};
void setup(){
for(int i = 0; i < 9; i++){
pinMode(ledDigitalOne[i], OUTPUT); //Set the three LED pins as outputs
}
}
void loop(){
/* Example - 1 Set a color
Set the three LEDs to any predefined color
*/
setNumber(ledDigitalOne, Eight); //Set the color of LED one
for (int i = 0; i < 10; i++)
{
setNumber(ledDigitalOne, Nine);
delay (1000);
setNumber(ledDigitalOne, Eight);
delay (1000);
setNumber(ledDigitalOne, Seven);
delay (1000);
setNumber(ledDigitalOne, Six);
delay (1000);
setNumber(ledDigitalOne, Five);
delay (1000);
setNumber(ledDigitalOne, Four);
delay (1000);
setNumber(ledDigitalOne, Three);
delay (1000);
setNumber(ledDigitalOne, Two);
delay (1000);
setNumber(ledDigitalOne, One);
delay (1000);
setNumber(ledDigitalOne, Zero);
delay (1000);
}
/* Example - 2 Go through Random Colors
Set the LEDs to a random color
*/
//randomNumber();
}
//void randomNumber(){
//int rand = random(0, sizeof(NUMBER / 2); //get a random number within the range of colors
//setNumber(ledDigitalOne, NUMBER[rand]); //Set the color of led one to a random color
//delay(1000);
//}
/* Sets an led to any color
led - a three element array defining the three color pins (led[0] = redPin, led[1] = greenPin, led[2] = bluePin)
color - a three element boolean array (color[0] = red value (LOW = on, HIGH = off), color[1] = green value, color[2] =blue value)
*/
void setNumber(int* led, boolean* number)
{
for(int i = 0; i < 7; i++)
{
digitalWrite(led[i], number[i]);
}
}
/* A version of setColor that allows for using const boolean colors
*/
void setNumber(int* led, const boolean* number)
{
boolean tempNumber[] = {number[0], number[1], number[2], number[3], number[4], number[5], number[6]};
setNumber(led, tempNumber);
}
// the loop routine runs over and over again forever:

98
Projects/7 Segment Main/_7_Segment_Self/_7_Segment_Self.ino Executable file
View File

@@ -0,0 +1,98 @@
int ledDigitalOne[] = {13, 12, 11, 10, 9, 8, 7}; //the three digital pins of the digital LED
//9 = redPin, 10 = greenPin, 11 = bluePin
const boolean ON = HIGH; //Define on as LOW (this is because we use a common
//Anode RGB LED (common pin is connected to +5 volts)
const boolean OFF = LOW; //Define off as HIGH
//Predefined Colors
const boolean One[] = {ON, OFF, OFF, OFF, OFF, OFF, ON};
const boolean Two[] = {OFF, ON, ON, ON, OFF, ON, ON};
const boolean Three[] = {ON, ON, OFF, ON, OFF, ON, ON};
const boolean Four[] = {ON, OFF, OFF, ON, ON, OFF, ON};
const boolean Five[] = {ON, ON, OFF, ON, ON, ON, OFF};
const boolean Six[] = {ON, ON, ON, ON, ON, ON, OFF};
const boolean Seven[] = {ON, OFF, OFF, OFF, OFF, ON, ON};
const boolean Eight[] = {ON, ON, ON, ON, ON, ON, ON};
const boolean Nine[] = {ON, ON, OFF, ON, ON, ON, ON};
const boolean Zero[] = {ON, ON, ON, OFF, ON, ON, ON};
//An Array that stores the predefined colors (allows us to later randomly display a color)
const boolean* NUMBERS[] = {One, Two, Three, Four, Five, Six, Seven, Eight, Nine, Zero};
void setup(){
for(int i = 0; i < 9; i++){
pinMode(ledDigitalOne[i], OUTPUT); //Set the three LED pins as outputs
}
}
void loop(){
/* Example - 1 Set a color
Set the three LEDs to any predefined color
*/
setNumber(ledDigitalOne, Eight); //Set the color of LED one
for (int i = 0; i < 10; i++)
{
setNumber(ledDigitalOne, Nine);
delay (500);
setNumber(ledDigitalOne, Eight);
delay (500);
setNumber(ledDigitalOne, Seven);
delay (500);
setNumber(ledDigitalOne, Six);
delay (500);
setNumber(ledDigitalOne, Five);
delay (500);
setNumber(ledDigitalOne, Four);
delay (500);
setNumber(ledDigitalOne, Three);
delay (500);
setNumber(ledDigitalOne, Two);
delay (500);
setNumber(ledDigitalOne, One);
delay (500);
setNumber(ledDigitalOne, Zero);
delay (500);
}
/* Example - 2 Go through Random Colors
Set the LEDs to a random color
*/
//randomNumber();
}
//void randomNumber(){
//int rand = random(0, sizeof(NUMBER / 2); //get a random number within the range of colors
//setNumber(ledDigitalOne, NUMBER[rand]); //Set the color of led one to a random color
//delay(1000);
//}
/* Sets an led to any color
led - a three element array defining the three color pins (led[0] = redPin, led[1] = greenPin, led[2] = bluePin)
color - a three element boolean array (color[0] = red value (LOW = on, HIGH = off), color[1] = green value, color[2] =blue value)
*/
void setNumber(int* led, boolean* number)
{
for(int i = 0; i < 7; i++)
{
digitalWrite(led[i], number[i]);
}
}
/* A version of setColor that allows for using const boolean colors
*/
void setNumber(int* led, const boolean* number)
{
boolean tempNumber[] = {number[0], number[1], number[2], number[3], number[4], number[5], number[6]};
setNumber(led, tempNumber);
}
// the loop routine runs over and over again forever:

98
Projects/7 Segment Main/_7_Segment_w__74HC/_7_Segment_w__74HC.ino Executable file
View File

@@ -0,0 +1,98 @@
/* ---------------------------------------------------------
* | Arduino Experimentation Kit Example Code |
* | CIRC-05 .: 8 More LEDs :. (74HC595 Shift Register) |
* ---------------------------------------------------------
*
* We have already controlled 8 LEDs however this does it in a slightly
* different manner. Rather than using 8 pins we will use just three
* and an additional chip.
*
*
*/
//Pin Definitions
//Pin Definitions
//The 74HC595 uses a serial communication
//link which has three pins
int data = 11;
int latch = 12;
int clock = 13;
//Used for single LED manipulation
int ledState = 1;
const int ON = HIGH;
const int OFF = LOW;
/*
* setup() - this function runs once when you turn your Arduino on
* We set the three control pins to outputs
*/
void setup()
{
pinMode(data, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(latch, OUTPUT);
}
/*
* loop() - this function will start after setup finishes and then repeat
* we set which LEDs we want on then call a routine which sends the states to the 74HC595
*/
void loop() // run over and over again
{
int delayTime = 100; //the number of milliseconds to delay between LED updates
for(int i = 0; i < 256; i++){
updateLEDs(i);
delay(delayTime);
}
}
/*
* updateLEDs() - sends the LED states set in ledStates to the 74HC595
* sequence
*/
void updateLEDs(int value){
digitalWrite(latch, LOW); //Pulls the chips latch low
shiftOut(data, clock, MSBFIRST, value); //Shifts out the 8 bits to the shift register
digitalWrite(latch, HIGH); //Pulls the latch high displaying the data
}
/*
* updateLEDsLong() - sends the LED states set in ledStates to the 74HC595
* sequence. Same as updateLEDs except the shifting out is done in software
* so you can see what is happening.
*/
void updateLEDsLong(int value){
digitalWrite(latch, LOW); //Pulls the chips latch low
for(int i = 0; i < 8; i++){ //Will repeat 8 times (once for each bit)
int bit = value & B10000000; //We use a "bitmask" to select only the eighth
//bit in our number (the one we are addressing this time through
value = value << 1; //we move our number up one bit value so next time bit 7 will be
//bit 8 and we will do our math on it
if(bit == 128){digitalWrite(data, HIGH);} //if bit 8 is set then set our data pin high
else{digitalWrite(data, LOW);} //if bit 8 is unset then set the data pin low
digitalWrite(clock, HIGH); //the next three lines pulse the clock pin
delay(1);
digitalWrite(clock, LOW);
}
digitalWrite(latch, HIGH); //pulls the latch high shifting our data into being displayed
}
//These are used in the bitwise math that we use to change individual LEDs
//For more details http://en.wikipedia.org/wiki/Bitwise_operation
int bits[] = {B0000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000};
int masks[] = {B11111110, B11111101, B11111011, B11110111, B11101111, B11011111, B10111111, B01111111};
/*
* changeLED(int led, int state) - changes an individual LED
* LEDs are 0 to 7 and state is either 0 - OFF or 1 - ON
*/
void changeLED(int led, int state){
ledState = ledState & masks[led]; //clears ledState of the bit we are addressing
if(state == ON){ledState = ledState | bits[led];} //if the bit is on we will add it to ledState
updateLEDs(ledState); //send the new LED state to the shift register
}

236
Projects/7 Segment Main/_8_LED_74HC/_8_LED_74HC.ino Executable file
View File

@@ -0,0 +1,236 @@
/* ---------------------------------------------------------
* | Arduino Experimentation Kit Example Code |
* | CIRC-05 .: 8 More LEDs :. (74HC595 Shift Register) |
* ---------------------------------------------------------
*
* We have already controlled 8 LEDs however this does it in a slightly
* different manner. Rather than using 8 pins we will use just three
* and an additional chip.
*
*
*/
//Pin Definitions
//Pin Definitions
//The 74HC595 uses a serial communication
//link which has three pins
int data = 2;
int clock = 3;
int latch = 4;
//Used for single LED manipulation
int ledState = 0;
const int ON = HIGH;
const int OFF = LOW;
void setup()
{
pinMode(data, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(latch, OUTPUT);
}
/*
* loop() - this function will start after setup finishes and then repeat
* we set which LEDs we want on then call a routine which sends the states to the 74HC595
*/
void loop() // run over and over again
{
int delayTime = 500;
for (int i = 0; i < 8; i++)
{
changeLED(0,ON); // - 9
changeLED(1,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 8
changeLED(1,ON);
changeLED(2,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 7
changeLED(5,ON);
changeLED(6,ON);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 6
changeLED(1,ON);
changeLED(2,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 5
changeLED(1,ON);
changeLED(3,ON);
changeLED(4,ON);
changeLED(5,ON);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 4
changeLED(3,ON);
changeLED(4,ON);
changeLED(6,ON);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 3
changeLED(1,ON);
changeLED(3,ON);
changeLED(5,ON);
changeLED(6,ON);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(1,ON); // - 2
changeLED(2,ON);
changeLED(3,ON);
changeLED(5,ON);
changeLED(6,ON);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 1
changeLED(6,ON);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
changeLED(0,ON); // - 0
changeLED(1,ON);
changeLED(2,ON);
changeLED(4,ON);
changeLED(5,ON);
changeLED(6,ON);
delay(1000);
changeLED(0,OFF);
changeLED(1,OFF);
changeLED(2,OFF);
changeLED(3,OFF);
changeLED(4,OFF);
changeLED(5,OFF);
changeLED(6,OFF);
}
for (int i = 0; i < 7; i++)
{
changeLED(i,OFF);
delay(delayTime);
}
}
/*
* updateLEDs() - sends the LED states set in ledStates to the 74HC595
* sequence
*/
void updateLEDs(int value){
digitalWrite(latch, LOW); //Pulls the chips latch low
shiftOut(data, clock, MSBFIRST, value); //Shifts out the 8 bits to the shift register
digitalWrite(latch, HIGH); //Pulls the latch high displaying the data
}
/*
* updateLEDsLong() - sends the LED states set in ledStates to the 74HC595
* sequence. Same as updateLEDs except the shifting out is done in software
* so you can see what is happening.
*/
void updateLEDsLong(int value){
digitalWrite(latch, LOW); //Pulls the chips latch low
for(int i = 0; i < 8; i++){ //Will repeat 8 times (once for each bit)
int bit = value & B10000000; //We use a "bitmask" to select only the eighth
//bit in our number (the one we are addressing this time through
value = value << 1; //we move our number up one bit value so next time bit 7 will be
//bit 8 and we will do our math on it
if(bit == 128){digitalWrite(data, HIGH);} //if bit 8 is set then set our data pin high
else{digitalWrite(data, LOW);} //if bit 8 is unset then set the data pin low
digitalWrite(clock, HIGH); //the next three lines pulse the clock pin
delay(1);
digitalWrite(clock, LOW);
}
digitalWrite(latch, HIGH); //pulls the latch high shifting our data into being displayed
}
//These are used in the bitwise math that we use to change individual LEDs
//For more details http://en.wikipedia.org/wiki/Bitwise_operation
int bits[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000};
int masks[] = {B11111110, B11111101, B11111011, B11110111, B11101111, B11011111, B10111111, B01111111};
/*
* changeLED(int led, int state) - changes an individual LED
* LEDs are 0 to 7 and state is either 0 - OFF or 1 - ON
*/
void changeLED(int led, int state){
ledState = ledState & masks[led]; //clears ledState of the bit we are addressing
if(state == ON){ledState = ledState | bits[led];} //if the bit is on we will add it to ledState
updateLEDs(ledState); //send the new LED state to the shift register
}