/*
 * J-TechWCS1.cpp
 *
 * Created: 15.07.2021 14:13:37
 * Author : Julien
 */ 

#define F_CPU 8000000
#ifndef F_CPU
#define F_CPU           8000000                   // processor clock frequency
#warning kein F_CPU definiert
#endif
#include <stdio.h>
#include <stdint.h>
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include "uart.h"

//IO defines

#  define InTriggerOn	!(PINB & (1<<PB7))
#  define InTriggerOff	PINB & (1<<PB7)
#  define InMagInOn		!(PINB & (1<<PB6))
#  define InMagInOff	PINB & (1<<PB6)
#  define InBurstOn		!(PIND & (1<<PD2))
#  define InBurstOff	PIND & (1<<PD2)
#  define InSafeOn		!(PIND & (1<<PD3))
#  define InSafeOff		PIND & (1<<PD3)
#  define InReloadOn	!(PIND & (1<<PD4))
#  define InReloadOff	PIND & (1<<PD4)
#  define InSemiOn		!(PIND & (1<<PD5))
#  define InSemiOff		PIND & (1<<PD5)

#  define OutTriggerOn		PORTC &= ~(1 << PC0)
#  define OutTriggerOff		PORTC |= (1 << PC0)
#  define OutSemiOn			PORTC &= ~(1 << PC1)
#  define OutSemiOff		PORTC |= (1 << PC1)
#  define OutReloadOn		PORTC &= ~(1 << PC2)
#  define OutReloadOff		PORTC |= (1 << PC2)

#define KEY_DDR         DDRB
#define KEY_PORT        PORTB
#define KEY_PIN         PINB
#define KEY0            7
#define ALL_KEYS        (1<<KEY0)

#define REPEAT_MASK     (1<<KEY0)       // repeat: key0
#define REPEAT_START    50                        // after 500ms
#define REPEAT_NEXT     20                       // every 200ms



//Variablen
volatile unsigned int t_triggerON;
volatile unsigned int t_triggerOFF;
volatile unsigned int schuss;
volatile unsigned int schussAuftrag;
volatile unsigned int SPM;
volatile unsigned int Impulszeit;
volatile unsigned int ImpulszeitReload;
volatile unsigned int Schusszyklus;

//UART defines
/*#define FOSC 8000000 // Clock Speed
#define BAUD 9600
#define MYUBRR FOSC/16/BAUD-1*/
#define UART_BAUD_RATE 9600

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

volatile uint8_t msec;                              // zähler Millisekunden
volatile float m;                              // zähler Millisekunden

volatile float mTrigger;                              // Merker Trigger

volatile float test;                              // zähler Millisekunden

volatile unsigned int UART_State;				//Variable UART Zustandsmaschine

///////////////////////////////////////////////////////////////////
//
// 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 being 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;
}

///////////////////////////////////////////////////////////////////
//
// check if a key is pressed right now
//
uint8_t get_key_state( uint8_t key_mask )

{
	key_mask &= key_state;
	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 ));
}

void SetupTimer0()
{
	
	// Timer 0 konfigurieren
	TCCR0A = (1<<WGM01); // CTC Modus
	TCCR0B |= (1<<CS00); // Prescaler 64
	TCCR0B |= (1<<CS01); // Prescaler 64
	// ((8000000/64)/1000) = 125
	OCR0A = 125-1;
	// Compare Interrupt erlauben
	TIMSK0 |= (1<<OCIE0A);
}

void SetupTimer1()
{
	TCCR1B = (1<<WGM12);
	TCCR1B = (1<<CS10); 
	TCCR1B = (1<<CS12);         // divide by 64
	TIMSK1 |= 1<<OCIE1A;                   // enable CTC timer interrupt
	OCR1A=310;
}
void SetupUART()
{
	uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
}

void UART()
{
	/* Empfangenes Zeichen + Statuscode */
	uint16_t        c = 0;
	
	c = uart_getc();
	switch((uint8_t)c)
	{
		case 'h':
		UART_State=0;
		uart_puts("\n\r\n\rEingabecommands\n\rTrigger: t\n\rReload: r\n\rSemi: s\n\rSafe: d\n\rMagIn: m\n\rBurst: b\n\rExit: q");
		break;
		case 't':
		UART_State=1;
		break;
		case 'r':
		UART_State=2;
		break;
		case 's':
		UART_State=3;
		break;
		case 'd':
		UART_State=4;
		break;
		case 'm':
		UART_State=5;
		break;
		case 'b':
		UART_State=6;
		break;
		case 'q':
		UART_State=0;
		uart_puts("\033[2J");
		break;
		default:
		break;
	}	
}

void SetupGunHK416()
{
	//Schuss pro Minute
	SPM=775;
	//Umrechnung in Millisekunden pro Schuss
	Schusszyklus=1000/(SPM/60);
	//Signalmpulszeit an LaserWar Board in ms
	Impulszeit=10;
}
void SetupGunScorpion()
{
	//Schuss pro Minute
	SPM=600;
	//Umrechnung in Millisekunden pro Schuss
	Schusszyklus=1000/(SPM/60);
	//Signalmpulszeit an LaserWar Board in ms
	Impulszeit=25;
}
void SetupIOs()
{
		  // Pin D0 und D1 auf Ausgang und andere im ursprünglichen Zustand belassen:
		  DDRC |= (1 << PC0);//Trigger
		  DDRC |= (1 << PC1);//Semi
		  DDRC |= (1 << PC2);//Reload

		  
		  //Ausgänge initialisieren
			OutTriggerOff;
			OutSemiOff;
			OutReloadOff;
		  
		  /* Pins auf Eingang */
		  DDRB &= ~(1 << PB6);//MagIn
		  DDRB &= ~(1 << PB7);//Trigger
		  DDRD &= ~(1 << PD2);//Burst
		  DDRD &= ~(1 << PD3);//Safe
		  DDRD &= ~(1 << PD4);//Reload
		  DDRD &= ~(1 << PD5);//Semi

		  /* Interne Pull-Up Widerstände einschalten */
		  PORTB |= (1<<PB6);
		  PORTB |= (1<<PB7);
		  PORTD |= (1<<PD2);
		  PORTD |= (1<<PD3);
		  PORTD |= (1<<PD4);
		  PORTD |= (1<<PD5);
		  
}


void SchussModeHK416()
{
		//Safe
		if (InSafeOff)
		{
			schussAuftrag=0;
		}
		//Semimodus
		if (InSemiOn&&InSafeOn)
		{
			schussAuftrag=1;
		}
		//Schussfolgenmodus
		/*if (InSemiOff&&InSafeOff)
		{
			schussAuftrag=3;
		}
		*/
		//Weder Semi noch Schussfolge -> Vollauto
		if (InSemiOff&&InSafeOn)
		{
			schussAuftrag=9999;
		}
}

void SchussModeScorpion()
{
		//Semimodus
		if ((PIND & (1<<PD5))&&(PIND & (1<<PD4)))
		{
			schussAuftrag=1;
		}
		//Schussfolgenmodus
		if ((!(PIND & (1<<PD5))&&(PIND & (1<<PD4))))
		{
			schussAuftrag=3;
		}
		//Weder Semi noch Schussfolge -> Vollauto
		if ((!(PIND & (1<<PD4)))&&((!(PIND & (1<<PD5)))))
		{
			if((get_key_state(1<<KEY0)))
			{
				if (schuss==0)
				{
					schussAuftrag=1;
					schuss=schussAuftrag;
				}
			}

		}
	
}

int main(void)
{
	SetupIOs();
	SetupTimer0();
	SetupTimer1();

	SetupUART();
	
	SetupGunHK416();
	//SetupGunScorpion();

	// Global Interrupts aktivieren
	sei();
	
	//AdminMode();
	//Variablen initialisieren
	t_triggerOFF=100;
	t_triggerON=0;
	schuss=0;
	schussAuftrag=0;
	msec=0;
	mTrigger=0;
	UART_State=0;
	

    /* Replace with your application code */
    while (1) 
    {
		
		
		SchussModeHK416();
		//SchussModeScorpion();
		UART();
		//Ein Tastendruck entspricht einem Semi/Schussfolge
		if((get_key_press( 1<<KEY0 ))&&(schussAuftrag!=0)&&(schussAuftrag!=9999))
		{
			
			if (schuss==0)
			{
				schuss=schussAuftrag;
			}
			
		}
		if((InTriggerOn)&&(schussAuftrag==9999))
		{
			if (schuss==0)
			{
				schuss=1;
			}
		}
		//Reload
		if (InReloadOn)
		{
			OutReloadOn;
		}
		else
		{
			OutReloadOff;
		}
    }
}

ISR (TIMER0_COMPA_vect)
{
	
	if ((schuss>0)&&(mTrigger==0))
	{
		mTrigger=1;
	}
	
	if (mTrigger==1)
	{
		if ((t_triggerON<=Impulszeit)&&(PINC & (1 << PC0)))
		{
			OutTriggerOn;
		}
		if ((t_triggerON>Impulszeit)&&(!(PINC & (1 << PC0))))
		{
			OutTriggerOff;
			schuss--;
			
		}
		if (t_triggerON>=Schusszyklus)
		{
			mTrigger=0;
			t_triggerON=0;
		}
		t_triggerON++;
	}
}

ISR( TIMER1_COMPA_vect )                            // every 10ms
{
	
	msec++;
		
		if (msec>=10)
		{
				switch(UART_State)
				{
					case 0:
					break;
					case 1:
					uart_puts("\033[2J");
					uart_puts("\r\nTrigger: ");
					if (InTriggerOn)
					{
						uart_puts("1");
					}
					else
					{
						uart_puts("0");
					}
					break;
					case 2:
					uart_puts("\033[2J");
					uart_puts("\r\nReload: ");
					if (InReloadOn)
					{
						uart_puts("1");
					}
					else
					{
						uart_puts("0");
					}
					break;
					case 3:
					uart_puts("\033[2J");
					uart_puts("\r\nSemi: ");
					if (InSemiOn)
					{
						uart_puts("1");
					}
					else
					{
						uart_puts("0");
					}
					break;
					case 4:
					uart_puts("\033[2J");
					uart_puts("\r\nSafe: ");
					if (InSafeOn)
					{
						uart_puts("1");
					}
					else
					{
						uart_puts("0");
					}
					break;
					case 5:
					uart_puts("\033[2J");
					uart_puts("\r\nMagIn: ");
					if (InMagInOn)
					{
						uart_puts("1");
					}
					else
					{
						uart_puts("0");
					}
					break;
					case 6:
					uart_puts("\033[2J");
					uart_puts("\r\nBurst: ");
					if (InBurstOn)
					{
						uart_puts("1");
					}
					else
					{
						uart_puts("0");
					}
					break;
					default:
					/* some code */;
				}

				msec=0;
		}

	TCNT1=0;
	
	static uint8_t ct0 = 0xFF, ct1 = 0xFF, rpt;
	uint8_t i;
	
	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;
	}
}