AVRFreaks.net

#define F_CPU 20000000UL // 20 MHz

for(int i=0; i<10 i++)
         for(int j=0; j<10 j++)
             for(int k=0; k<10 k++)   
                cin>>pin[i][j][k];

// If clock speed isn't set in the project settings then it is set here
#ifndef F_CPU
    #define F_CPU    3686400UL //20000000UL  20 MHz
#endif
 
// Include some useful libraries
#include <stdlib.h>
#include <avr/io.h>
#include <util/delay.h>
 
 
/*
 * These constants are used to control overall game state
 * We could just use numbers instead, but this is far cleaner
 */
#define STATE_STARTUP 0x01
#define STATE_BEGIN 0x02
#define STATE_DISPLAY 0x04
#define STATE_INPUT 0x08
 
 
/*
 * These variables are used for game state management
 */
unsigned int patternLength = 3; // the length of the starting pattern
unsigned int patternDelay = 60; // how long each light is shown for (ebala to const)
unsigned int patternInterval = 10; // how long between each light   (ebala to const)
unsigned int* pattern; // a pointer to an array to hold the pattern
unsigned int* input; // a pointer to an array to hold user input
unsigned int inputPos = 0; // the pattern position expected next
unsigned int inputStarted = 0; // 0/1 value to indicate whether input has started
 
unsigned int currentLevel = 1; // Level counter (used for multiplier calculations)
unsigned int currentState = STATE_STARTUP; // The default state
unsigned int timerExceeded = 0; // A counter
 
unsigned int waitingPin = 0; // A variable to track the 'chaser' effect pin
 
unsigned int pins[8]; // An array to hold the pin bits (see initPins())
 
 
/*
 * These constants control game behaviour and timing
 *
 * They can safely be changed without breaking the program,
 * though it may become unplayable if extreme values are chosen.
 */
#define DECREASE_DELAY_MULTIPLIER 1 // Decrease delay every n levels
#define DECREASE_DELAY_AMOUNT 1 // Amount to decrease by
#define INCREASE_LENGTH_MULTIPLIER 3 // Increase pattern length every n levels
#define INCREASE_LENGTH_AMOUNT 1 // Amount to increase by
 
#define HIGH_PRECISION_COUNTER_LIMIT 50000
#define LOW_PRECISION_COUNTER_FAIL_ON_NO_INPUT 20
#define LOW_PRECISION_COUNTER_FAIL_ON_INPUT_THEN_TIMEOUT 100
 
void mydelay_ms(int n) {
  while(n--) {
   _delay_ms(1);
  }
}
 
void dellms(void){
 mydelay_ms(1);
 }


// Initialise the array of pins
void initPins()
{
    /*
        These are already defined elsewhere but for this program
        it's easier if we keep the values in an array
    */
    pins[0] = 0x01; // 1
    pins[1] = 0x02; // 2
    pins[2] = 0x04; // 4
    pins[3] = 0x08; // 8
    pins[4] = 0x10; // 16
    pins[5] = 0x20; // 32
    pins[6] = 0x40; // 64
    pins[7] = 0x80; // 128
}
 
// Flashes all 8 LEDs for ms duration and repeat times
void flashAll(int ms, int repeat ) 
{
    int i;
    for( i = 0; i < repeat; i++ )
    {
        // Switch on all PORTB pins
        PORTB = 0x00;
//while (ms--){
//dellms();
//}
        mydelay_ms(ms);
        // And switch them all off again
        PORTB = 0xFF;
//while(ms--){
//dellms();
//}
       mydelay_ms(ms);
    }
}
 
// Flashes 4 LEDs (alternating nibbles) for ms duration and repeat times
void flashAlt(int const ms, int const repeat)  //edv ekana allagh prosthesa ta 2 const
{
    int i;
    for( i = 0; i < repeat; i++ )
    {
        // Switch on only half of the pins
        PORTB = pins[0] + pins[1] + pins[2] + pins[3];
        mydelay_ms(ms);
        // Switch on only the other half
        PORTB = pins[4] + pins[5] + pins[6] + pins[7];
        mydelay_ms(ms);
        // And switch them all off again
        PORTB = 0xFF;
    }
}
 
// Increases the level number and possibly adds to the difficulty
void nextLevel()
{
    currentLevel++;
    if(currentLevel % DECREASE_DELAY_MULTIPLIER == 0) patternDelay -= DECREASE_DELAY_AMOUNT;
    if(currentLevel % INCREASE_LENGTH_MULTIPLIER == 0) patternLength += INCREASE_LENGTH_AMOUNT;
    if(patternDelay < 0) patternDelay = 0;
}
 
// Clear the pattern (generated and user-input)
void resetPattern()
{
    free(pattern);
    free(input);
 
    inputPos = 0;
 
    pattern = NULL;
    input = NULL;
}
 
// Called when the user inputs an incorrect pattern (or on timeout)
void incorrectPattern()
{
    mydelay_ms(50);
    flashAlt(7, 3);
    mydelay_ms(40);
 
    resetPattern();
}
 
// Called when the user inputs the correct pattern
void correctPattern()
{
    mydelay_ms(50);
    flashAll(7, 3);
    mydelay_ms(40);
 
    resetPattern();
    nextLevel();
}
 
// Generates a new pattern
void generatePattern()
{
    int i;
    int LOW = 0;
    int HIGH = 7; 
   
    // Create two arrays of the correct size
    pattern = (unsigned int*) malloc(patternLength*sizeof(unsigned int));
    input = (unsigned int*) malloc(patternLength*sizeof(unsigned int));
 
    // Generate some random numbers
    srand(TCNT1); // TCNT1 is from the timer to create a 'random' seed
    for(i = 0; i < patternLength; i++)
    {
        pattern[i] = rand() % (HIGH - LOW + 1) + LOW;
    }
}
 
// Displays the pattern to the user
void displayPattern()
{
    int i;
 
    PORTB = 0xFF; // clear the display
 
    // A short pause before we start
    mydelay_ms(50);
    // Flash all the pins to indicate pattern start
    flashAll(10, 1);
    mydelay_ms(40);
 
    // Display the pattern
    for(i = 0; i < patternLength; i++)
    {
        PORTB = ~pins[pattern[i]]; // switch on the selected pin
        mydelay_ms(patternDelay);
        PORTB = 0xFF; // switch off all pins
        mydelay_ms(patternInterval);
    }
   
    // Flash all the pins to indicate pattern end
    mydelay_ms(50);
    flashAll(10, 1);
 
    // And another short pause before we end
    /*
        Note: Everyone whose tried it so far cant wait to start
        entering the pattern after the flashAll signal...
        However - including a short delay here seems to distract
        the user as they consciously wait for the chaser
        sequence to start, and so this extra delay unintentionally
        makes the game more difficult.
    */
    mydelay_ms(40);
 
    timerExceeded = 0; // Reset the timer exceeded counter
    inputStarted = 0; // reset the input flag
    waitingPin = 0; // make the chaser restart from the beginning
}
 
void displayChaser()
{
    // Very simple chaser effect:
    // loop through 0-7, switch on the pin, delay
    PORTB = ~pins[waitingPin];
    waitingPin++; if(waitingPin > 7) waitingPin=0;
    mydelay_ms(5);
}
 
/*
 * The main program entry point
 * Note: we must NEVER return from main() - if we do the program
 * will end and the user is forced to reset the board (either
 * by pressing reset or by disconnecting the power supply)
 */
int main(void)
{
    unsigned char i; // A temporary variable to hold the input pin values
   
    initPins(); // Initialise the pin array
 
    // Set all port B pins as output (data direction register B, set bit to 1 for OUTPUT)
    DDRB=0xFF;
    // Set all port D pins as input (data direction register D, set bit to 0 for INPUT)
    // Note: not really required, this is the default
    DDRD=0x00;
 
    // Setup a timer
    TCCR1B |= (1 << CS10); // Sets the CS10 bit (use Fcpu as speed)
 
    // Clear port B (switch off all leds, even though they already should be)
    PORTB = 0xFF;
 
    while(1)
    {
        // Read the current PIND state
        // Note: we're copying it here so even if the user lets go
        // of the button during a delay we don't lose any data
        i = PIND;
 
        switch(currentState) {
            case STATE_STARTUP:
                // Flash a few times to say "hello"
                flashAll(10, 3);
 
                // Wait a moment
                mydelay_ms(50);
 
                // Switch state to begin
                currentState = STATE_BEGIN;
                break;
            case STATE_BEGIN:
                // Check if any of the pins are pressed
                if( i != 0xFF )
                {
                    // Highlight the selected pin - only done here for consistency
                    // since we've done it on the pattern input chaser
                    PORTB = i;
                    // Wait a moment
                    mydelay_ms(40);
                    // Go to Display
                    waitingPin = 0;
                    currentState = STATE_DISPLAY;
                } else {
                    // display the 'waiting' chaser
                    displayChaser();
                }
                break;
            case STATE_DISPLAY:
                // generate and display pattern
                if(pattern == NULL) {
                    generatePattern();
                }
                displayPattern();             
 
                // Go to input state
                currentState = STATE_INPUT;
                TCNT1 = 0; // Set the timer back to 0
                break;
            case STATE_INPUT:
 
                // The timer isn't big enough - we'll use a second counter
                if(TCNT1 >= HIGH_PRECISION_COUNTER_LIMIT) {
                    timerExceeded++;
                    TCNT1 = 0;
                }
                if( (timerExceeded >= LOW_PRECISION_COUNTER_FAIL_ON_NO_INPUT && inputStarted == 0)
                    || timerExceeded >= LOW_PRECISION_COUNTER_FAIL_ON_INPUT_THEN_TIMEOUT ) {
                    // If the second counter reaches determined max we'll force the user to lose
                    incorrectPattern();
                    currentState = STATE_DISPLAY;
                    break;
                }
 
                // Check if any of the pins are pressed
                if( i != 0xFF )
                {
                    // 'Highlight' the selected pin
                    if(inputStarted == 0) inputStarted = 1;
                    PORTB = i;
 
                    // Check if the pin matches the next pin in the pattern
                    if(~i & pins[pattern[inputPos]]) {
                        // The right button was pressed
                        input[inputPos] = pattern[inputPos];
                        inputPos++;
                       
                        if(inputPos >= patternLength) {
                            // The sequence was finished correctly
                            correctPattern();
                            currentState = STATE_DISPLAY;
                            break;
                        }
                    } else {                   
                        // The wrong button was pressed
                        incorrectPattern();
                        currentState = STATE_DISPLAY;
                        break;
                    }
 
                    mydelay_ms(50);
                }
 
                // Display 'waiting' chaser (to show user can press buttons)
                displayChaser();
 
                break;
        }
    }
   
    return 0;
}