//----------------------------------------------------------------------------------
void SeriellesNetzwerkEmpfaenger(void)
{


//Wenn sich der Reset Pin nicht geändert hat,
if(SeriellerPin_Reset == SeriellerPin_Reset_Merker)
{

//wenn sich das Hi Pin geändert hat,
if(SeriellerPin_Hi != SeriellerPin_Hi_Merker)
{
//dann ist das Momentan Bit ist Hi.
EmpfaengerRegister[EmpfaengerRegisterZaehler] = 1;

//Verriegeln
SeriellerPin_Hi_Merker = SeriellerPin_Hi;

//dann nechstes Bit
++ EmpfaengerRegisterZaehler;
}


//wenn sich das Lo Pin geändert hat,
if(SeriellerPin_Lo != SeriellerPin_Lo_Merker)
{
//dann ist das Momentan Bit ist Lo.
EmpfaengerRegister[EmpfaengerRegisterZaehler] = 0;

//Verriegeln
SeriellerPin_Lo_Merker = SeriellerPin_Lo;

//dann nechstes Bit
++ EmpfaengerRegisterZaehler;
}
}

//wenn nicht
else
{
//Wenn schon mal ganz empfangen wurde
if(EmpfaengerRiegelReset > 1)
{
//Empfänger als fertig Markiren
FertigEmpfaenger = 1;
}

++ FertigEmpfaenger;

//dann erstes Bit
EmpfaengerRegisterZaehler = 1;

//Verriegeln
SeriellerPin_Reset_Merker = SeriellerPin_Reset;
}


}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void NetzwerkPinsEntprellen(void)
{

//Sender
Pin_SeriellerPort_Hi = SeriellerPort_Hi;
Pin_SeriellerPort_Lo = SeriellerPort_Lo;
Pin_SeriellerPort_Reset = SeriellerPort_Reset;

//Empfänger
//Hi
if(Pin_SeriellerPin_Hi == 0)
{
SeriellerPin_Hi_Zaehler = 0;
}

if(SeriellerPin_Hi_Zaehler >= SeriellerPin_Prell_Zeit)
{
SeriellerPin_Hi = 1;
}
else
{
++ SeriellerPin_Hi_Zaehler;
SeriellerPin_Hi = 0;
}

//Lo
if(Pin_SeriellerPin_Lo == 0)
{
SeriellerPin_Lo_Zaehler = 0;
}

if(SeriellerPin_Lo_Zaehler >= SeriellerPin_Prell_Zeit)
{
SeriellerPin_Lo = 1;
}
else
{
++ SeriellerPin_Lo_Zaehler;
SeriellerPin_Lo = 0;
}

//Reset
if(Pin_SeriellerPin_Reset == 0)
{
SeriellerPin_Reset_Zaehler = 0;
}

if(SeriellerPin_Reset_Zaehler >= SeriellerPin_Prell_Zeit)
{
SeriellerPin_Reset = 1;
}
else
{
++ SeriellerPin_Reset_Zaehler;
SeriellerPin_Reset = 0;
}


} // Ende der Funktion Verz()
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void SerielleBitsZuordnenEmpfaenger(void)
{

//Auszug
if( EmpfaengerRegister[1] == 0) { AuszugWert &= ~ 1 ; } // 0 setzen
else { AuszugWert |= 1 ; } // 1 setzen

if( EmpfaengerRegister[2] == 0) { AuszugWert &= ~ 2 ; } // 0 setzen
else { AuszugWert |= 2 ; } // 1 setzen

if( EmpfaengerRegister[3] == 0) { AuszugWert &= ~ 4 ; } // 0 setzen
else { AuszugWert |= 4 ; } // 1 setzen

if( EmpfaengerRegister[4] == 0) { AuszugWert &= ~ 8 ; } // 0 setzen
else { AuszugWert |= 8 ; } // 1 setzen

if( EmpfaengerRegister[5] == 0) { AuszugWert &= ~ 16 ; } // 0 setzen
else { AuszugWert |= 16 ; } // 1 setzen

if( EmpfaengerRegister[6] == 0) { AuszugWert &= ~ 32 ; } // 0 setzen
else { AuszugWert |= 32 ; } // 1 setzen

if( EmpfaengerRegister[7] == 0) { AuszugWert &= ~ 64 ; } // 0 setzen
else { AuszugWert |= 64 ; } // 1 setzen

if( EmpfaengerRegister[8] == 0) { AuszugWert &= ~ 128 ; } // 0 setzen
else { AuszugWert |= 128 ; } // 1 setzen

if( EmpfaengerRegister[9] == 0) { AuszugWert &= ~ 256 ; } // 0 setzen
else { AuszugWert |= 256 ; } // 1 setzen

if( EmpfaengerRegister[10] == 0) { AuszugWert &= ~ 512 ; } // 0 setzen
else { AuszugWert |= 512 ; } // 1 setzen

if( EmpfaengerRegister[11] == 0) { AuszugWert &= ~ 1024 ; } // 0 setzen
else { AuszugWert |= 1024 ; } // 1 setzen

if( EmpfaengerRegister[12] == 0) { AuszugWert &= ~ 2048 ; } // 0 setzen
else { AuszugWert |= 2048 ; } // 1 setzen

if( EmpfaengerRegister[13] == 0) { AuszugWert &= ~ 4096 ; } // 0 setzen
else { AuszugWert |= 4096 ; } // 1 setzen

if( EmpfaengerRegister[14] == 0) { AuszugWert &= ~ 8192 ; } // 0 setzen
else { AuszugWert |= 8192 ; } // 1 setzen

if( EmpfaengerRegister[15] == 0) { AuszugWert &= ~16384 ; } // 0 setzen
else { AuszugWert |= 16384 ; } // 1 setzen

if( EmpfaengerRegister[16] == 0) { AuszugWert &= ~32768 ; } // 0 setzen
else { AuszugWert |= 32768 ; } // 1 setzen

if( EmpfaengerRegister[17] == 0) { AuszugWert &= ~65536 ; } // 0 setzen
else { AuszugWert |= 65536 ; } // 1 setzen


//Temperatur
if( EmpfaengerRegister[18] == 0) { TemperaturEmpfangen &= ~ 1 ; } // 0 setzen
else { TemperaturEmpfangen |= 1 ; } // 1 setzen

if( EmpfaengerRegister[19] == 0) { TemperaturEmpfangen &= ~ 2 ; } // 0 setzen
else { TemperaturEmpfangen |= 2 ; } // 1 setzen

if( EmpfaengerRegister[20] == 0) { TemperaturEmpfangen &= ~ 4 ; } // 0 setzen
else { TemperaturEmpfangen |= 4 ; } // 1 setzen

if( EmpfaengerRegister[21] == 0) { TemperaturEmpfangen &= ~ 8 ; } // 0 setzen
else { TemperaturEmpfangen |= 8 ; } // 1 setzen

if( EmpfaengerRegister[22] == 0) { TemperaturEmpfangen &= ~ 16 ; } // 0 setzen
else { TemperaturEmpfangen |= 16 ; } // 1 setzen

if( EmpfaengerRegister[23] == 0) { TemperaturEmpfangen &= ~ 32 ; } // 0 setzen
else { TemperaturEmpfangen |= 32 ; } // 1 setzen

if( EmpfaengerRegister[24] == 0) { TemperaturEmpfangen &= ~ 64 ; } // 0 setzen
else { TemperaturEmpfangen |= 64 ; } // 1 setzen

if( EmpfaengerRegister[25] == 0) { TemperaturEmpfangen &= ~ 128; } // 0 setzen
else { TemperaturEmpfangen |= 128; } // 1 setzen

if( EmpfaengerRegister[26] == 0) { TemperaturEmpfangen &= ~ 256; } // 0 setzen
else { TemperaturEmpfangen |= 256; } // 1 setzen

if( EmpfaengerRegister[27] == 0) { TemperaturEmpfangen &= ~ 512; } // 0 setzen
else { TemperaturEmpfangen |= 512; } // 1 setzen

//Bereit
if( EmpfaengerRegister[28] == 0) { SystemStatus &= ~ 1 ; } // 0 setzen
else { SystemStatus |= 1 ; } // 1 setzen

if( EmpfaengerRegister[29] == 0) { SystemStatus &= ~ 2 ; } // 0 setzen
else { SystemStatus |= 2 ; } // 1 setzen

//Teilungsfaktor
if( EmpfaengerRegister[30] == 0) { Teilingsfaktor &= ~ 1 ; } // 0 setzen
else { Teilingsfaktor |= 1 ; } // 1 setzen

if( EmpfaengerRegister[31] == 0) { Teilingsfaktor &= ~ 2 ; } // 0 setzen
else { Teilingsfaktor |= 2 ; } // 1 setzen

//Hellichkeit
if( EmpfaengerRegister[32] == 0) { Hellichkeit &= ~ 1 ; } // 0 setzen
else { Hellichkeit |= 1 ; } // 1 setzen

if( EmpfaengerRegister[33] == 0) { Hellichkeit &= ~ 2 ; } // 0 setzen
else { Hellichkeit |= 2 ; } // 1 setzen

if( EmpfaengerRegister[34] == 0) { Hellichkeit &= ~ 4 ; } // 0 setzen
else { Hellichkeit |= 4 ; } // 1 setzen

if( EmpfaengerRegister[35] == 0) { Hellichkeit &= ~ 8 ; } // 0 setzen
else { Hellichkeit |= 8 ; } // 1 setzen

//Auszug
if( EmpfaengerRegister[36] == 0) { Auszug &= ~ 1 ; } // 0 setzen
else { Auszug |= 1 ; } // 1 setzen

if( EmpfaengerRegister[37] == 0) { Auszug &= ~ 2 ; } // 0 setzen
else { Auszug |= 2 ; } // 1 setzen

//Sonderfunktionen
if( EmpfaengerRegister[38] == 0) { LAN_nicht_Verbunden &= ~ 1 ; } // 0 setzen
else { LAN_nicht_Verbunden |= 1 ; } // 1 setzen

if( EmpfaengerRegister[39] == 0) { Nullpunkt_festlegen &= ~ 1 ; } // 0 setzen
else { Nullpunkt_festlegen |= 1 ; } // 1 setzen

if( EmpfaengerRegister[40] == 0) { Temp_Ausgleich_EIN &= ~ 1 ; } // 0 setzen
else { Temp_Ausgleich_EIN |= 1 ; } // 1 setzen

if( EmpfaengerRegister[41] == 0) { Temp_Ausgleich_AUS &= ~ 1 ; } // 0 setzen
else { Temp_Ausgleich_AUS |= 1 ; } // 1 setzen

if( EmpfaengerRegister[42] == 0) { Joistik_EIN &= ~ 1 ; } // 0 setzen
else { Joistik_EIN |= 1 ; } // 1 setzen

if( EmpfaengerRegister[43] == 0) { Joistik_AUS &= ~ 1 ; } // 0 setzen
else { Joistik_AUS |= 1 ; } // 1 setzen

//FreieEmpfaengerFunktion
if( EmpfaengerRegister[44] == 0) { FreieEmpfaengerFunktion_1 &= ~ 1 ; } // 0 setzen
else { FreieEmpfaengerFunktion_1 |= 1 ; } // 1 setzen

if( EmpfaengerRegister[45] == 0) { FreieEmpfaengerFunktion_2 &= ~ 1 ; } // 0 setzen
else { FreieEmpfaengerFunktion_2 |= 1 ; } // 1 setzen

if( EmpfaengerRegister[46] == 0) { FreieEmpfaengerFunktion_3 &= ~ 1 ; } // 0 setzen
else { FreieEmpfaengerFunktion_3 |= 1 ; } // 1 setzen

//FreieEmpfaengerFunktion
if( EmpfaengerRegister[47] == 0) { SicherheitsBitsEmpfaenger &= ~ 1 ; } // 0 setzen
else { SicherheitsBitsEmpfaenger |= 1 ; } // 1 setzen

if( EmpfaengerRegister[48] == 0) { SicherheitsBitsEmpfaenger &= ~ 2 ; } // 0 setzen
else { SicherheitsBitsEmpfaenger |= 2 ; } // 1 setzen

if( EmpfaengerRegister[49] == 0) { SicherheitsBitsEmpfaenger &= ~ 4 ; } // 0 setzen
else { SicherheitsBitsEmpfaenger |= 4 ; } // 1 setzen

if( EmpfaengerRegister[50] == 0) { SicherheitsBitsEmpfaenger &= ~ 8 ; } // 0 setzen
else { SicherheitsBitsEmpfaenger |= 8 ; } // 1 setzen



}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void SerielleBitsZuordnenSender(void)
{

unsigned short PotiWert;

//Poti
if( (PotiWert & 1) == 0) { SenderBitRegister[1] = 0; }
else { SenderBitRegister[1] = 1; }

if( (PotiWert & 2) == 0) { SenderBitRegister[2] = 0; }
else { SenderBitRegister[2] = 1; }

if( (PotiWert & 4) == 0) { SenderBitRegister[3] = 0; }
else { SenderBitRegister[3] = 1; }

if( (PotiWert & == 0) { SenderBitRegister[4] = 0; }
else { SenderBitRegister[4] = 1; }

if( (PotiWert & 16) == 0) { SenderBitRegister[5] = 0; }
else { SenderBitRegister[5] = 1; }

if( (PotiWert & 32) == 0) { SenderBitRegister[6] = 0; }
else { SenderBitRegister[6] = 1; }

if( (PotiWert & 64) == 0) { SenderBitRegister[7] = 0; }
else { SenderBitRegister[7] = 1; }

if( (PotiWert & 12 == 0) { SenderBitRegister[8] = 0; }
else { SenderBitRegister[8] = 1; }

//Temperatur
if( (Temperatur & 1) == 0) { SenderBitRegister[9] = 0; }
else { SenderBitRegister[9] = 1; }

if( (Temperatur & 2) == 0) { SenderBitRegister[10] = 0; }
else { SenderBitRegister[10] = 1; }

if( (Temperatur & 4) == 0) { SenderBitRegister[11] = 0; }
else { SenderBitRegister[11] = 1; }

if( (Temperatur & == 0) { SenderBitRegister[12] = 0; }
else { SenderBitRegister[12] = 1; }

if( (Temperatur & 16) == 0) { SenderBitRegister[13] = 0; }
else { SenderBitRegister[13] = 1; }

if( (Temperatur & 32) == 0) { SenderBitRegister[14] = 0; }
else { SenderBitRegister[14] = 1; }

if( (Temperatur & 64) == 0) { SenderBitRegister[15] = 0; }
else { SenderBitRegister[15] = 1; }

if( (Temperatur & 12 == 0) { SenderBitRegister[16] = 0; }
else { SenderBitRegister[16] = 1; }

if( (Temperatur & 256) == 0) { SenderBitRegister[17] = 0; }
else { SenderBitRegister[17] = 1; }

if( (Temperatur & 512) == 0) { SenderBitRegister[18] = 0; }
else { SenderBitRegister[18] = 1; }

//Sicherheits Bits
{ SenderBitRegister[19] = 0; }
{ SenderBitRegister[20] = 1; }

}
//----------------------------------------------------------------------------------



//----------------------------------------------------------------------------------
void PodiEinlesenAuswerten(void)
{


uint16_t result = readADC(0); //Auslesen der analogen Spannungen an Pin 0,
// also ADC0. In result steht das Ergebnis.

PotiADWert = result;

if(result >= ad_wert_up_min)
{

ad_wert_up_Poti = result - ad_wert_up_min ;

prozent = (ad_wert_up_Poti * 100 / ad_wert_up_diff);

if(prozent > 100)
{ prozent = 100; }

}


if(result <= ad_wert_down_max)
{

ad_wert_down_Poti = ad_wert_down_max - result ;

prozent = (ad_wert_down_Poti * 100 / ad_wert_down_diff);

if(prozent > 100)
{ prozent = 100; }

prozent = 0 - prozent;

}


if((result > ad_wert_down_max)&&(result < ad_wert_up_min))
{
prozent = 0;
}



PotiProzent = prozent;


}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void DisplayHellichkeut(void)
{

//Hellichkeit festlegen
//Wenn sich Hellichkeit geändert hat,

if(Hellichkeit_Merker != Hellichkeit)
{

UART_SendByte(0x1b); // ESC
UART_SendByte('L'); // Helligkeitssteuerung

//Wenn Hellichkeit ist 0
if(Hellichkeit == 0)
{
UART_SendByte(0x00); // 30% Helligkeit
}

if(Hellichkeit == 1)
{
UART_SendByte(0x00); // 30% Helligkeit
}

if(Hellichkeit == 2)
{
UART_SendByte(0x40); // 50% Helligkeit
}

if(Hellichkeit == 3)
{
UART_SendByte(0x80); // 75% Helligkeit
}

if(Hellichkeit == 4)
{
UART_SendByte(0xC0); // 100% Helligkeit
}

Hellichkeit_Merker = Hellichkeit;
}



}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void messagenumberSetzen(void)
{
//LAN_nichtVerbunden
if((LAN_nicht_Verbunden_Merker == 0)&&(LAN_nicht_Verbunden == 1))
{ messagenumber = 1; }

//Nullpunktfestlegen
if((Nullpunkt_festlegen_Merker == 0)&&(Nullpunkt_festlegen == 1))
{ messagenumber = 2; }

//TempAusgleichEIN
if((Temp_Ausgleich_EIN_Merker == 0)&&(Temp_Ausgleich_EIN == 1))
{ messagenumber = 3; }

//TempAusgleichAUS
if((Temp_Ausgleich_AUS_Merker == 0)&&(Temp_Ausgleich_AUS == 1))
{ messagenumber = 4; }

//JoistikEIN
if((Joistik_EIN_Merker == 0)&&(Joistik_EIN == 1))
{ messagenumber = 5; }

//JoistikAUS
if((Joistik_AUS_Merker == 0)&&(Joistik_AUS == 1))
{ messagenumber = 6; }

//Hellichkeit0
if((Hellichkeit_0_Merker == 0)&&(Hellichkeit_0 == 1))
{ messagenumber = 7; }

//Hellichkeit30
if((Hellichkeit_30_Merker == 0)&&(Hellichkeit_30 == 1))
{ messagenumber = 8; }

//Hellichkeit50
if((Hellichkeit_50_Merker == 0)&&(Hellichkeit_50 == 1))
{ messagenumber = 9; }

//Hellichkeit75
if((Hellichkeit_75_Merker == 0)&&(Hellichkeit_75 == 1))
{ messagenumber = 10; }

//Hellichkeit100
if((Hellichkeit_100_Merker == 0)&&(Hellichkeit_100 == 1))
{ messagenumber = 11; }


LAN_nicht_Verbunden_Merker = LAN_nicht_Verbunden ;
Nullpunkt_festlegen_Merker = Nullpunkt_festlegen ;
Temp_Ausgleich_EIN_Merker = Temp_Ausgleich_EIN ;
Temp_Ausgleich_AUS_Merker = Temp_Ausgleich_AUS ;
Joistik_EIN_Merker = Joistik_EIN ;
Joistik_AUS_Merker = Joistik_AUS ;
Hellichkeit_0_Merker = Hellichkeit_0 ;
Hellichkeit_30_Merker = Hellichkeit_30 ;
Hellichkeit_50_Merker = Hellichkeit_50 ;
Hellichkeit_75_Merker = Hellichkeit_75 ;
Hellichkeit_100_Merker = Hellichkeit_100 ;

}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void SystemStatusSetzen(void)
{

sprintf(messageSystemStatus, "\r%6d_%5d_%4d_OK", AuszugWert, Temperatur, Teilingsfaktor);

}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void DisplayAusgabe(void)
{


SystemStatusSetzen ();


DisplayHellichkeut ();


messagenumberSetzen ();


if(messagenumber != messagenumberMerker)
{
messagenumberMerker = messagenumber;

//Display Programmieren
UART_PrintfProgStr (messages[messagenumber]);

InfoAnzeige_Zaehler = InfoAnzeigeLaenge;
}



if(InfoAnzeige_Zaehler == 0)
{

if(Hellichkeit != 0)
{

UART_PrintfProgStr (messageSystemStatus);
}
else
{
UART_PrintfProgStr (messages[0]);
}

}
else
{
-- InfoAnzeige_Zaehler;
}

}
//----------------------------------------------------------------------------------



//################################################## #################################
//############### Funktion Main ################################################## ###
//################################################## #################################

int main (void)
{

Init ();
ioinit ();
UART_Init ();



Verz (100000);

//Poti Nullen
uint16_t result = readADC(0); //Auslesen der analogen Spannungen an Pin 0,
// also ADC0. In result steht das Ergebnis.

ad_wert_zero = result;
ad_wert_up_min = ad_wert_zero + 3;
ad_wert_down_max = ad_wert_zero - 3;
ad_wert_up_diff = ad_wert_up_max - ad_wert_up_min ;
ad_wert_down_diff = ad_wert_down_max - ad_wert_down_min ;



for(;// Endlosschleife, wird zwischen den geschweiften Klammern immer wieder durchlaufen

{

if((FertigSender == 1)&&(FertigEmpfaenger == 1)&&(FertigTemperatur == 1))
{

//Ports Einlesen
PortsSetzenEinlesen ();

//Poti
//Poti Auswerten
PodiEinlesenAuswerten ();

//Netzwerk
//Netzwerk Entprellen (Abfallverzögert)
NetzwerkPinsEntprellen();

//Netzwerk Register setzen
SerielleBitsZuordnenEmpfaenger ();
SerielleBitsZuordnenSender ();


//VFDisplay
DisplayAusgabe ();



FertigSender = 1;
FertigEmpfaenger = 0;
FertigTemperatur = 1;

//Empfänger verriegeln für min.2x Empfangen um halbe auszuschließen
EmpfaengerRiegelReset = 0;

}
else
{

//Ports Einlesen
PortsSetzenEinlesen ();

//Netzwerk
//Netzwerk Entprellen (Abfallverzögert)
NetzwerkPinsEntprellen();

//Senden
SeriellesNetzwerkEmpfaenger ();

//Empfangen
SeriellesNetzwerkSender ();

//Empfangen Temperatur
TemperaturSeriellEinlesen ();
}

}
return 0;
}