#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <inttypes.h>
#include <util/delay.h>


/***********   Belegung Port A fuer CAN-Controller   *************/
#define _WINKEL (PINA & (1<<PINA6))  		// Eingang, Codierbrücke: Low == Winkelgeber
#define WDT_RES_ON (PORTA |= (1<<PORTA7))	// Watchdog extern reset
#define WDT_RES_OFF (PORTA &= ~(1<<PORTA7)) // Watchdog extern laufen lassen

/***********   Belegung Port B fuer A/D-Wandler und Ph. Layer *****/
#define SCLK_AD_ON (PORTB |= (1<<PORTB4)) // Ausgang,ser. Schnittst., Clocksignal
#define SCLK_AD_OFF (PORTB &= ~(1<<PORTB4)) // Ausgang,ser. Schnittst., Clocksignal
#define DIN_AD_ON (PORTB |= (1<<PORTB6))  // Ausgang, "    "       , Daten µC ==>A/D_Wandler 
#define DIN_AD_OFF (PORTB &= ~(1<<PORTB6))  // Ausgang, "    "       , Daten µC ==>A/D_Wandler 
#define DOUT_AD (PINB & (1<<PINB5)) // Eingang, "    "     , Daten vom AD
#define _DRDY (PINB & (1<<PINB7)) // Eingang, "    "       , wenn 0 ==> Data Ready
#define _CS_AD_OFF (PORTB |= (1<<PORTB3))  // Ausgang, Chip select, 1 ==> inaktiv
#define _CS_AD_ON (PORTB &= ~(1<<PORTB3))  // Ausgang, Chip select, 0 ==> aktiv
#define _RES_AD_ON (PORTB &= ~(1<<PORTB2))  // Ausgang, Reset A/D-Wandler, 0 ==> Reset
#define _RES_AD_OFF (PORTB |= (1<<PORTB2))  // Ausgang, Reset A/D-Wandler, 1 ==> AD laeuft
#define _EN_PH_LAY_ON (PORTB &= ~(1<<PORTB0))  // Ausgang, Enable ATA6660
#define _EN_PH_LAY_OFF (PORTB |= (1<<PORTB0))  // Ausgang, Disable ATA6660


/************* Definitionen CAN Protokoll ********************************/
#define UNIT 0              // Seriennummer (3 Byte) setzt sich aus Einheit, Woche 
#define WEEK 43             // und Jahr zusammen.
#define YEAR 97             // 
                            // 23.............16|15..........10|9.............0
                            // YEAR (0...99dez.) WEEK  (1...52) UNIT (0...1023)

                            // Anmerkung:
                            // Seriennummer für spaetere Einzelteilverwaltung vorgesehen
                            // heutige Definition:
                            // UNIT = 0, WEEK/YEAR = Softwarestand

/******************* Variablen *******************************************/
volatile unsigned char count;        // allgemeine Zaehlervariable

volatile unsigned char datenwert;       // Daten die geschrieben werden sollen oder die 
              			              // gelesen wurden, seriell

volatile unsigned char buffer;       // allg. Datenspeicher
volatile unsigned char mirror;       // allg. Datenspeicher

volatile unsigned char umlauf;       // Zaehler fuer Programmumlaeufe, wird pro Umlauf inc.
volatile unsigned char mob;

volatile unsigned char prog_stat = 0b00000000;

volatile unsigned char crc;          // CRC-Checksumme

volatile unsigned char id_hb;        // Identifier_Highbyte
volatile unsigned int idf1;        // Identifier_Highbyte
volatile unsigned int idf2;        // Identifier_Highbyte

volatile unsigned int mw;           // Messwert aus dem A/D Wandler, 16 bit
volatile unsigned char mw_hb;		// Messwert Highbyte
volatile unsigned char mw_lb;  		// Messwert Lowbyte

volatile unsigned int weekunit;     // Mischwort fuer Serienummer Woche/Einheit
volatile unsigned int weekunit_low;                // Lowbyte
volatile unsigned int weekunit_high;              // Highbyte
volatile unsigned int tausendstel = 0;
volatile unsigned int waittimer = 0;

volatile unsigned char data[8];
volatile unsigned char toggle = 0;


void clrwdg(void);
void write_to_ad(unsigned char);
void read_from_ad(void);
void hardwareinit(void);
void adcaninit(void);
void hole_mw(void);
void message1_to_can(void);
void message2_to_can(void);
void test_can_status(void);



ISR(CANIT_vect)
{
	uint8_t		save_canpage;

	// Aktuelle CANPAGE sichern
 	save_canpage	= CANPAGE;

	// Falls es kein gültiges MOB war abbrechen
	if(mob >= 14)
	{
		return;
	}

	// RXOK-Flag löschen
	CANSTMOB &= ~(1<<RXOK);
    
    // CANPAGE wiederherstellen
	CANPAGE		= save_canpage;
}

void clrwdg(void)
{
	WDT_RES_OFF;
	_delay_us(1);
	WDT_RES_ON;
}




void hardwareinit(void)
{
    // Initialisierung der Prozessorports *********************************

	MCUSR = 0;				// Clear MCU Status Register
	SREG = 0b10000000;		// Global Int enabled
	CLKPR = 0b1000000;		// Clearing the clock-prescaler
	SMCR = 0b0000000;		// Sleep-mode off
	WDTCR = 0b00010000;		// Disable Watchdog
	WDTCR &= ~(1<<WDE);		// SSecond part for clearing watchdog
	MCUCR = 0b00000000;		// Enables Jtag, Pullups

	DDRA = 0b10000000;		// PortA as Input, execpt A7
	PORTA = 0b00110000;		// Pullup except A4,A5
	DDRB = 0b01011101;		// PB as Output
	PORTB = 0b00000000;		// Set Pullups and Outputs
	DDRC = 0x00;			// PortC Inputs
	PORTC = 0xFF;			// Pullups PortC On
	DDRD = 0b00100000;		// PortD Inputs execpt D5
	PORTD = 0b10011111;		// PortD Pullups
	DDRE = 0b00000100;		// PortE Inputs, Outputs
	PORTE = 0xFB;			// PortE Pullups
	DDRF = 0xFF;				// PortF Inputs
	PORTF = 0xFF;			// PortF Pullups
	DDRG = 0xFF;				// PortF Inputs
	PORTG = 0xFF;			// PortF Pullups

	EICRA = 0x00;			// Async. Ext. Interrupt Ctrl
	EICRB = 0x00;			// Sync. Ext. Interrupt Ctrl
	EIMSK = 0x00;			// Ext. Interrupt Mask
	EIFR = 0x00;			// Ext. Interrupt Flag Register

	GTCCR = 0x00;			// General Timer/Counter Control
	TCCR0A = 0x03;			// Timer/Counter0 Control A
	TCNT0 = 0xA2;			// Timer/Counter0
	OCR0A = 0x00;			// Output compare register A
	TIMSK0 = 0x00;			// Timer/Counter0 interrupt mask
	TIFR0 = 0x00;			// Timer/Counter0 interrupt flags

	sei();
return;
}




void adcaninit(void)
{

	// Berechnung der Seite des Identifier aus der Stellung der Codierbrücke
    if (_WINKEL)
        {
        id_hb=0X04;            // Seite für Längengeber
        }
    else
        {
        id_hb=0X02;            // Seite für Winkelgeber
        }
    // Berechnung des Identifier aus der Stellung des Codierschalters
    id_hb <<= 4;              // 4 Stellen links schieben
    buffer = (0x0f & PINA);   // Codierschalter (PORTA) lesen
                              // Bit 0...2:   Steckercode 0...7, aktiv high
                              // Bit 3:               Knoten A/B, 0 ==>A

	if (buffer & 0x01) mirror |= 0x08;	// Bits spiegeln, da Anschluss verkehrt
	else mirror &= ~0xF8;
	if (buffer & 0x02) mirror |= 0x04;
	else mirror &= ~0xF4;
	if (buffer & 0x04) mirror |= 0x02;
	else mirror &= ~0xF2;
	if (buffer & 0x08) mirror |= 0x01;
	else mirror &= ~0xF1;
	buffer = mirror;

    id_hb |=buffer;           // Bits aus Codierschalter (PORTA) hinzu 
    			            // Wert fuer identifier_hb speichern
                              // (ist fuer Message 0...7 konstant)

	idf1 = (((id_hb<<8) | 0x37)>>5);	// Message1 Identifier
	idf2 = (((id_hb<<8) | 0x55)>>5);	// Message2 Identifier
    
    // Init Programmvariablen ***********************************************************    
    prog_stat |= (1<<2);      // Vorgabewert Programmstatus nach der Initialisierung, Bit 2        
    umlauf = 0;               // Programmumlaufzaehler Startwert
    
    // Vorberechnung der Seriennummer *****************************************
    weekunit = (WEEK & 0X003F);   // Variable aus Woche und Einheit zusammensetzen
    weekunit <<= 10;          // WEEK, UNIT siehe Datei Seriennr.inc
    weekunit &= 0XFC00;
    weekunit += UNIT;

    _RES_AD_OFF;
	_CS_AD_ON;
	    
    write_to_ad(0X10);           // config Communication-Reg:
                                 // naechste Aktion: Schreibe ins Setup Reg.  
                                 // Gain = 1 für Potigeber
    
    write_to_ad(0X64);           // config Setup-Reg:
                                 // MD1 MD0 CLK FS1 FS0 _B/U BUF FSYNC
                                 //  0   1   1   0   0    1   0   0
                                 // Self Calibration Mode, Takt = 2,5 MHz,
                                 // Output Update Rate = 50Hz ==> t=20ms 

    while (_DRDY)
        {
                            // warten bis A/D-Wandler fertig;
        _delay_ms(200);         // Calibration Time = 9*20ms = 180ms !       
        clrwdg();
        };

    // Init CAN-Controller ****************************************************
  	for (mob = 0; mob < 15; mob++)
	{
		CANPAGE  = (mob << 4);
		CANSTMOB = 0;
 		CANCDMOB = 0;
	}
		// CAN_setBaudrate
	CANBT1		= 0x04; /************************ war 04 */
	CANBT2		= 0x6c; /************************ war 0c */
	CANBT3		= 0x37;	/************************ war 37 */

		// CAN_setInterrupt
	CANGIE &= ~(1<<ENIT);
	CANGIE &= ~(1<<ENRX);
	CANGIE &= ~(1<<ENTX);

	CANGCON |= (1<<ENASTB);		// CAN-Controller in Enabled Mode setzen
  	// Warten bis der CAN-Controller das Enabled-Bit gesetzt hat und einsatzbereit ist
  	while (!(CANGSTA & (1<<ENFG)));

	return;
}





void write_to_ad(unsigned char adwert)
    {
	unsigned char maske = 0b10000000;
	_delay_us(1);
    for (count=8;count > 0;count--)
        {
        if ((adwert & maske) == maske)
            {
            DIN_AD_ON;             // DIN_AD entsprechend setzen
            }
        else
            {
            DIN_AD_OFF;
            }
        SCLK_AD_OFF;               // Bit in den A/D-Wandler einschreiben
	_delay_us(1);
        SCLK_AD_ON;
	_delay_us(1);
		maske = (maske>>1);			// 
        }
    }





void read_from_ad(void)
    {
	unsigned char maske = 0b10000000;
    
	_delay_us(1);
    for (count=8;count > 0;count--)
        {
        SCLK_AD_OFF;              		// Datenbit wird auf die Leitung gelegt
	_delay_us(1);
 		if (DOUT_AD)					// Wenn Bit = 1
            {
            datenwert |= maske;         // Datenwert mit Masken-1 belegen
            }
        else
            {
            datenwert &= ~(maske);		// Datenwert mit 0 belegen
            }
        SCLK_AD_ON; 
	_delay_us(1);
        maske = (maske>>1);            	// Maskenbit eins weiterschieben
        }
    }






void hole_mw(void)
    {
	_CS_AD_ON;
    while (_DRDY)
        {
        ;                   // warten bis A/D-Wandler fertig
        };
    write_to_ad(0X38);               // Vorbereitung Messwert abholen
    read_from_ad();                  // 8 Bit auslesen ==> HB
    mw_hb=datenwert;
    read_from_ad();                  // 8 Bit auslesen ==> LB
    mw_lb=datenwert;
	mw = (mw_hb<<8);
	mw |= (mw_lb);
    mw &= 0XFFF0;                    // Aufloesung auf 12 bit begrenzen
    mw >>= 4;
    mw &= 0X0FFF;
    mw +=0X400;                      // Offset 400hex hinzufuegen
	mw_hb = (mw>>8);
	mw_lb = (mw & 0x00FF);
	_CS_AD_OFF;
    }





void message1_to_can(void)
    {

	unsigned char i = 0;
	unsigned int idm = 0xFFFF;

	//CAN_getMOB
	CANPAGE	= 0x10;	// mob = 1

	while ((CANCDMOB & (1<<RPLV))) {;};
    crc = 2;                         // CRC-Vorgabewert fuer message 1
    crc ^= id_hb;
    crc ^= umlauf;
    crc ^= mw_hb;
    crc ^= mw_lb;
    crc ^= prog_stat;
    crc ^= weekunit_low;

	data[0] = id_hb;
	data[1] = umlauf;
	data[2] = mw_hb;
	data[3] = mw_lb;
	data[4] = prog_stat;
	data[5] = weekunit_low;
	data[6] = crc;

//*************CAN_enableMOB****************************
	//CAN_setInterrupt
	CANIE2 |= (1<<IEMOB1);
	//CAN_setIDMask
    CANIDM2 = (uint8_t)(idm << 5); 
    CANIDM1 = (uint8_t)(idm >> 3);
	//CAN_setID
    CANIDT2 = (uint8_t)(idf1 << 5); 
    CANIDT1 = (uint8_t)(idf1 >> 3);
	//CAN_setData
	CANCDMOB |= (1<<DLC0);
	CANCDMOB |= (1<<DLC1);
	CANCDMOB |= (1<<DLC2);
	CANCDMOB &= ~(1<<DLC3);
	for(i = 0; i < 8; i++)
	{
		CANMSG	= data[i];
	}
	//CAN_set_Mode
	CANCDMOB &= ~(1<<CONMOB0);
	CANCDMOB |= (1<<CONMOB1);
	CANCDMOB |= (1<<RPLV);
	CANIDT4 |= (1<<RTRTAG);

}




void message2_to_can()
    {

	unsigned char i = 0;
	unsigned int id = 0;
	unsigned int idm = 0;

	//CAN_getMOB
	CANPAGE	= 0x20;	// mob = 1

	while ((CANCDMOB & (1<<RPLV))) {;};
    crc = 3;                             // CRC-Vorgabewert fuer message 2
    crc ^= id_hb;
    crc ^= YEAR;
    crc ^= weekunit_high;
    crc ^= weekunit_low;


	id = idf2;
	idm = 0xFFFF;

	data[0] = id_hb;
	data[1] = YEAR;
	data[2] = weekunit_high;
	data[3] = weekunit_low;
	data[4] = crc;

//*************CAN_enableMOB****************************
	//CAN_setInterrupt
	CANIE2 |= (1<<IEMOB2);
	//CAN_setIDMask
    CANIDM2 = (uint8_t)(idm << 5); 
    CANIDM1 = (uint8_t)(idm >> 3);
	//CAN_setID
    CANIDT2 = (uint8_t)(id << 5); 
    CANIDT1 = (uint8_t)(id >> 3);
	//CAN_setData
	CANCDMOB |= (1<<DLC0);
	CANCDMOB &= ~(1<<DLC1);
	CANCDMOB |= (1<<DLC2);
	CANCDMOB &= ~(1<<DLC3);
	for(i = 0; i < 8; i++)
	{
		CANMSG	= data[i];
	}
	//CAN_set_Mode
	CANCDMOB &= ~(1<<CONMOB0);
	CANCDMOB |= (1<<CONMOB1);
	CANCDMOB |= (1<<RPLV);
	CANIDT4 |= (1<<RTRTAG);

    }





void test_can_status()
    {
    prog_stat &= ~(1<<2);           // "Init-Flag" loeschen
    datenwert = CANGSTA;            // Statusreg CAN lesen
    prog_stat &= ~(1<<4);			// PhysicalLayerFehler nicht ersehbar

    if (datenwert & 0X01)
        {
        prog_stat |= (1<<5); 	    // "Error Passiv"-Flag gesetzt Bit5
        }
    else
        {
        prog_stat &= ~(1<<5);
        }
    if (datenwert & 0X02)
        {
                                     // "Bus off"-Flag gesetzt
        _EN_PH_LAY_OFF;		         // Physical Layer abschalten dh. Bus abtrennen
        _RES_AD_ON;		             // Hardware Reset A/D-Wandler
        prog_stat |= (1<<6);         // bewirkt neue init in main() Bit6
        _delay_ms(1000);        	 // 1 Sekunde warten
        }
    else
        {
        prog_stat &= ~(1<<6);
        }
    }





int main()
	{

    hardwareinit();
	adcaninit();
    hole_mw();                  // aktuellen Messwert vom A/D-Wandler holen
    message1_to_can();          // Messwerttelegramm an Can-Controller uebertragen
    message2_to_can();          // Seriennummerntelegramm an Can-Controller uebertragen
    _EN_PH_LAY_ON;	            // Physical Layer aktivieren ==> Busverbindung freigeben
    while (1)
        {
        hole_mw();              // aktuellen Messwert vom A/D-Wandler holen
        message1_to_can();      // Messwerttelegramm an Can-Controller uebertragen
        test_can_status();      // Programmstatus ermitteln
        if (prog_stat & 0b01000000)
            {
								// bei "Bus off"
            adcaninit();             // neu initialisieren
            prog_stat |= (1<<6);// Markierung für bus off Bit6
            message2_to_can();  // Seriennummerntelegramm an Can-Controller uebertragen
            _EN_PH_LAY_ON;      // Physical Layer aktivieren ==> Busverbindung freigeben
            }
		umlauf++;               // Umlaufzaehler erhoehen
        clrwdg();               // Watchdog zuruecksetzen
        };

	}