/*
 * Pruefcomputer V1_5_2.cpp
 *
 * Created: 12.09.2016 08:48:15
 * Author : Doege/ Theilken
 */ 

#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdio.h>
#include <stdlib.h>
#include "definitionen.h"

// Vergabe vom Namensraum
using namespace std;

uint8_t zustand;


#define BAUDRATE 9600
#define BAUD_PRESCALLER (((F_CPU / (BAUDRATE * 16UL))) - 1)


/*Deklaration der genutzten Funktionen*/

void USART_init(void);					
void USART_Transmit(unsigned char data );
void data_send (char str[]);
void Ausgang_high(int Pin);
void Ausgang_low(int Pin);
void Name(char Name_auswertung_array [],char uart_get_array []);
void loesch(int kreuztest_array[],int verbidung_array[],int ergebnis_messung_array[]);
void Verbindungstest(int Pin_Anzahl,int verbidung_array []);
void Kreuztest (int Pin_Anzahl, int kreuztest_array[]);
void Objekt_Schalter_AUS (int kreuztest_array[], int verbidung_array[],int ergebnis_messung_array[]);
void Objekt_Schalter_AN (int kreuztest_array[], int verbidung_array[],int ergebnis_messung_array[]);
uint8_t uart_get(void);
void Leitung_kodierung(int Leitung_kodierung_array[],char uart_get_array[],int Leitung_array[][28]);
	
/*******************************Beginn Hauptprogramm*******************************/
	
int main(void)
{
	USART_init();       // Aufruf der Initialisierungsfunktion für die USART-Schnittstelle

	
		// Eingänge definieren und Pullups einschalten
		
		DDRB	&= ~((1<<PB4)|(1<<PB5))	;														//PIN 11, 10	/ PB4 = Pin 27,PB5 = Pin 28
		PORTB	|=	(1<<PB4)|(1<<PB5);

		DDRH	&= ~((1<<PH3)|(1<<PH4)|(1<<PH5)|(1<<PH6));										//PIN 9,8,7,6	/ PH3 = 23 / PH4 =24 / PH 5 = 25 / PH6 = 26
		PORTH	|=	(1<<PH3)|(1<<PH4)|(1<<PH5)|(1<<PH6);
		
		DDRE	&= ~((1<<PE3)|(1<<PE4)|(1<<PE5));													//PIN 2,3,5 / PE4 =19 / PE5 = 20 / PE3 = 22
		PORTE	|=	(1<<PE3)|(1<<PE4)|(1<<PE5);
		
		DDRG	&= ~((1<<PG5)|(1<<PG1)|(1<<PG2));													//PIN 4 PIN 39,40  / PG1 = 0 /PG2 =  1 /PG5 =  21
		PORTG	|=	(1<<PG5)|(1<<PG1)|(1<<PG2);
		
		DDRA	&= ~((1<<PA0)|(1<<PA1)|(1<<PA2)|(1<<PA3)|(1<<PA4)|(1<<PA5)|(1<<PA6)|(1<<PA7));		// PIN 22-29 / PA7 = 12/ PA6= 13 / PA5 = 12/ PA5 = 13 / PA4 =14
		PORTA	|=	(1<<PA0)|(1<<PA1)|(1<<PA2)|(1<<PA3)|(1<<PA4)|(1<<PA5)|(1<<PA6)|(1<<PA7);	// PA3 = 15 / PA2 = 16 / PA1 = 17 / PA0 = 18
		
		DDRC	&= ~((1<<PC0)|(1<<PC1)|(1<<PC2)|(1<<PC3)|(1<<PC4)|(1<<PC5)|(1<<PC6)|(1<<PC7));		//PIN 30 - 37 / PC0 = 4 / PC1 = 5 / PC2= 6/ PC3 = 7 / PC4 = 8
		PORTC	|=	(1<<PC0)|(1<<PC1)|(1<<PC2)|(1<<PC3)|(1<<PC4)|(1<<PC5)|(1<<PC6)|(1<<PC7);		// PC5 = 9 / PC6 = 10 / PC7 = 11
		
		DDRD	&= ~(1<<PD7);																		//PIN 38 / PD7 = Pin 2
		PORTD	|=	(1<<PD7);
		
		
		
		//Ausgänge schalten
		
		DDRB	|=	(1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3);												//PIN 53 -50
		DDRL	|=	(1<<PL0)|(1<<PL1)|(1<<PL2)|(1<<PL3)|(1<<PL4)|(1<<PL5)|(1<<PL6)|(1<<PL7);			//PIN 49 -42
		DDRG	|=	(1<<PG0);																			//PIN 41
		DDRF	|=	(1<<PF0)|(1<<PF1)|(1<<PF2)|(1<<PF3)|(1<<PF4)|(1<<PF5)|(1<<PF6)|(1<<PF7);			//PIN 97-90
		DDRK	|=	(1<<PK0)|(1<<PK1)|(1<<PK2)|(1<<PK3)|(1<<PK4)|(1<<PK5)|(1<<PK6)|(1<<PK7);			// PIN 89 -82
		
		
		
		

//Deklarationen Global
		char uart_get_array[30];
		char zeichen;
		char Name_auswertung_array [25];
		int Pin_Anzahl =0;
		int kreuztest_array [29];
		int verbidung_array [29];
		char message[80];
		int objekt_array[28];
		int ergebnis_messung_array[28];
		char Pruefung;
		int Leitung_kodierung_array[28];
		int Leitung_array[3][28];
	//----------------------------------------------------------------------------------------------------------------------------------
	while(1)
	{        
		int i = 0;
		do 
		{
		zeichen = uart_get();
		uart_get_array[i]=zeichen;
		i=i++;				
		}
		while ((zeichen!='#')||(i==25));	// Zeichen ungleich # oder i =25
		
		Pruefung = uart_get_array[0];	
							
					switch (Pruefung)
					{
						// Benutzer Einlesen
						case 49:	// Vom Display 0x31 0x23
						Name(Name_auswertung_array,uart_get_array);
						break;
						//---------------------------------------------------------------------------------------------------------
												
						// Pin_anzahl Eingabe
						case 50:	// Vom Display 0x32 0x23 
						//Pin_Anzahl=(int)uart_get_array[1];
						break;
						// -------------------------------------------------------------------------------------------------------------
						
						// Manueller Test: Zuweisung der Leitungen
						case 51:	// Vom Display 0x33 0x23 
						Leitung_kodierung(Leitung_kodierung_array,uart_get_array,Leitung_array);
						break;
						//----------------------------------------------------------------------------------------------------------------
					
						// Pruefung Verbindungstest "Objektschalter AUS"
						case 52:	// Vom Display 0x34 0x23 
						Pin_Anzahl=3;
						Verbindungstest(Pin_Anzahl,verbidung_array);
						Objekt_Schalter_AUS(verbidung_array,kreuztest_array,ergebnis_messung_array);
						//loesch(kreuztest_array,verbidung_array,ergebnis_messung_array);	// Initialisiern aller Arrays auf 0
						break;
						//----------------------------------------------------------------------------------------------------------------

						// Pruefung Verbindungstest "Objektschalter AN"
						case 53:	// Vom Display 0x35 0x23 
						Verbindungstest(Pin_Anzahl,verbidung_array);
						Objekt_Schalter_AN(verbidung_array,kreuztest_array,ergebnis_messung_array);
						break;
						//----------------------------------------------------------------------------------------------------------------

						// Pruefung Kreuztest
						case 54:	// Vom Display 0x36 0x23 
						Pin_Anzahl=3;
						Kreuztest(Pin_Anzahl,kreuztest_array);
						break;
						//----------------------------------------------------------------------------------------------------------------

						// löschen alle arrays. Setzte alle Anzeigen auf Null
						case 58:	// Vom Display 0x40 0x23 
						loesch(kreuztest_array,verbidung_array,ergebnis_messung_array);
						break;
						//----------------------------------------------------------------------------------------------------------------
						
						//Wenn keine Case übereinstimmung 
						default:
							Pruefung = 9;
							sprintf(message,"ErgebnisHptSch.pruefung.val=%d\n",Pruefung);
							data_send(message);
							_delay_ms(2000);
							
						break;
					} // ENDE "switch"

			
		} // ENDE "while"
	return 0;
}
/**************************Ende Hauptprogramm**************************/



//Definition der Funktionen
void USART_init(void)
{
	/*	UBRRnH	=>	(UART Baud Rate Register) hier wird die Datenübertragungsgeschwindigkeit festgelegt. 
		UCSRnB	=>	(UART Control and Status Register B) hier wird die Art der Verwendung festgelegt.
		UCSRnC	=>	(UART Control and Status Register C) hier wird der Aufbau des Signals festgelegt.*/
	
	UBRR1H = (uint8_t)(BAUD_PRESCALLER>>8);
	UBRR1L = (uint8_t)(BAUD_PRESCALLER);
	UCSR1B = (1<<RXEN1)|(1<<TXEN1)|(1<<RXCIE1);		// Senden, Empfangen und Rx-Interrupt 
	UCSR1C = (1<<USBS1)|(1<<UCSZ11)|(1<<UCSZ10);	// 2 Stopbits, 7 Datenbits
}
uint8_t uart_get(void)
{
	while (!(UCSR1A & (1<<RXC1))){}
		return UDR1;
}
void Ausgang_high (int Pin)
{
	if (Pin==0)Output_high_Pin0;
	if (Pin==1)Output_high_Pin1;
	if (Pin==2)Output_high_Pin2;
	if (Pin==3)Output_high_Pin3;
	if (Pin==4)Output_high_Pin4;
	if (Pin==5)Output_high_Pin5;
	if (Pin==6)Output_high_Pin6;
	if (Pin==7)Output_high_Pin7;
	if (Pin==8)Output_high_Pin8;
	if (Pin==9)Output_high_Pin9;
	if (Pin==10)Output_high_Pin10;
	if (Pin==11)Output_high_Pin11;
	if (Pin==12)Output_high_Pin12;
	if (Pin==13)Output_high_Pin13;
	if (Pin==14)Output_high_Pin14;
	if (Pin==15)Output_high_Pin15;
	if (Pin==16)Output_high_Pin16;
	if (Pin==17)Output_high_Pin17;
	if (Pin==18)Output_high_Pin18;
	if (Pin==19)Output_high_Pin19;
	if (Pin==20)Output_high_Pin20;
	if (Pin==21)Output_high_Pin21;
	if (Pin==22)Output_high_Pin22;
	if (Pin==23)Output_high_Pin23;
	if (Pin==24)Output_high_Pin24;
	if (Pin==25)Output_high_Pin25;
	if (Pin==26)Output_high_Pin26;
	if (Pin==27)Output_high_Pin27;
	if (Pin==28)Output_high_Pin28;
}
void Ausgang_low (int Pin)
{
	if (Pin==0) Output_low_Pin0;
	if (Pin==1) Output_low_Pin1;
	if (Pin==2) Output_low_Pin2;
	if (Pin==3) Output_low_Pin3;
	if (Pin==4) Output_low_Pin4;
	if (Pin==5) Output_low_Pin5;
	if (Pin==6) Output_low_Pin6;
	if (Pin==7) Output_low_Pin7;
	if (Pin==8) Output_low_Pin8;
	if (Pin==9) Output_low_Pin9;
	if (Pin==10) Output_low_Pin10;
	if (Pin==11) Output_low_Pin11;
	if (Pin==12) Output_low_Pin12;
	if (Pin==13) Output_low_Pin13;
	if (Pin==14) Output_low_Pin14;
	if (Pin==15) Output_low_Pin15;
	if (Pin==16) Output_low_Pin16;
	if (Pin==17) Output_low_Pin17;
	if (Pin==18) Output_low_Pin18;
	if (Pin==19) Output_low_Pin19;
	if (Pin==20) Output_low_Pin20;
	if (Pin==21) Output_low_Pin21;
	if (Pin==22) Output_low_Pin22;
	if (Pin==23) Output_low_Pin23;
	if (Pin==24) Output_low_Pin24;
	if (Pin==25) Output_low_Pin25;
	if (Pin==26) Output_low_Pin26;
	if (Pin==27) Output_low_Pin27;
	if (Pin==28) Output_low_Pin28;
}
void USART_Transmit(unsigned char data )
{
	
	//Wait for empty transmit buffer
	
	while
	( !( UCSR1A & (1<<UDRE1)) );

	//Put data into buffer, sends the data

	UDR1 = data;
}
void data_send (char str[])
{
	int i =0;
	while (str [i] != '\n')
	{
		USART_Transmit(str[i]);
		i++;
	}
	USART_Transmit(0xFF);
	USART_Transmit(0xFF);
	USART_Transmit(0xFF);
}
void loesch( int kreuztest_array [],int verbidung_array [],int ergebnis_messung_array[])		// Löscht alle Arrays
{
		//Initialisieren der Arrays auf Null
		//kreuztest_array [29]= 0; 
		verbidung_array [29];
		ergebnis_messung_array[28];
}
void Kreuztest(int Pin_Anzahl,int kreuztest_array[])
{
	char message[80];
	for (int a =0 ; a <= Pin_Anzahl; a++)
	{
		Ausgang_high(a);
// Abfrage Eingang
		
		if  (Input_PIN_0(zustand) == 0 )		kreuztest_array[0]=a;
		if  (Input_PIN_1(zustand) == 0 )		kreuztest_array[1]=a;
		if  (Input_PIN_2(zustand) == 0 )		kreuztest_array[2]=a;
		if  (Input_PIN_3(zustand) == 0 )		kreuztest_array[3]=a;
		if  (Input_PIN_4(zustand) == 0 )		kreuztest_array[4]=a;
		if  (Input_PIN_5(zustand) == 0 )		kreuztest_array[5]=a;
		if  (Input_PIN_6(zustand) == 0 )		kreuztest_array[6]=a;
		if  (Input_PIN_7(zustand) == 0 )		kreuztest_array[7]=a;
		if  (Input_PIN_8(zustand) == 0 )		kreuztest_array[8]=a;
		if  (Input_PIN_9(zustand) == 0 )		kreuztest_array[9]=a;
		if  (Input_PIN_10(zustand) == 0 )		kreuztest_array[10]=a;
		if  (Input_PIN_11(zustand) == 0 )		kreuztest_array[11]=a;
		if  (Input_PIN_12(zustand) == 0 )		kreuztest_array[12]=a;
		if  (Input_PIN_13(zustand) == 0 )		kreuztest_array[13]=a;
		if  (Input_PIN_14(zustand) == 0 )		kreuztest_array[14]=a;
		if  (Input_PIN_15(zustand) == 0 )		kreuztest_array[15]=a;
		if  (Input_PIN_16(zustand) == 0 )		kreuztest_array[16]=a;
		if  (Input_PIN_17(zustand) == 0 )		kreuztest_array[17]=a;
		if  (Input_PIN_18(zustand) == 0 )		kreuztest_array[18]=a;
		if  (Input_PIN_19(zustand) == 0 )		kreuztest_array[19]=a;
		if  (Input_PIN_20(zustand) == 0 )		kreuztest_array[20]=a;
		if  (Input_PIN_21(zustand) == 0 )		kreuztest_array[21]=a;
		if  (Input_PIN_22(zustand) == 0 )		kreuztest_array[22]=a;
		if  (Input_PIN_23(zustand) == 0 )		kreuztest_array[23]=a;
		if  (Input_PIN_24(zustand) == 0 )		kreuztest_array[24]=a;
		if  (Input_PIN_25(zustand) == 0 )		kreuztest_array[25]=a;
		if  (Input_PIN_26(zustand) == 0 )		kreuztest_array[26]=a;
		if  (Input_PIN_27(zustand) == 0 )		kreuztest_array[27]=a;
		if  (Input_PIN_28(zustand) == 0 )		kreuztest_array[28]=a;
	
	
	
		_delay_ms(300); // Ganz wichitg die Zeit drin zu lassen sonst kann der Eingang nicht so schnell überprüft werden!!!!
		Ausgang_low(a);
		
	 }
	 
	 
		 sprintf(message,"Fehler_Hpt.va0.val=%d\n",kreuztest_array[0]);
		 data_send(message);
		sprintf(message,"Fehler_Hpt.va1.val=%d\n",kreuztest_array[1]);
		data_send(message);
		sprintf(message,"Fehler_Hpt.va2.val=%d\n",kreuztest_array[2]);
		data_send(message);
	 
	
} 
void Verbindungstest (int Pin_Anzahl,int verbidung_array [])
{
	
	verbidung_array [29];			// verbindung_array auf 0 initialisieren
	for (int a=0;a<=Pin_Anzahl;a++) // Solange die Variable a kleiner gleich der Variable Pin_Anzahl zähle hoch
	{

		Ausgang_high(a);	//Funktion Pin wird auf High gesetzt
							//Zustand => BIT Ergebnis
		
	if  (Input_PIN_0(zustand) == 0 )		verbidung_array[0]=1;
	if  (Input_PIN_1(zustand) == 0 )		verbidung_array[1]=1;
	if  (Input_PIN_2(zustand) == 0 )		verbidung_array[2]=1;
	if  (Input_PIN_3(zustand) == 0 )		verbidung_array[3]=1;
	if  (Input_PIN_4(zustand) == 0 )		verbidung_array[4]=1;
	if  (Input_PIN_5(zustand) == 0 )		verbidung_array[5]=1;
	if  (Input_PIN_6(zustand) == 0 )		verbidung_array[6]=1;
	if  (Input_PIN_7(zustand) == 0 )		verbidung_array[7]=1;
	if  (Input_PIN_8(zustand) == 0 )		verbidung_array[8]=1;
	if  (Input_PIN_9(zustand) == 0 )		verbidung_array[9]=1;
	if  (Input_PIN_10(zustand) == 0 )		verbidung_array[10]=1;
	if  (Input_PIN_11(zustand) == 0 )		verbidung_array[11]=1;
	if  (Input_PIN_12(zustand) == 0 )		verbidung_array[12]=1;
	if  (Input_PIN_13(zustand) == 0 )		verbidung_array[13]=1;
	if  (Input_PIN_14(zustand) == 0 )		verbidung_array[14]=1;
	if  (Input_PIN_15(zustand) == 0 )		verbidung_array[15]=1;
	if  (Input_PIN_16(zustand) == 0 )		verbidung_array[16]=1;
	if  (Input_PIN_17(zustand) == 0 )		verbidung_array[17]=1;
	if  (Input_PIN_18(zustand) == 0 )		verbidung_array[18]=1;
	if  (Input_PIN_19(zustand) == 0 )		verbidung_array[19]=1;
	if  (Input_PIN_20(zustand) == 0 )		verbidung_array[20]=1;
	if  (Input_PIN_21(zustand) == 0 )		verbidung_array[21]=1;
	if  (Input_PIN_22(zustand) == 0 )		verbidung_array[22]=1;
	if  (Input_PIN_23(zustand) == 0 )		verbidung_array[23]=1;
	if  (Input_PIN_24(zustand) == 0 )		verbidung_array[24]=1;
	if  (Input_PIN_25(zustand) == 0 )		verbidung_array[25]=1;
	if  (Input_PIN_26(zustand) == 0 )		verbidung_array[26]=1;
	if  (Input_PIN_27(zustand) == 0 )		verbidung_array[27]=1;
	if  (Input_PIN_28(zustand) == 0 )		verbidung_array[28]=1; 
			
			_delay_ms(300); // Zeit für Optokoppler zum erreichen eines definierten Zustands
			
		Ausgang_low(a);
		
	}
}
void Name(char Name_auswertung_array [],char uart_get_array[])
{
for (int a =0; a<=20;a++)
{
	Name_auswertung_array[a]=0;
	
}

int i = 0;
char message [80];
do
{
	Name_auswertung_array[i]=uart_get_array[i+1];
	
	i++;
}while ((uart_get_array[i+1]!= '#')||(i==25));



}
void Leitung_kodierung(int Leitung_kodierung_array[],char uart_get_array[],int Leitung_array[][28])
{
	
	int  Wert;
		for (int a =0; a<=28;a++)
		{
			Leitung_kodierung_array[a]=0;
			
		}

		int i = 0;
		int spalten_zehner =0;
		int spalten_einer =1;
		char message [80];
	
		do
		{
			Leitung_kodierung_array[i]=uart_get_array[i+1];
		
				
			Leitung_kodierung_array[i]=Leitung_kodierung_array[i]-48;		// -48 weil char 0 =int 48 ist
		
			Leitung_array[0][i]=Leitung_kodierung_array[spalten_zehner];
			Leitung_array[1][i]=Leitung_kodierung_array[spalten_einer];	
					
			//		Leitung_array[2][i]=Leitung_array[0][i]*10;
			//		Leitung_array[2][i]=Leitung_array[2][i]+Leitung_array[1][i];
					
					i++;
					spalten_zehner=spalten_zehner +2;
					spalten_einer=spalten_einer +2;
		}while ((uart_get_array[i+1]!= '#')||(i==28));
		
		
			
	
	
		sprintf (message,"Manuell_Ausw.t5.txt=%c%d%c\n",34,Leitung_array[2][0],34);
		data_send(message);
	
}
void Objekt_Schalter_AUS(int verbidung_array[], int kreuztest_array[],int ergebnis_messung_array[])
{
	char message [80]; // Buffer sprintf Befehl
	for (int i=0; i<=3 ; i++ )
	{
		if (verbidung_array[1]==1)
		{
			ergebnis_messung_array[0]=1;
		}
	}
	
	sprintf(message,"ErgebnisHptSch.ergebnis.val=%d\n",ergebnis_messung_array[0]);
	data_send(message);
	
	
}
void Objekt_Schalter_AN(int verbidung_array[], int kreuztest_array[], int ergebnis_messung_array[])
{
	char message [80];

	int i =0;
	for (int a=0;a<=4;a++)
	{
		
		if(verbidung_array[a]==1)
		{
			i++;
		}
	}
	
	if ((verbidung_array[5]==1)&&(i==4))
	{
		ergebnis_messung_array[0]=2;
	}

	
	sprintf(message,"ErgebnisHptSch.ergebnis.val=%d\n",ergebnis_messung_array[0]);
	data_send(message);

}