// ************************************************************************
// *                                                                      *
// *                             Arcade Stick                             *
// *                         Tastenprogrammierung                         *
// *                                                                      *
// ************************************************************************
 
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "lcd.h"
#include "LCD_Driver.h"

#ifndef F_CPU
#define F_CPU			4000000									// Processor Takt-Frequenz definieren
#warning kein F_CPU definiert
#endif

// Tasteneingänge definieren
// =========================
#define KEY_DDR         DDRB
#define KEY_PORT        PORTB
#define KEY_PIN         PINB
#define KEY0            6
#define KEY1            7
#define KEY2            0
#define KEY3            1
#define KEY4            2
#define KEY5            3
#define KEY6            4
#define KEY7            5
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2 | 1<<KEY3 | 1<<KEY4 | 1<<KEY5 | 1<<KEY6 | 1<<KEY7)
#define ACTION_KEYS		(1<<KEY2 | 1<<KEY3 | 1<<KEY4 | 1<<KEY5 | 1<<KEY6 | 1<<KEY7)

// Tastendrückwiederholungsdauer definieren
// ========================================
#define REPEAT_MASK     (1<<KEY0 | 1<<KEY1)
#define REPEAT_START    50                       				// nach 500ms
#define REPEAT_NEXT     20                      				// alle 200ms

// Tasten-Ausgänge definieren
// ==========================
#define OUT_DDR         DDRC
#define OUT_PORT        PORTC
#define OUT_PIN         PINC
#define OUT1            0
#define OUT2            1
#define OUT3            2
#define OUT4            3
#define OUT5            4
#define OUT6            5
#define ALL_OUT			(1<<OUT1 | 1<<OUT2 | 1<<OUT3 | 1<<OUT4 | 1<<OUT5 | 1<<OUT6)

#define LED0			(1<<PC0)
#define LED1			(1<<PC1)
#define LED2			(1<<PC2)
#define LED3			(1<<PC3)
#define LED4			(1<<PC4)
#define LED5			(1<<PC5)

#define NR_KONFIGS		9
#define NR_KEYS			7
#define DELAY			300
#define MENU_SIZE		(sizeof(menu_text) / sizeof(*menu_text))

#define NO_ACTION          0
#define EXIT_ACTION        1
#define DEF_KEY_ACTION     2
#define DEF_REPEAT_ACTION  3
#define LCD_ACTION         4
#define LED_ACTION         5
#define SAVE_ACTION        6

// Tabelle von Zeigern auf die Tastenkonfigurationen erstellen
// ===========================================================
uint8_t KonfigPattern[NR_KONFIGS][NR_KEYS] =
	{
		{LED0,LED0,LED4,LED3,LED1,LED2,0},						// Konfiguration 1 (C64)
		{LED1,LED0,LED3,LED2,LED5,LED4,1},						// Konfiguration 2
		{LED5,LED4,LED0,LED2,LED1,LED3,5},						// Konfiguration 3
		{LED3,LED1,LED2,LED0,LED4,LED5,0},						// Konfiguration 4
		{LED4,LED1,LED2,LED3,LED0,LED5,0},						// Konfiguration 5
		{LED5,LED1,LED2,LED3,LED4,LED0,0},						// Konfiguration 6
		{LED0,LED1,LED2,LED3,LED4,LED5,0},						// Konfiguration 7
		{LED0,LED1,LED2,LED3,LED4,LED5,0},						// Konfiguration 8
		{LED0,LED1,LED2,LED3,LED4,LED5,0},						// Konfiguration 9
   };

// LCD-Menüeinträge definieren
// ===========================
const char menu_000[] = " Multifunktions ";	//
const char menu_001[] = "ArcadeController";	//
const char menu_002[] = "** HAUPTMENUE **";	//

const char menu_100[] = "Tastenzuordnung>";	// 0
const char menu_101[] = "[X        ]    1";	// 1
const char menu_102[] = "[XX       ]    2";	// 2
const char menu_103[] = "[XXX      ]    3";	// 3
const char menu_104[] = "[XXXX     ]    4";	// 4
const char menu_105[] = "[XXXXX    ]    5";	// 5
const char menu_106[] = "[XXXXXX   ]    6";	// 6
const char menu_107[] = "[XXXXXXX  ]    7";	// 7
const char menu_108[] = "[XXXXXXXX ]    8";	// 8
const char menu_109[] = "[XXXXXXXXX]    9";	// 9

const char menu_200[] = "<Dauerfeuer    >";	// 10
const char menu_201[] = "[         ]    0";	// 11
const char menu_202[] = "[X        ]    1";	// 12
const char menu_203[] = "[XX       ]    2";	// 13
const char menu_204[] = "[XXX      ]    3";	// 14
const char menu_205[] = "[XXXX     ]    4";	// 15
const char menu_206[] = "[XXXXX    ]    5";	// 16
const char menu_207[] = "[XXXXXX   ]    6";	// 17
const char menu_208[] = "[XXXXXXX  ]    7";	// 18
const char menu_209[] = "[XXXXXXXX ]    8";	// 19
const char menu_210[] = "[XXXXXXXXX]    9";	// 20

const char menu_300[] = "<System        >";	// 21
const char menu_301[] = "LCD            >";	// 22
const char menu_302[] = "<LED-Test       ";	// 23

const char menu_400[] = "<Speichern     >";	// 24

const char menu_500[] = "<Beenden        ";	// 25


typedef struct def_menustruktur
{
	const char *text;

	unsigned char next;
	unsigned char previous;
	unsigned char sub;
	unsigned char up;

	unsigned char ActionCode;
	unsigned char ActionArgument;
}menustruktur;

// Tabelle von Zeigern auf die Texte erstellen
// ===========================================
menustruktur menu[] = 
{
	{menu_100, 10, 0, 1, 0, NO_ACTION, 0},
		{menu_101, 2, 1, 0, 0, DEF_KEY_ACTION, 1},
		{menu_102, 3, 1, 0, 0, DEF_KEY_ACTION, 2},
		{menu_103, 4, 2, 0, 0, DEF_KEY_ACTION, 3},
		{menu_104, 5, 3, 0, 0, DEF_KEY_ACTION, 4},
		{menu_105, 6, 4, 0, 0, DEF_KEY_ACTION, 5},
		{menu_106, 7, 5, 0, 0, DEF_KEY_ACTION, 6},
		{menu_107, 8, 6, 0, 0, DEF_KEY_ACTION, 7},
		{menu_108, 9, 7, 0, 0, DEF_KEY_ACTION, 8},
		{menu_109, 9, 8, 0, 0, DEF_KEY_ACTION, 9},
	{menu_200, 21, 0, 11, 10, NO_ACTION, 0},
		{menu_201, 12, 11, 10, 10, DEF_REPEAT_ACTION, 0},
		{menu_202, 13, 11, 10, 10, DEF_REPEAT_ACTION, 1},
		{menu_203, 14, 12, 10, 10, DEF_REPEAT_ACTION, 2},
		{menu_204, 15, 13, 10, 10, DEF_REPEAT_ACTION, 3},
		{menu_205, 16, 14, 10, 10, DEF_REPEAT_ACTION, 4},
		{menu_206, 17, 15, 10, 10, DEF_REPEAT_ACTION, 5},
		{menu_207, 18, 16, 10, 10, DEF_REPEAT_ACTION, 6},
		{menu_208, 19, 17, 10, 10, DEF_REPEAT_ACTION, 7},
		{menu_209, 20, 18, 10, 10, DEF_REPEAT_ACTION, 8},
		{menu_210, 21, 19, 10, 10, DEF_REPEAT_ACTION, 9},
	{menu_300, 24, 10, 22, 21, NO_ACTION, 0},
		{menu_301, 23, 22, 21, 21, LCD_ACTION, 1},
		{menu_302, 23, 22, 21, 21, LED_ACTION, 1},
	{menu_400, 25, 21, 24, 24, SAVE_ACTION, 1},
	{menu_500, 25, 24, 25, 25, EXIT_ACTION, 1}
};


volatile uint8_t key_state;										// Entprellt und invertierte Tastenstatus:
																// Bit=1 -> Taste wurde gedrückt
volatile uint8_t key_press;										// Tastendruck registriert
volatile uint8_t key_rpt;										// Tastendruckdauer
volatile uint8_t nKonfig = 1;									// Tasten-Konfiguration
volatile uint8_t Summe = 0;										// Tastenzuordnung bei gedrückten Tasten

volatile uint8_t nFire = 0;										// Dauerfeuer-Konfiguration
volatile uint8_t nFireTime = 12;								// Dauerfeuer-Zeit

volatile uint8_t MenuOnScreen = 0;								// LCD-Menü aktiv?
unsigned char menu_index = 0;
unsigned char sub_menu_index = 1;

// Timer Interrupt von 10ms definieren
// ===================================
ISR(TIMER0_OVF_vect)
{
	static uint8_t ct0, ct1, rpt, cntTicks;
	uint8_t i;

	TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);

	i = key_state ^ ~KEY_PIN;									// Taste geändert?
	ct0 = ~(ct0 & i);											// resete oder zähle CT0
	ct1 = ct0 ^ (ct1 & i);										// resete oder zähle CT1
	i &= ct0 & ct1;												// Überlauf gezählt?
	key_state ^= i;												// dann Entprellstatus ändern
	key_press |= key_state & i;									// 0->1: Tastendruck erkannt

	if((key_state & REPEAT_MASK) == 0)							// Überprüfe Tastenwiederholfunktion
		rpt = REPEAT_START;										// Starte Verzögerung
	if(--rpt == 0)
	{
		rpt = REPEAT_NEXT;										// Wiederhole Verzögerung
		key_rpt |= key_state & REPEAT_MASK;
	}

	if (nFire != 0)
	{
		cntTicks++;												// Ist Dauerfeuer aktiv
		if(cntTicks >= nFireTime)								// und Feuergeschwindigkeit x 10ms
		{														// toggle abhängig von Konfiguration, Ausgang PortC.0
			KonfigPattern[nKonfig-1][KonfigPattern[nKonfig-1][6]] ^= 0x01;
			cntTicks = 0;
		}
	}
}

// Überprüfen, ob eine Taste gedrückt wurde.
// Jede gedrückte Taste wird nur einmal gemeldet
// =============================================
uint8_t get_key_press(uint8_t key_mask)
{
	cli();														// Interrupts deaktivieren
	key_mask &= key_press;										// Tasten auslesen
	key_press ^= key_mask;										// Tasten löschen
	sei();														// Interrupts aktivieren
	return key_mask;
}

// Erfolgt ein längerer Tastendruck, so wird nach einiger Zeit
// der Tastendruck automatisch wieder verworfen.
// ===========================================================
uint8_t get_key_rpt(uint8_t key_mask)
{
	cli();														// Interrupts deaktivieren
	key_mask &= key_rpt;										// Tasten auslesen
	key_rpt ^= key_mask;										// Tasten löschen
	sei();														// Interrupts aktivieren
	return key_mask;
}

// Kurzer Tastendruck
// ==================
uint8_t get_key_short(uint8_t key_mask)
{
	cli();														// Interrupts deaktivieren
	return get_key_press(~key_state & key_mask);
}

// Langer Tastendruck
// ==================
uint8_t get_key_long(uint8_t key_mask)
{
	return get_key_press(get_key_rpt(key_mask));
}

void lcd_update()
{
	MenuOnScreen = 0;
	lcd_gotoxy(0,0);											// Startmeldung am LCD anzeigen
	lcd_puts(menu_000);
	lcd_gotoxy(0,1);
	lcd_puts(menu_001);
	menu_index = 0;
}

// Initialisierung der Ports
// =========================
void init()
{

// Ports initialisieren
// --------------------
	OUT_DDR |= ALL_OUT;											// Controller als Ausgang definieren
	KEY_DDR &= ~ALL_KEYS;										// Tastenports als Eingang definieren
	KEY_PORT |= ALL_KEYS;										// Tastenports PullUp

// Interrupt aktvieren
// -------------------
	TCCR0 = (1<<CS02)|(1<<CS00);								// Teilen bei 1024
	TIMSK = 1<<TOIE0;											// TimerInterrupt aktivieren

// LCD initialisieren
// ------------------
    lcd_init(LCD_DISP_ON);
	lcd_clrscr();
}

int main(void)
{
	init();														// Einschaltsequenz starten
	sei();														// Interrupts aktivieren

	lcd_update();

	while(1)
	{
		if(MenuOnScreen)
		{	
			if(get_key_short(1<<KEY0))							// kurzer Tastendruck (PinB.6)
			{
				menu_index = menu[menu_index].next;

				lcd_gotoxy(0,1);
				lcd_puts(menu[menu_index].text);
			}

			if(get_key_short(1<<KEY1))							// kurzer Tastendruck (PinB.7)
			{
				menu_index = menu[menu_index].previous;

				lcd_gotoxy(0,1);
				lcd_puts (menu[menu_index].text);
			}

			if(get_key_long(1<<KEY1))							// langer Tastendruck (PinB.6)
			{
				lcd_gotoxy(0,0);
				lcd_puts(menu[menu_index].ActionArgument);
				menu_index = menu[menu_index].sub;
				lcd_gotoxy(0,1);
				lcd_puts(menu[menu_index].text);

				if(menu[menu_index].ActionCode == DEF_KEY_ACTION)
				{
					nKonfig = menu[menu_index].ActionArgument;
				}
				else if(menu[menu_index].ActionCode == DEF_REPEAT_ACTION)
					nFire = menu[menu_index].ActionArgument;
				else if(menu[menu_index].ActionCode == SAVE_ACTION)
				{
					eeprom_write_byte(00, nKonfig);
					lcd_update();
				}
				else if(menu[menu_index].ActionCode == EXIT_ACTION)
					lcd_update();
			}
		}
		else
		{
			if(get_key_short(1<<KEY1))							// kurzer Tastendruck (PinB.6)
			{
				KEY_DDR |= ACTION_KEYS;
				lcd_gotoxy(0,0);
				lcd_puts(menu_002);
				lcd_gotoxy(0,1);
				lcd_puts(menu[menu_index].text);
				MenuOnScreen = 1;    							// LCD-Hauptmenü anzeigen
			}

			Summe = 0;

			if(!(KEY_PIN & 0x01))								// Wenn Taste PortB.0 auf HIGH
				Summe |= KonfigPattern[nKonfig-1][0];
			if(!(KEY_PIN & 0x02))								// Wenn Taste PortB.1 auf HIGH
				Summe |= KonfigPattern[nKonfig-1][1];
			if(!(KEY_PIN & 0x04))								// Wenn Taste PortB.2 auf HIGH
				Summe |= KonfigPattern[nKonfig-1][2];
			if(!(KEY_PIN & 0x08))								// Wenn Taste PortB.3 auf HIGH
				Summe |= KonfigPattern[nKonfig-1][3];
			if(!(KEY_PIN & 0x10))								// Wenn Taste PortB.4 auf HIGH
				Summe |= KonfigPattern[nKonfig-1][4];
			if(!(KEY_PIN & 0x20))								// Wenn Taste PortB.5 auf HIGH
				Summe |= KonfigPattern[nKonfig-1][5];

			OUT_PORT = Summe;
		}
	}
}