#include <avr/io.h>
#define F_CPU 8000000UL
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <string.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include "font.h"
//#include "tex.h"

#include <stdbool.h>



#define PIN_SCK                 	PORTB7
#define PIN_MOSI                	PORTB5
#define PIN_SS                  	PORTB4
#define PIN_MISO					PORTB6

#define DIGIT0						0x01
#define DIGIT1				   		0x02
#define DIGIT2				   		0x03
#define DIGIT3				   		0x04
#define DIGIT4				   		0x05
#define DIGIT5				   		0x06	
#define DIGIT6				   		0x07
#define DIGIT7				   		0x08

#define MAX71219_DATAIN1			PORTB |= (1<<PIN_MOSI)
#define MAX71219_DATAIN0	 		PORTB &=~(1<<PIN_MOSI)

#define MAX7219_LOAD1           	PORTB |= (1<<PIN_SS)
#define MAX7219_LOAD0          	 	PORTB &= ~(1<<PIN_SS)

#define MAX7219_SCK1            	PORTB |= (1<<PIN_SCK)
#define MAX7219_SCK0            	PORTB &= ~(1<<PIN_SCK)

#define MAX7219_REG_NOOP          	0x00 
#define MAX7219_MODE_DECODE       	0x09
#define MAX7219_MODE_INTENSITY    	0x0A
#define MAX7219_MODE_SCAN_LIMIT   	0x0B
#define MAX7219_MODE_SHUT_DOWN    	0x0C
#define MAX7219_MODE_TEST         	0x0F

//*****************************************************************************************+         

// Clear Display --------------  	0b00000001
#define LCD_CLEAR_DISPLAY        	0x01

// Cursor Home ----------------  	0b0000001x
#define LCD_CURSOR_HOME          	0x02

#define LCD_MOVE_CURSOR_LEFT     	0x10   
#define LCD_MOVE_CURSOR_RIGHT    	0x14   

//*******************************************************************************************

#define MATRIX_PORT     	PORTA
#define MATRIX_DDR      	DDRA

#define E		  	PB0
#define RW        		0
#define RS        		PB2


unsigned char InstructionReg = 0;
unsigned char DataReg = 0;


unsigned char i;
unsigned char k;
unsigned char j;
uint8_t spidata[16];
uint8_t status[16]; 

//**************************** SPI ***************************************************
/*
void spiSendByte (uint8_t databyte)

{
	// Daten Kopieren in die SPI-Datenregister
	SPDR = databyte;
	// Warten bis die Übertragung abgeschlossen ist
	while (!(SPSR & (1 << SPIF))); 

}
*/

void SPI_MasterInit(void)
{
/* Set MOSI and SCK output, all others input */
DDRB = (1<<PIN_MOSI)|(1<<PIN_SCK)|(1 << PIN_SS);
/* Enable SPI, Master, set clock rate fck/16 */
SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
}

void spiSendByte(char cData)
{
/* Start transmission */
SPDR = cData;
/* Wait for transmission complete */
while(!(SPSR & (1<<SPIF)));
}

//*********************************** Sendefunktion *****************************************************

void sendByte(const uint8_t reg1, const uint8_t data1 ,  const uint8_t reg2, const uint8_t data2)
{
   	    
 	 MAX7219_LOAD0;

  	 spiSendByte(reg1);
  	 spiSendByte(data1);
 	 spiSendByte(reg2);
  	 spiSendByte(data2);
	 	 
	 MAX7219_LOAD1;	 

}  

//************************ MAX's initialisieren **********************************************************

void max7219_init()
{
	
	//Decode-Mode an beide MAX7219 senden

	sendByte(  MAX7219_MODE_DECODE, 0x00,MAX7219_MODE_DECODE, 0x00);// using an led matrix (not digits)

	//Scanlimit an beide MAX7219 senden
	sendByte(MAX7219_MODE_SCAN_LIMIT,0x07 , MAX7219_MODE_SCAN_LIMIT, 0x07);// show all 8 digits	


	//Intensity an beide MAX7219 senden	
	sendByte( MAX7219_MODE_INTENSITY, 0x07,  MAX7219_MODE_INTENSITY, 0x07);// character intensity: range: 0 to 15

	//Power an beide MAX7219 senden
	sendByte(MAX7219_MODE_SHUT_DOWN, 0x01 ,  MAX7219_MODE_SHUT_DOWN, 0x01);// not in shutdown mode

	//Displaytest
	sendByte( MAX7219_MODE_TEST, 0x00,   MAX7219_MODE_TEST, 0x00);// no display test

}

//************************************************************************************************

void spiTransfer(int addr, uint8_t reg, uint8_t data) 
{

    //Create an array with the data to shift out
    int offset = addr*2;
    int maxbytes = 2*2; // 2*2(second 2 is the number of devices(MAX's))

    for(int i=0;i<maxbytes;i++)  spidata[i]= 0x00;

    //put our device data into the array
    spidata[offset+1]=reg;
    spidata[offset]=data;

    //enable the line 
    MAX7219_LOAD0;

    //Now shift out the data 
    for(int i=maxbytes;i>0;i--)   spiSendByte(spidata[i-1]);

    //latch the data onto the display
    MAX7219_LOAD1;

}  

//*********************************************************

void clearDisplay1(int addr)
{
    int offset;

    if(addr<0 || addr>=2)
	return;
    offset=addr*8;
    for(int i=7;i<8;i++) {
	status[offset + i]=0;
	spiTransfer(addr, i+1,status[offset + i]);

   }
}


//********************************************************************************

void setLed(int addr, int row, int column, bool state) 
{
    int offset;
    uint8_t val=0x00;

    if(addr<0 || addr>=2)
	return;
    if(row<0 || row>7 || column<0 || column>7)
	return;
    offset=addr*8;
    val= 0b10000000 >> column;
    if(state)
	status[offset+row]=status[offset+row]|val;
    else {
	val=~val;
	status[offset+row]=status[offset+row]&val;
    }
    spiTransfer(addr, row+1,status[offset+row]);
}

//*****************************************************************************

void setRow(int addr, uint8_t row, uint8_t value)
{
    int offset;
    if(addr<0 || addr>=2)
	return;
    if(row<0 || row>7)
	return;
    offset=addr*8;
    status[offset+row]=value;
    spiTransfer(addr, row+1,status[offset+row]);
}
//************************************************************************************

void setColumn(int addr, int col, uint8_t value) {
    uint8_t val;

    if(addr<0 || addr>=2)
	return;
    if(col<0 || col>7) 
	return;
    for(int row=0;row<8;row++) {
	val=value >> (7-row);
	val=val & 0x01;
	setLed(addr,row,col,val);
    }
}

//**************************************************************************************

void setChar(int addr, uint8_t value) 
{
    
    offset=addr*8;
    for(k = 0; k < 8; k++){
    v = pgm_read_byte (&font [value] [k]);//v=charTable[index];
    status[offset+k]=v;
    spiTransfer(addr, k+1,v);
	}
}

//******************************************************************************************

void clearDisplay() 
{
	char zeile[8];
	
	for(i=0;i<8;i++)
	{
		zeile[i] = 0x00;
		sendByte(i+1,zeile[i], i+1,zeile[i]);
		//_delay_ms(200);
	}	
}



//****************** function to write byte to LCD controller *****************************************

/*Input:    data   byte to write to LCD
          rs     1: write data
                 0: write instruction */

uint16_t address_counter = 0;
uint16_t ac;
void lcd_write(uint8_t data,uint8_t rs)
{
	if(rs == 0) //write to instruction register
	{
		//DDRB = 0xff;
		PORTB &= ~(1<<RS);
		MATRIX_DDR = 0x00; // DDRA
		MATRIX_PORT = data;
		InstructionReg = MATRIX_PORT ; //PORTA
	

		if(InstructionReg == LCD_CLEAR_DISPLAY ){ // Clear display.
		clearDisplay();
		//setRow(0,7,0b11111111);
		}

		if(InstructionReg == LCD_CURSOR_HOME ){ //Cursor home. 

		clearDisplay1(address_counter);
		address_counter = 0b00000000;
		setRow(address_counter, 7, 0b11111111);
		
		}
		
		else if(InstructionReg == LCD_MOVE_CURSOR_RIGHT) //Cursor shift command:right, move cursor.
		{
		
		clearDisplay1(address_counter);
		address_counter++;
		setRow(address_counter,7,0b11111111);
		
		}	

		else if(InstructionReg == LCD_MOVE_CURSOR_LEFT) //Cursor shift command:left, move cursor.
		{
		
		clearDisplay1(address_counter);
		address_counter--;
		
		setRow(address_counter,7,0b11111111);
		
		}

		else if( InstructionReg == 0b01000000) // set CGRAM Address
		{

		}

		else if(PINA & (1<<PA7 )) // set DDGRAM Address
		{
			if(MATRIX_PORT == 0b10000000 )
			{
				clearDisplay1(address_counter);
				address_counter = 0b00000000;
				setRow(address_counter, 7, 0b11111111);	
			}
			else if( MATRIX_PORT == 0b10000001   )
			{
				clearDisplay1(address_counter);
				address_counter++;
				setRow(address_counter,7,0b11111111);	
			}		
		}

//*********************** 4 bit mode ******************************************************
		
		else if( PINA & (1<<PA5 ) ) //4 bit mode ON, 1 line, 8*8 font
		{

		}

		else if( PINA & (1<<PA5 ) && PINA & (1<<PA3) ) //4 bit mode ON, 2 lines, 8*8 font, 
		{

		}

//*********************** 8 bit mode *******************************************************

		else if(PINA & (1<<PA5 ) && PINA & (1<<PA4 )) // 8 bit mode ON, 1 line, 8*8 font
		{

		}

		else if(PINA & (1<<PA5 ) && PINA & (1<<PA4) && PINA & (1<<PA3) ) // 8 bit mode ON, 2 line, 8*8 font
		{

		}


	}	
			
	
	else if(rs == 1) // write to data register
	{
		//DDRB = 0xff;
		PORTB |= (1<<RS);
		MATRIX_DDR = 0xff; // DDRA
		MATRIX_PORT = data;
		DataReg = MATRIX_PORT; //PORTA
		
		setChar(address_counter, data); //data will go to DDRAM (address_counter)
		address_counter++;
		setRow(address_counter,7,0b11111111);
	}
}

//**************************************** send command **********************************+

/* Send to the controller instruction command 
input: instruction to send to the controller */

void lcd_command(uint8_t cmd)
{
    
    lcd_write(cmd,0);
}

//********************************* send data **********************************************

/* Send to the controller data send 
input: data to send to the controller */

void lcd_data(uint8_t dat)
{
	lcd_write(dat, 1);
}


//************************************ main-Funktion ************************************************

 int main(void)
{

	SPI_MasterInit();	
	max7219_init();
	clearDisplay();


	
	lcd_command(0x02);_delay_ms(2000);
	lcd_command(0b00010100);_delay_ms(2000);
	lcd_command(0x02);_delay_ms(2000);
	lcd_data('A');_delay_ms(2000);

	lcd_command(0b10000000);_delay_ms(2000);
	lcd_command(0b10000001);_delay_ms(2000);



	while (1)
	{
	
	
	}
			
}