neale
/
Simon-Says
mirror of https://github.com/nealey/Simon-Says
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Lots of porting to Arduino functions and standards.

This commit is contained in:
Nathan Seidle 2012-12-28 21:49:19 -07:00
parent 172c744f28
commit a9b242e9b6
2 changed files with 296 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

491
Firmware/Simon_Says/Simon_Says.ino
View File

@ -44,31 +44,134 @@
#include "hardware_versions.h" #include "hardware_versions.h"
// Define game parameters // Define game parameters
#define MOVES_TO_WIN 13 #define MOVES_TO_WIN 13 //Number of rounds to succesfully remember before you win. 13 is do-able.
#define TIME_LIMIT 3000 //3000ms = 3 sec #define ENTRY_TIME_LIMIT 3000 //Amount of time to press a button before game times out. 3000ms = 3 sec
#define sbi(port_name, pin_number) (port_name |= 1<<pin_number) #define MODE_MEMORY 0
#define cbi(port_name, pin_number) ((port_name) &= (uint8_t)~(1 << pin_number)) #define MODE_BATTLE 1
#define MODE_BEEGEES 2
int battle = 0; int gameMode = MODE_MEMORY; //By default, let's play the memory game
///These ints are for the begees loop funtion to work
int counter = 0; // for cycling through the LEDs during the beegees loop
int count = 20; // for keeping rhythm straight in the beegees loop
//////////////
// Game state variables // Game state variables
uint8_t moves[32]; uint8_t moves[32];
uint8_t nmoves = 0; uint8_t nmoves = 0;
//Timer 2 overflow ISR //Timer 2 overflow ISR
ISR (SIG_OVERFLOW2) /*ISR (SIG_OVERFLOW2)
{ {
// Prescalar of 1024, Clock = 16MHz, 15,625 clicks per second, 64us per click // Prescalar of 1024, Clock = 16MHz, 15,625 clicks per second, 64us per click
// Preload timer 2 for 125 clicks. Should be 8ms per ISR call // Preload timer 2 for 125 clicks. Should be 8ms per ISR call
TCNT2 = 131; //256 - 125 = 131 TCNT2 = 131; //256 - 125 = 131
}*/
void setup()
{
init_gpio();
randomSeed(analogRead(0)); //Seed the random generator with noise on pin A0
/*
//Set Timer 0 Registers to Default Setting to over-ride the timer initialization made in the init() function of the \
//Arduino Wiring library (Wiring.c in the hardware/core/arduino folder)
TCCR0A = 0;
TIMSK0 = 0;
// Init timer 0 for delay_us timing (1,000,000 / 1 = 1,000,000)
//TCCR0B = (1<<CS00); // Set Prescaler to 1. CS00=1
TCCR0B = (1<<CS01); // Set Prescaler to 1. CS00=1
// Init timer 2
ASSR = 0;
// Set Prescaler to 1024. CS22=1, CS21=1, CS20=1
TCCR2B = (1<<CS22)|(1<<CS21)|(1<<CS20);
TIMSK2 = (1<<TOIE2); // Enable Timer 2 Interrupt
cli(); //We don't use any interrupt functionality. Let's turn it off so Arduino doesn't screw around with it!
*/
Serial.begin(9600);
Serial.println("Welcome to Simon Says!");
/*
//Mode checking
// Check to see if the lower right button is pressed
if (checkButton() == CHOICE_YELLOW)
{
gameMode = MODE_BEEGEES;
//Turn on the yellow LED
setLEDs(CHOICE_YELLOW);
while(checkButton() != CHOICE_NONE) ; //Wait for user to stop pressing button
delay(100);
while(checkButton() == CHOICE_NONE)
{
//buzz(5);
//delay(750);
//if (checkButton() == CHOICE_NONE)
//{
//while (1)
playBeegees();
//}
} }
}
// Check to see if LOWER RIGHT BUTTON is pressed
if (checkButton() == CHOICE_GREEN)
{
gameMode = MODE_BATTLE;
//Turn on the green LED
setLEDs(CHOICE_GREEN);
while(checkButton() != CHOICE_NONE) ; //Wait for user to stop pressing button
//Now do nothing. Battle mode will be serviced in the main routine
/*delay(100);
while(1)
{
buzz(5);
delay(750);
if (checkButton() == CHOICE_NONE){
battle = 1;
break;
}
}
*/
//}
play_winner();
}
void loop()
{
// Wait for user to start game
attractMode();
// Indicate the start of game play
setLEDs(CHOICE_RED|CHOICE_GREEN|CHOICE_BLUE|CHOICE_YELLOW);
delay(1000);
setLEDs(CHOICE_OFF);
delay(250);
// Play game and handle result
if (game_mode() != 0)
{
// Player won, play winner tones
play_winner();
}
else
{
// Player lost, play loser tones
play_loser();
}
}
//General short delays, using internal timer do a fairly accurate 1us //General short delays, using internal timer do a fairly accurate 1us
#ifdef CHIP_ATMEGA168 #ifdef CHIP_ATMEGA168
@ -93,41 +196,29 @@ void delay_us(uint16_t delay)
} }
#endif #endif
//General short delays //Lights a given LEDs
void delay_ms(uint16_t x) //Pass in a byte that is made up from CHOICE_RED, CHOICE_YELLOW, etc
void setLEDs(byte leds)
{ {
while (x-- > 0) { if ((leds & CHOICE_RED) != 0)
delay_us(1000); digitalWrite(LED_RED, HIGH);
} else
} digitalWrite(LED_RED, LOW);
//Light the given set of LEDs if ((leds & CHOICE_GREEN) != 0)
void set_leds(uint8_t leds) digitalWrite(LED_GREEN, HIGH);
{ else
if ((leds & LED_RED) != 0) { digitalWrite(LED_GREEN, LOW);
sbi(LED_RED_PORT, LED_RED_PIN);
} if ((leds & CHOICE_BLUE) != 0)
else { digitalWrite(LED_BLUE, HIGH);
cbi(LED_RED_PORT, LED_RED_PIN); else
} digitalWrite(LED_BLUE, LOW);
if ((leds & LED_GREEN) != 0) {
sbi(LED_GREEN_PORT, LED_GREEN_PIN); if ((leds & CHOICE_YELLOW) != 0)
} digitalWrite(LED_YELLOW, HIGH);
else { else
cbi(LED_GREEN_PORT, LED_GREEN_PIN); digitalWrite(LED_YELLOW, LOW);
}
if ((leds & LED_BLUE) != 0) {
sbi(LED_BLUE_PORT, LED_BLUE_PIN);
}
else {
cbi(LED_BLUE_PORT, LED_BLUE_PIN);
}
if ((leds & LED_YELLOW) != 0) {
sbi(LED_YELLOW_PORT, LED_YELLOW_PIN);
}
else {
cbi(LED_YELLOW_PORT, LED_YELLOW_PIN);
}
} }
@ -159,88 +250,70 @@ void init_gpio(void)
#ifdef BOARD_REV_PTH #ifdef BOARD_REV_PTH
void init_gpio(void) void init_gpio(void)
{ {
// 1 = output, 0 = input //Enable pull ups on inputs
DDRB = 0b11101101; // LEDs and Buttons pinMode(BUTTON_RED, INPUT_PULLUP);
DDRC = 0b11111111; // LEDs and Buttons pinMode(BUTTON_GREEN, INPUT_PULLUP);
DDRD = 0b10111011; // LEDs, buttons, buzzer, TX/RX pinMode(BUTTON_BLUE, INPUT_PULLUP);
pinMode(BUTTON_YELLOW, INPUT_PULLUP);
PORTB = 0b00010010; // Enable pull-ups on buttons 1, 4 pinMode(LED_RED, OUTPUT);
//PORTC = 0b00100110; // Enable pull-ups on buttons 0, 2, 3 pinMode(LED_GREEN, OUTPUT);
PORTD = 0b01000100; // Enable pull-up on button 1 pinMode(LED_BLUE, OUTPUT);
pinMode(LED_YELLOW, OUTPUT);
pinMode(BUZZER1, OUTPUT);
pinMode(BUZZER2, OUTPUT);
} }
#endif #endif // End BOARD_REV_PTH
void ioinit(void) // Returns a '1' bit in the position corresponding to CHOICE_RED, CHOICE_GREEN, etc.
byte checkButton(void)
{ {
init_gpio(); byte buttonPressed = CHOICE_NONE;
//Set Timer 0 Registers to Default Setting to over-ride the timer initialization made in the init() function of the \ if (digitalRead(BUTTON_RED) == 0) buttonPressed |= CHOICE_RED;
//Arduino Wiring library (Wiring.c in the hardware/core/arduino folder) if (digitalRead(BUTTON_GREEN) == 0) buttonPressed |= CHOICE_GREEN;
TCCR0A = 0; if (digitalRead(BUTTON_BLUE) == 0) buttonPressed |= CHOICE_BLUE;
TIMSK0 = 0; if (digitalRead(BUTTON_YELLOW) == 0) buttonPressed |= CHOICE_YELLOW;
// Init timer 0 for delay_us timing (1,000,000 / 1 = 1,000,000)
//TCCR0B = (1<<CS00); // Set Prescaler to 1. CS00=1
TCCR0B = (1<<CS01); // Set Prescaler to 1. CS00=1
// Init timer 2 return buttonPressed;
ASSR = 0;
// Set Prescaler to 1024. CS22=1, CS21=1, CS20=1
TCCR2B = (1<<CS22)|(1<<CS21)|(1<<CS20);
TIMSK2 = (1<<TOIE2); // Enable Timer 2 Interrupt
cli(); //We don't use any interrupt functionality. Let's turn it off so Arduino doesn't screw around with it!
}
// Returns a '1' bit in the position corresponding to LED_RED, etc.
uint8_t check_button(void)
{
uint8_t button_pressed = 0;
if ((BUTTON_RED_PORT & (1 << BUTTON_RED_PIN)) == 0)
button_pressed |= LED_RED;
if ((BUTTON_GREEN_PORT & (1 << BUTTON_GREEN_PIN)) == 0)
button_pressed |= LED_GREEN;
if ((BUTTON_BLUE_PORT & (1 << BUTTON_BLUE_PIN)) == 0)
button_pressed |= LED_BLUE;
if ((BUTTON_YELLOW_PORT & (1 << BUTTON_YELLOW_PIN)) == 0)
button_pressed |= LED_YELLOW;
return button_pressed;
} }
// Play the loser sound/lights // Play the loser sound/lights
void play_loser(void) void play_loser(void)
{ {
set_leds(LED_RED|LED_GREEN); setLEDs(CHOICE_RED|CHOICE_GREEN);
buzz_sound(255, 1500); buzz_sound(255, 1500);
set_leds(LED_BLUE|LED_YELLOW); setLEDs(CHOICE_BLUE|CHOICE_YELLOW);
buzz_sound(255, 1500); buzz_sound(255, 1500);
set_leds(LED_RED|LED_GREEN); setLEDs(CHOICE_RED|CHOICE_GREEN);
buzz_sound(255, 1500); buzz_sound(255, 1500);
set_leds(LED_BLUE|LED_YELLOW); setLEDs(CHOICE_BLUE|CHOICE_YELLOW);
buzz_sound(255, 1500); buzz_sound(255, 1500);
} }
// Play the winner sound // Play the winner sound
void winner_sound(void) void winner_sound(void)
{ {
uint8_t x, y; byte x, y;
// Toggle the buzzer at various speeds // Toggle the buzzer at various speeds
for (x = 250 ; x > 70 ; x--) { for (x = 250 ; x > 70 ; x--) {
for (y = 0 ; y < 3 ; y++) { for (y = 0 ; y < 3 ; y++) {
sbi(BUZZER2_PORT, BUZZER2); //sbi(BUZZER2_PORT, BUZZER2);
cbi(BUZZER1_PORT, BUZZER1); //cbi(BUZZER1_PORT, BUZZER1);
digitalWrite(BUZZER2, HIGH);
digitalWrite(BUZZER1, LOW);
delayMicroseconds(x);
delay_us(x); //cbi(BUZZER2_PORT, BUZZER2);
//sbi(BUZZER1_PORT, BUZZER1);
cbi(BUZZER2_PORT, BUZZER2); digitalWrite(BUZZER2, LOW);
sbi(BUZZER1_PORT, BUZZER1); digitalWrite(BUZZER1, HIGH);
delayMicroseconds(x);
delay_us(x);
} }
} }
} }
@ -248,36 +321,33 @@ void winner_sound(void)
// Play the winner sound and lights // Play the winner sound and lights
void play_winner(void) void play_winner(void)
{ {
set_leds(LED_GREEN|LED_BLUE); setLEDs(CHOICE_GREEN|CHOICE_BLUE);
winner_sound(); winner_sound();
set_leds(LED_RED|LED_YELLOW); setLEDs(CHOICE_RED|CHOICE_YELLOW);
winner_sound(); winner_sound();
set_leds(LED_GREEN|LED_BLUE); setLEDs(CHOICE_GREEN|CHOICE_BLUE);
winner_sound(); winner_sound();
set_leds(LED_RED|LED_YELLOW); setLEDs(CHOICE_RED|CHOICE_YELLOW);
winner_sound(); winner_sound();
} }
// Plays the current contents of the game moves // Plays the current contents of the game moves
void play_moves(void) void play_moves(void)
{ {
uint8_t move; byte currentMove;
for (move = 0; move < nmoves; move++) { for (currentMove = 0 ; currentMove < nmoves ; currentMove++)
toner(moves[move], 150); {
delay_ms(150); toner(moves[currentMove], 150);
delay(150);
} }
} }
// Adds a new random button to the game sequence, by sampling the timer // Adds a new random button to the game sequence, by sampling the timer
void add_to_moves(void) void add_to_moves(void)
{ {
uint8_t new_button; byte newButton = random(0, 3);
moves[nmoves++] = newButton; //Add this new button to the game array
// Use the lower 2 bits of the timer for the random value
new_button = 1 << (TCNT2 & 0x3);
moves[nmoves++] = new_button;
} }
// Adds a user defined button to the game sequence, by waiting for their input // Adds a user defined button to the game sequence, by waiting for their input
@ -294,6 +364,7 @@ void add_to_moves_battle(void)
} }
// Toggle buzzer every buzz_delay_us, for a duration of buzz_length_ms. // Toggle buzzer every buzz_delay_us, for a duration of buzz_length_ms.
//Given a length and a
void buzz_sound(uint16_t buzz_length_ms, uint16_t buzz_delay_us) void buzz_sound(uint16_t buzz_length_ms, uint16_t buzz_delay_us)
{ {
uint32_t buzz_length_us; uint32_t buzz_length_us;
@ -303,13 +374,18 @@ void buzz_sound(uint16_t buzz_length_ms, uint16_t buzz_delay_us)
buzz_length_us -= buzz_delay_us*2; buzz_length_us -= buzz_delay_us*2;
// Toggle the buzzer at various speeds // Toggle the buzzer at various speeds
cbi(BUZZER1_PORT, BUZZER1); //cbi(BUZZER1_PORT, BUZZER1);
sbi(BUZZER2_PORT, BUZZER2); //sbi(BUZZER2_PORT, BUZZER2);
delay_us(buzz_delay_us); digitalWrite(BUZZER1, LOW);
digitalWrite(BUZZER2, HIGH);
// delay_us(buzz_delay_us);
delayMicroseconds(buzz_delay_us);
sbi(BUZZER1_PORT, BUZZER1); //sbi(BUZZER1_PORT, BUZZER1);
cbi(BUZZER2_PORT, BUZZER2); //cbi(BUZZER2_PORT, BUZZER2);
delay_us(buzz_delay_us); digitalWrite(BUZZER1, HIGH);
digitalWrite(BUZZER2, LOW);
delayMicroseconds(buzz_delay_us);
} }
} }
@ -322,52 +398,53 @@ void buzz_sound(uint16_t buzz_length_ms, uint16_t buzz_delay_us)
*/ */
void toner(uint8_t which, uint16_t buzz_length_ms) void toner(uint8_t which, uint16_t buzz_length_ms)
{ {
set_leds(which); setLEDs(which);
switch (which) { switch (which) {
case LED_RED: case CHOICE_RED:
buzz_sound(buzz_length_ms, 1136); // buzz_sound(buzz_length_ms, 1136);
tone(BUZZER1, 440, buzz_length_ms);
break; break;
case LED_GREEN: case CHOICE_GREEN:
buzz_sound(buzz_length_ms, 568); // buzz_sound(buzz_length_ms, 568);
tone(BUZZER1, 880, buzz_length_ms);
break; break;
case LED_BLUE: case CHOICE_BLUE:
buzz_sound(buzz_length_ms, 851); // buzz_sound(buzz_length_ms, 851);
tone(BUZZER1, 587, buzz_length_ms);
break; break;
case LED_YELLOW: case CHOICE_YELLOW:
buzz_sound(buzz_length_ms, 638); // buzz_sound(buzz_length_ms, 638);
tone(BUZZER1, 784, buzz_length_ms);
break; break;
} }
// Turn off all LEDs // Turn off all LEDs
set_leds(0); setLEDs(CHOICE_OFF);
} }
// Show an "attract mode" display while waiting for user to press button. // Show an "attract mode" display while waiting for user to press button.
void attract_mode(void) void attractMode(void)
{ {
while (1) { while(1)
set_leds(LED_RED); {
delay_ms(100); setLEDs(CHOICE_RED);
if (check_button() != 0x00) delay(100);
return; if (checkButton() != CHOICE_NONE) return;
set_leds(LED_BLUE); setLEDs(CHOICE_BLUE);
delay_ms(100); delay(100);
if (check_button() != 0x00) if (checkButton() != CHOICE_NONE) return;
return;
set_leds(LED_GREEN); setLEDs(CHOICE_GREEN);
delay_ms(100); delay(100);
if (check_button() != 0x00) if (checkButton() != CHOICE_NONE) return;
return;
set_leds(LED_YELLOW); setLEDs(CHOICE_YELLOW);
delay_ms(100); delay(100);
if (check_button() != 0x00) if (checkButton() != CHOICE_NONE) return;
return;
} }
} }
@ -375,7 +452,7 @@ void attract_mode(void)
// Returns one of led colors (LED_RED, etc.) if successful, 0 if timed out // Returns one of led colors (LED_RED, etc.) if successful, 0 if timed out
uint8_t wait_for_button(void) uint8_t wait_for_button(void)
{ {
uint16_t time_limit = TIME_LIMIT; uint16_t time_limit = ENTRY_TIME_LIMIT;
uint8_t released = 0; uint8_t released = 0;
uint8_t old_button; uint8_t old_button;
@ -384,22 +461,22 @@ uint8_t wait_for_button(void)
// Implement a small bit of debouncing // Implement a small bit of debouncing
old_button = button; old_button = button;
button = check_button(); button = checkButton();
// Make sure we've seen the previous button released before accepting new buttons // Make sure we've seen the previous button released before accepting new buttons
if (button == 0) if (button == CHOICE_NONE)
released = 1; released = 1;
if (button == old_button && released == 1) { if (button == old_button && released == 1) {
// Make sure just one button is pressed // Make sure just one button is pressed
if (button == LED_RED || if (button == CHOICE_RED ||
button == LED_BLUE || button == CHOICE_BLUE ||
button == LED_GREEN || button == CHOICE_GREEN ||
button == LED_YELLOW) { button == CHOICE_YELLOW) {
return button; return button;
} }
} }
delay_ms(1); delay(1);
time_limit--; time_limit--;
} }
@ -412,26 +489,24 @@ int game_mode(void)
nmoves = 0; nmoves = 0;
int moves_to_win_var = MOVES_TO_WIN; // If in normal mode, then allow the user to win after a #define varialb up top (default is 13). int moves_to_win_var = MOVES_TO_WIN; // If in normal mode, then allow the user to win after a #define varialb up top (default is 13).
if(battle) moves_to_win_var = 1000; // If in battle mode, allow the users to go up to 1000 moves! Like anyone could possibly do that :) if(gameMode == MODE_BATTLE) moves_to_win_var = 1000; // If in battle mode, allow the users to go up to 1000 moves! Like anyone could possibly do that :)
while (nmoves < moves_to_win_var) while (nmoves < moves_to_win_var)
{ {
uint8_t move;
// Add a button to the current moves, then play them back // Add a button to the current moves, then play them back
if(battle) if(gameMode == MODE_BATTLE)
add_to_moves_battle(); // If in battle mode, then listen for user input to choose the next step add_to_moves_battle(); // If in battle mode, then listen for user input to choose the next step
else else
add_to_moves(); add_to_moves();
if(battle) if(gameMode == MODE_BATTLE)
; // If in battle mode, then don't play back the pattern, it's up the the users to remember it - then add on a move. ; // If in battle mode, then don't play back the pattern, it's up the the users to remember it - then add on a move.
else else
play_moves(); play_moves();
// Then require the player to repeat the sequence. // Then require the player to repeat the sequence.
for (move = 0; move < nmoves; move++) { for (byte currentMove = 0 ; currentMove < nmoves ; currentMove++) {
uint8_t choice = wait_for_button(); byte choice = wait_for_button();
// If wait timed out, player loses. // If wait timed out, player loses.
if (choice == 0) if (choice == 0)
@ -440,88 +515,34 @@ int game_mode(void)
toner(choice, 150); toner(choice, 150);
// If the choice is incorect, player loses. // If the choice is incorect, player loses.
if (choice != moves[move]) { if (choice != moves[currentMove]) {
return 0; return 0;
} }
} }
// Player was correct, delay before playing moves // Player was correct, delay before playing moves
if(battle) if(gameMode == MODE_BATTLE)
{ {
//reduced wait time, because we want to allow the battle to go very fast! //reduced wait time, because we want to allow the battle to go very fast!
//plus, if you use the delay(1000), then it may miss capturing the users next input. //plus, if you use the delay(1000), then it may miss capturing the users next input.
delay_ms(100); delay(100);
} }
else else
delay_ms(1000); delay(1000);
} }
// Player wins! // Player wins!
return 1; return 1;
} }
void setup()
{
}
void loop()
{
// Setup IO pins and defaults
ioinit();
// Check to see if LOWER LEFT BUTTON is pressed
if (check_button() == LED_YELLOW){
while(1){
buzz(5);
delay_ms(750);
if (check_button() == 0x00){
while (1) beegees_loop();
}
}
}
// Check to see if LOWER RIGHT BUTTON is pressed
if (check_button() == LED_GREEN){
while(1){
buzz(5);
delay_ms(750);
if (check_button() == 0x00){
battle = 1;
break;
}
}
}
play_winner();
// Main loop
while (1) {
// Wait for user to start game
attract_mode();
// Indicate the start of game play
set_leds(LED_RED|LED_GREEN|LED_BLUE|LED_YELLOW);
delay_ms(1000);
set_leds(0);
delay_ms(250);
// Play game and handle result
if (game_mode() != 0) {
// Player won, play winner tones
play_winner();
}
else {
// Player lost, play loser tones
play_loser();
}
}
}
//These ints are for the begees loop funtion to work
int counter = 0; // for cycling through the LEDs during the beegees loop
int count = 20; // for keeping rhythm straight in the beegees loop
// //
void beegees_loop()
//playBeegees() does nothing but play bad beegees music
void playBeegees()
{ {
buzz(3); buzz(3);
delay(400); delay(400);
@ -596,15 +617,17 @@ void buzz(int tone){
count = count * (2000/freq); count = count * (2000/freq);
// this next function simply changes the next LED to turn on. // this next function simply changes the next LED to turn on.
change_led(); changeLED();
// this next for loop actually makes the buzzer pin move. // this next for loop actually makes the buzzer pin move.
// it uses the "count" variable to know how many times to play the frequency. // it uses the "count" variable to know how many times to play the frequency.
// -this keeps the timing correct. // -this keeps the timing correct.
for(int i = 0; i < count; i++){ for(int i = 0 ; i < count ; i++)
{
digitalWrite(BUZZER1, HIGH); digitalWrite(BUZZER1, HIGH);
digitalWrite(BUZZER2, LOW); digitalWrite(BUZZER2, LOW);
delayMicroseconds(freq); delayMicroseconds(freq);
digitalWrite(BUZZER1, LOW); digitalWrite(BUZZER1, LOW);
digitalWrite(BUZZER2, HIGH); digitalWrite(BUZZER2, HIGH);
delayMicroseconds(freq); delayMicroseconds(freq);
@ -631,6 +654,7 @@ void rest(int tone){
freq = 1110; freq = 1110;
} }
//freq = (freq/2); //freq = (freq/2);
count = 40; count = 40;
count = count * (2000/freq); count = count * (2000/freq);
//change_led(); //change_led();
@ -646,15 +670,10 @@ void rest(int tone){
} }
// //
void change_led() void changeLED()
{ {
if(counter > 3) setLEDs(1 << counter);
{
counter = 0;
}
set_leds(1 << counter);
counter += 1; counter += 1;
if(counter > 3) counter = 0;
} }

58
Firmware/Simon_Says/hardware_versions.h
View File

@ -6,6 +6,14 @@
file attempts to map and support all the different hardware versions. file attempts to map and support all the different hardware versions.
*/ */
#define CHOICE_OFF 0 //Used to control LEDs
#define CHOICE_NONE 0 //Used to check buttons
#define CHOICE_RED (1 << 0)
#define CHOICE_GREEN (1 << 1)
#define CHOICE_BLUE (1 << 2)
#define CHOICE_YELLOW (1 << 3)
// Uncomment one of the following, corresponding to the board you have. // Uncomment one of the following, corresponding to the board you have.
//#define BOARD_REV_6_25_08 //#define BOARD_REV_6_25_08
//#define BOARD_REV_4_9_2009 //#define BOARD_REV_4_9_2009
@ -15,38 +23,36 @@
#define CHIP_ATMEGA168 #define CHIP_ATMEGA168
#define LED_RED (1 << 0) // LED pin definitions, these are Arduino pins, not ATmega pins
#define LED_GREEN (1 << 1) #define LED_RED 10
#define LED_BLUE (1 << 2) #define LED_GREEN 3
#define LED_YELLOW (1 << 3) #define LED_BLUE 13
#define LED_YELLOW 5
/* LED pin definitions */ //#define LED_RED_PORT PORTB
#define LED_RED_PIN 2 //#define LED_GREEN_PORT PORTD
#define LED_RED_PORT PORTB //#define LED_BLUE_PORT PORTB
#define LED_GREEN_PIN 3 //#define LED_YELLOW_PORT PORTD
#define LED_GREEN_PORT PORTD
#define LED_BLUE_PIN 5
#define LED_BLUE_PORT PORTB
#define LED_YELLOW_PIN 5
#define LED_YELLOW_PORT PORTD
/* Button pin definitions */ // Button pin definitions
#define BUTTON_RED_PIN 1 #define BUTTON_RED 9
#define BUTTON_RED_PORT PINB #define BUTTON_GREEN 2
#define BUTTON_GREEN_PIN 2 #define BUTTON_BLUE 12
#define BUTTON_GREEN_PORT PIND #define BUTTON_YELLOW 6
#define BUTTON_BLUE_PIN 4
#define BUTTON_BLUE_PORT PINB
#define BUTTON_YELLOW_PIN 6
#define BUTTON_YELLOW_PORT PIND
/* Buzzer pin definitions */ //#define BUTTON_RED_PORT PINB
//#define BUTTON_GREEN_PORT PIND
//#define BUTTON_BLUE_PORT PINB
//#define BUTTON_YELLOW_PORT PIND
// Buzzer pin definitions
#define BUZZER1 4 #define BUZZER1 4
#define BUZZER1_PORT PORTD
#define BUZZER2 7 #define BUZZER2 7
#define BUZZER2_PORT PORTD
#endif /* BOARD_REV_PTH */ //#define BUZZER1_PORT PORTD
//#define BUZZER2_PORT PORTD
#endif // End definition for BOARD_REV_PTH
#ifdef BOARD_REV_6_25_08 #ifdef BOARD_REV_6_25_08