#include <avr/io.h>
#define F_CPU 3686400UL    

#include "myavr_lcd.h"     
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <string.h>
#include <stdio.h>

#include <stdint.h>
#include <avr/interrupt.h>

#define Tweiter  !(PINB & (1<<PB5))
#define Tok !(PINB & (1<<PB4))

#define KEY_DDR         DDRB
#define KEY_PORT        PORTB
#define KEY_PIN         PINB
#define KEY0            4
#define KEY1            5
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1)
 
#define REPEAT_MASK     (1<<KEY0 | 1<<KEY1)       // repeat: key1, key2
#define REPEAT_START    50                        // after 500ms
#define REPEAT_NEXT     20                        // every 200ms
 
#define LED_DDR         DDRC
#define LED_PORT        PORTC
#define LED0            0
#define LED1            1
 
volatile uint8_t key_state;                                // debounced and inverted key state:
                                                  // bit = 1: key pressed
volatile uint8_t key_press;                                // key press detect
 
volatile uint8_t key_rpt;                                  // key long press and repeat
 
 
ISR( TIMER0_OVF_vect )                            // every 10ms
{
  static uint8_t ct0, ct1, rpt;
  uint8_t i;
 
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
 
  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
 
  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
     rpt = REPEAT_START;                          // start delay
  if( --rpt == 0 ){
    rpt = REPEAT_NEXT;                            // repeat delay
    key_rpt |= key_state & REPEAT_MASK;
  }
}
 
///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
uint8_t get_key_press( uint8_t 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;
}
 
///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported beeing pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
uint8_t get_key_rpt( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_rpt;                            // read key(s)
  key_rpt ^= key_mask;                            // clear key(s)
  sei();
  return key_mask;
}
 
///////////////////////////////////////////////////////////////////
//
uint8_t get_key_short( uint8_t key_mask )
{
  cli();                                          // read key state and key press atomic !
  return get_key_press( ~key_state & key_mask );
}
 
///////////////////////////////////////////////////////////////////
//
uint8_t get_key_long( uint8_t key_mask )
{
  return get_key_press( get_key_rpt( key_mask ));
}

const char haupt[] PROGMEM = "Hauptmenue      ";
const char ict[] PROGMEM = "1. ICT          ";
const char unidib[] PROGMEM = "2. UniDIB       ";
const char and[] PROGMEM = "AND             ";
const char or[] PROGMEM = "OR              ";
const char not[] PROGMEM = "NOT             ";
const char nand[] PROGMEM = "NAND            ";
const char nor[] PROGMEM = "NOR             ";
const char trenn[] PROGMEM = "----------------";

void display (int number)
{
	switch (number)
	{
	  case 0:
	  	lcd_clrscr();
		lcd_puts_p(haupt);  
    	lcd_gotoxy(0,1);    
    	lcd_puts_p(ict);
		break;

	  case 1:
	  	lcd_clrscr();
    	lcd_puts_p(ict);
    	lcd_gotoxy(0,1);    
    	lcd_puts_p(and);
		break;


	  case 2:
	  	lcd_clrscr();
    	lcd_puts_p(ict);
    	lcd_gotoxy(0,1);    
    	lcd_puts_p(or);
		break;


	  case 3:
	  	lcd_clrscr();
    	lcd_puts_p(ict);
    	lcd_gotoxy(0,1);    
    	lcd_puts_p(not);
		break;


	  case 4:
	  	lcd_clrscr();
    	lcd_puts_p(ict);
    	lcd_gotoxy(0,1);    
    	lcd_puts_p(nor);
		break;


	  case 5:
	  	lcd_clrscr();
    	lcd_puts_p(ict);
    	lcd_gotoxy(0,1);    
    	lcd_puts_p(nand);
		break;


	  case 6:
	  	lcd_clrscr();
		lcd_puts_p(haupt);  
    	lcd_gotoxy(0,1);    
    	lcd_puts_p(unidib);
		break;


	  case 7:
	  	lcd_clrscr();
    	lcd_puts_p(unidib);
    	lcd_gotoxy(0,1);    
    	lcd_puts_p(and);
		break;


	  case 8:
	  	lcd_clrscr();
    	lcd_puts_p(unidib);
    	lcd_gotoxy(0,1);    
    	lcd_puts_p(or);
		break;


	  case 9:
	  	lcd_clrscr();
    	lcd_puts_p(unidib);
    	lcd_gotoxy(0,1);    
    	lcd_puts_p(not);
		break;


	  case 10:
	  	lcd_clrscr();
    	lcd_puts_p(unidib);
    	lcd_gotoxy(0,1);    
    	lcd_puts_p(nor);
		break;


	  case 11:
	  	lcd_clrscr();
    	lcd_puts_p(unidib);
    	lcd_gotoxy(0,1);    
    	lcd_puts_p(nand);
		break;

	  case 12:
		lcd_clrscr();
    	lcd_puts_p(trenn);
		break;
	}
	    
}

int main()
{

	int menue = 0;
	int sub = 0;

	KEY_DDR &= ~ALL_KEYS;                
  	KEY_PORT |= ALL_KEYS;                
 
  	TCCR0 = (1<<CS02)|(1<<CS00);		
  	TIMSK = 1<<TOIE0;				
 
  	LED_PORT = 0xFF;
  	LED_DDR = 0xFF; 

	lcd_init(LCD_DISP_ON);    
  	
	PORTB |=(1<<PB4);
	PORTB |=(1<<PB5);

	while(1)
    {
		switch(menue)
		{
			case 0:
				lcd_puts("UniDIB          ");
				lcd_gotoxy(7,1);
				lcd_puts("und ICT         "); 
				menue = 1;
		
			case 1:
	   			if(get_key_short( 1<<KEY0))
				{
					display (0);
					menue = 2;
				}
				break;

  			case 2:
				if(get_key_short( 1<<KEY0))
				{	
					display (6);
					menue = 1;
				}
				break;	
		}

	}
    
	return 0;
}