AVR Freaks

#define F_CPU 1000000UL

#include 
#include 
#include 
#include 

#define ShiftPort 	PORTD
#define ShiftDDR	DDRD
#define LatchPin	(1 << 5)
#define ClkPin		(1 << 6)
#define DataPin		(1 << 4)
#define ccPort		PORTD
#define ccDDR		DDRD
#define ccPin0		(1 << 1)
#define ccPin1		(1 << 0)
//Debounce definitions
#define KEY_DDR 	DDRD
#define KEY_PIN 	PIND
#define KEY_PORT 	PORTD
#define BTN1 		3
#define KEY_MSK 	(1 << BTN1)

typedef unsigned char u8; //now we can type "u8" instead of "unsigned char" (saves time and headaches)

const u8 numerals[] PROGMEM = {
    0xFC, //0b11111100 = 0
    0x60, //0b01100000 = 1
    0xDA, //0b11011010 = 2
    0xF2, //0b11110010 = 3
    0x66, //0b01100110 = 4
    0xB6, //0b10110110 = 5
    0xBE, //0b10111110 = 6
    0xE0, //0b11100000 = 7
    0xFE, //0b11111110 = 8
    0xF6, //0b11110110 = 9
    0xEE, //0b11101110 = A
    0x3E, //0b00111110 = b
    0x9C, //0b10011100 = C
    0x7A, //0b01111010 = d
    0x9E, //0b10011110 = E
    0x8E, //0b10001110 = F
};

PGM_P numerals_p PROGMEM = numerals;

volatile u8 digit_ones = 0x00;
volatile u8 digit_tens = 0x00;

//Debouce variables
unsigned char debounce_cnt = 0;
volatile unsigned char key_press;
unsigned char key_state;

/*void Delay_ms(int cnt) {
	while (cnt-->0) {
		_delay_ms(1);
	}
}*/

//### InitPorts function ###
//Initializes the ports needed to operate the shift register and button
//##########################
void InitPorts(void) 
{
  ShiftDDR |= (LatchPin | ClkPin | DataPin);
  ShiftPort &= (~LatchPin & ~ClkPin & ~DataPin);  //Set LatchPin, ClkPin and DataPin low

  ccDDR |= (ccPin0 | ccPin1);
  ccPort &= (~ccPin1); //Set ccPin1 low
  ccPort |= (ccPin0);  //Set ccPin0 high

  KEY_DDR &= ~KEY_MSK; //Set Key pins as inputs
  KEY_PORT |= KEY_MSK; //Enable internal pull-up resistor for Key pins
}


void InitTimers(void)
{
  TCCR0B |= (1<<CS01);
  TIMSK |= (1<<TOIE0);
  sei();
}

//### ShiftOut function ###
//Shifts the data passed to it out to the shift register
//#########################
void ShiftOut(u8 shiftData)
{
  ShiftPort &= (~LatchPin & ~ClkPin & ~DataPin);  	//All pins low: LatchPin low signals a write operation
  for (char i=0; i<8; i++)				//Loop through all 8 bits
  {
    ShiftPort &= ~ClkPin;				//Set ClkPin low
    if (shiftData & (1<<i)) ShiftPort |= DataPin;	//Set DataPin high if current bit is 1
    else ShiftPort &= ~DataPin;				//Set DataPin low if current bit is 0
    ShiftPort |= ClkPin;				//Set ClkPin high to increment shift register
  }
  ShiftPort |= LatchPin;  				//Set LatchPin high to signal end of write operation
}

void display_hex(u8 n) {
  digit_tens = pgm_read_byte(numerals_p + (n/16));
  digit_ones = pgm_read_byte(numerals_p + (n%16));
}

unsigned char get_key_press(unsigned char key_mask)
{
  cli();               // read and clear atomic !
  key_mask &= key_press;                        // read key(s)
  key_press ^= key_mask;                        // clear key(s)
  sei();
  return key_mask;
}

int main(void) {
  InitPorts();
  InitTimers();

  //State machine variables
  u8 loop_count = 0;
  u8 current_state = 3;
  u8 event_count = 0;
  u8 this_state_status = 0;

  while(1) {  
    //Button Debounce
    //This is the famous "danni debounce" code used with get_key_press function above.
    //It was written by Peter Dannegger: danni@specs.de
    static unsigned char ct0, ct1;
    unsigned char i;

    debounce_cnt = 0;

    i = key_state ^ ~KEY_PIN;    // key changed ?
    ct0 = ~( ct0 & i );          // reset or count ct0
    ct1 = ct0 ^ (ct1 & i);       // reset or count ct1
    i &= ct0 & ct1;              // count until roll over ?
    key_state ^= i;              // then toggle debounced state
    key_press |= key_state & i;  // 0->1: key press detect
    //end of danni debounce code

    //Get button read
    if( get_key_press( 1<<BTN1 ))
    {
      //Do stuff
      loop_count = 0;
      event_count = 0;
      if (++current_state > 3) current_state = 1;
    }

    //State Machine Follows
    //TODO:  Add a reset state function
    
    //State 0 - Do nothing

    //State 1 - Chase outer ring of display
    if (current_state == 1)
    {
      //Is this the first time through?
      if ((loop_count==0) && (event_count==0)) {
        //Setup the first frame and reset loop_count
        digit_tens = 0x80;
        digit_ones = 0x80;
      } else if (loop_count >= 5) {
        //Shift the digit buffers
        digit_ones >>= 1;
        digit_tens <<= 1;
        //reset loop_count
        loop_count = 0;
      
      
        //Have the digit buffers overflowed our pattern?
        if (digit_ones < 4) {
          //increment the event_count, we've complete 1 cycle
          ++event_count;
          //Setup the first frame and 
          digit_ones = 0x80;
        }
        if (digit_tens == 0) digit_tens = 0x04;

        //Is event_count larger than it should be
        if (event_count > 4) {
          //TODO Reset state machine
        }
      }
      //Increment loop_count
      ++loop_count;
    }

    //State 2 - Count up
    if (current_state == 2) {
      ++current_state; //Advance to next state becuase this one is empty right now
      //TODO: Make this state do something
      //Check to see how many state loops have passed
        //Increment counter if it is time to do so
    }

    //State 3 - Count up in hex
    if (current_state == 3) {
      //Initial setup
      if (event_count == 0) {
        display_hex(event_count++);
      }  
      else if (loop_count >= 20) {
        loop_count = 0;

        //if we counted too far
        if (event_count == 0xFF) {
          current_state = 1;
          event_count = 0;
          loop_count = -1;
        }
        else {
          display_hex(event_count++);
        }
      }
      ++loop_count;  
    }
    //State etc...

    
    _delay_ms(10);  //TODO: Transition to using an interrupt driven counter instead of this delay.

  }
}

//This ISR handles the scanning of the multiplexed display
ISR(TIMER0_OVF_vect)
{
  u8 temp_cc = (ccPort & (ccPin0 | ccPin1)); //Store common cathode setting
  ccPort |= (ccPin0 | ccPin1);  //Set both cathodes high (off)
  //If the 'ones' cathode was just on
  if (temp_cc & ccPin1) {
    ShiftOut(digit_tens);	//Shift out 'tens' data
    ccPort &= ~(ccPin1);	//Set 'tens' cathode low
  }
  //Otherwise 'tens' cathode was just low
  else 
  {
    ShiftOut(digit_ones);	//Shift out 'ones' data
    ccPort &= ~(ccPin0);	//Set 'ones' cathode low
  }
}