SIGNAL(SIG_UART_TRANS)
{
/* Test if a string is being sent */
if (pUART_Buffer!=0)
{
pUART_Buffer++; // Go to next character in string

// Test if the end of string has been reached
if (/* PRG_RDB */*(pUART_Buffer)== '\0')
{
/* String has been sent */
pUART_Buffer = 0;
/* Indicate that the UART is now ready to send */
UART_Ready = 1;
return;
}
/* Send next character in string */
UDR = /* PRG_RDB */*(pUART_Buffer);
return;
}
/* Indicate that the UART is now ready to send */
UART_Ready = 1;
}
/* EasyCASE ) */
/* EasyCASE ( 72
SIGNAL */
/* EasyCASE F */
/* UART Receive Complete Interrupt Function */
SIGNAL(SIG_UART_RECV)
{
/* Indicate that the UART has received a character */
UART_ReceivedChar = 1;
/* Store received character */
UART_RxChar = UDR;
}
/* EasyCASE ) */
/* EasyCASE ( 73
UART_SendByte */
/* EasyCASE F */
void UART_SendByte(u08 Data)
{
/* wait for UART to become available */
while (!UART_Ready)
{
;
}
UART_Ready = 0;
/* Send character */
UDR = Data;
}
/* EasyCASE ) */
/* EasyCASE ( 74
UART_ReceiveByte */
/* EasyCASE F */
u08 UART_ReceiveByte(void)
{
/* wait for UART to indicate that a character has been received */
while (!UART_ReceivedChar)
{
;
}
UART_ReceivedChar = 0;
/* read byte from UART data buffer */
return UART_RxChar;
}
/* EasyCASE ) */
/* EasyCASE ( 75
UART_PrintfProgStr */
/* EasyCASE F */
void UART_PrintfProgStr(u08* pBuf)
{
/* wait for UART to become available */
while (!UART_Ready)
{
;
}
UART_Ready = 0; // Indicate to ISR the string to be sent

pUART_Buffer = pBuf; // Send first character

UDR = /* PRG_RDB */*(pUART_Buffer); // fuer RAM-based Strings die PRG_RDB-Macros ausgeblendet
}
/* EasyCASE ) */
/* EasyCASE ( 76
UART_PrintfEndOfLine */
/* EasyCASE F */
void UART_PrintfEndOfLine(void)
{
/* wait for UART to become available */
while (!UART_Ready)
{
;
}
UART_Ready = 0; /* Indicate to ISR the string to be sent */
pUART_Buffer = (u08 *)(&UART_pszEndOfLine[0]);
UDR = *(pUART_Buffer); /* Send first character */
}
/* EasyCASE ) */
/* EasyCASE ( 77
UART_PrintfU4 */
/* EasyCASE F */
void UART_PrintfU4(u08 Data)
{
/* Send 4-bit hex value */
u08 Character = Data&0x0f;
if (Character>9)
{
Character+='A'-10;
}
else
{
Character+='0';
}
UART_SendByte(Character);
}
/* EasyCASE ) */
/* EasyCASE ( 78
UART_Printfu08 */
/* EasyCASE F */
void UART_Printfu08(u08 Data)
{
/* Send 8-bit hex value */
UART_PrintfU4(Data>>4);
UART_PrintfU4(Data );
}
/* EasyCASE ) */
/* EasyCASE ( 79
UART_Printfu16 */
/* EasyCASE F */
void UART_Printfu16(u16 Data)
{
/* Send 16-bit hex value */
UART_PrintfU4(Data>>12);
UART_PrintfU4(Data>> ;
UART_PrintfU4(Data>> 4);
UART_PrintfU4(Data );
}
/* EasyCASE ) */
/* EasyCASE ( 80
UART_Init */
/* EasyCASE F */
void UART_Init(void)
{
UART_Ready = 1;
UART_ReceivedChar = 0;
pUART_Buffer = 0;
/* enable RxD/TxD and interrupts */
//outp(BV(RXCIE)|BV(TXCIE)|BV(RXEN)|BV(TXEN),UCR);
UCSRB = _BV(RXCIE) | _BV(TXCIE) | _BV(RXEN) | _BV(TXEN);
/* set baud rate */
UBRRH = (unsigned char)(UART_BAUD_SELECT>>;
UBRRL = (unsigned char)(UART_BAUD_SELECT);
/* enable interrupts */
sei();
}
/* EasyCASE ) */
/* EasyCASE ( 65
ioinit */
/* EasyCASE F */
void ioinit (void)
{
/* enable interrupts */
sei();
}
/* EasyCASE ) */
/* EasyCASE ( 88
delay */
/* EasyCASE F */
void delay (unsigned int delay)
{
static unsigned int InnerLoop;
while (delay > 0)
{
for (InnerLoop = 0; InnerLoop < 3686; ++InnerLoop)
{
// warten ...
}
--delay;
}
}





//----------------------------------------------------------------------------------
uint16_t readADC(uint8_t channel) {
uint8_t i;
uint16_t result = 0;

// Den ADC aktivieren und Teilungsfaktor auf 64 stellen
ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1);

// Kanal des Multiplexers waehlen
ADMUX = channel;
// Interne Referenzspannung verwenden (also 2,56 V)
ADMUX |= (1<<REFS1) | (1<<REFS0);

// Den ADC initialisieren und einen sog. Dummyreadout machen
ADCSRA |= (1<<ADSC);
while(ADCSRA & (1<<ADSC));

// Jetzt 3x die analoge Spannung and Kanal channel auslesen
// und dann Durchschnittswert ausrechnen.
for(i=0; i<10; i++) {
// Eine Wandlung
ADCSRA |= (1<<ADSC);
// Auf Ergebnis warten...
while(ADCSRA & (1<<ADSC));

result += ADCW;
}

// ADC wieder deaktivieren
ADCSRA &= ~(1<<ADEN);

result /= 10;

return result;
}
//----------------------------------------------------------------------------------




//################################################## #################################
//############### Input / Output Register anlegen ###################################
//################################################## #################################


//----------------------------------------------------------------------------------
void Verz(long time)
{
/*
Verzögerungsfunktion
Der übergebene Parameter time bestimmt, wie oft die Verzögerungsschleife
durchlaufen wird und damit, wie lange die Verzögerung dauert
(jede Befehlsausführung benötigt immer eine gewisse Zeit).
*/
do // Beginn einer do/while-Schleife
{
--time; // der übergebene Wert wird um eins vermindert
}
while (time > 0); // hier wird geprüft, od der Wert inzwischen 0 ist
// wenn nicht, wird wird wieder an den Anfang der do-Schleife
// gesprungen (while = solange oder während)
// ist irgendwann time == 0, wird die Schleife verlassen

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


//----------------------------------------------------------------------------------
void PortsSetzenEinlesen(void)
{

//-----------------------------------------------------------------
//----- Eingänge --------------------------------------------------
//-----------------------------------------------------------------

//Serielle übertragung über 2 Pins
if((PINB & 64) == 0) { Pin_Serielle_Setzen2 = 0; }
else { Pin_Serielle_Setzen2 = 1; }

if((PINB & 12 == 0) { Pin_Serielle_Bit2 = 0; }
else { Pin_Serielle_Bit2 = 1; }


//Serielles Netzwerk Empfänger
if((PIND & 4) == 0) { Pin_SeriellerPin_Hi = 0; }
else { Pin_SeriellerPin_Hi = 1; }

if((PIND & == 0) { Pin_SeriellerPin_Lo = 0; }
else { Pin_SeriellerPin_Lo = 1; }

if((PIND & 16) == 0) { Pin_SeriellerPin_Reset = 0; }
else { Pin_SeriellerPin_Reset = 1; }



//-----------------------------------------------------------------
//----- Ausgänge --------------------------------------------------
//-----------------------------------------------------------------

//Serielles Netzwerk Sender
if(Pin_SeriellerPort_Hi == 1)
{ PORTD |= 32; } // 1 setzen
else
{ PORTD &= ~32; } // 0 setzen

if(Pin_SeriellerPort_Lo == 1)
{ PORTD |= 64; } // 1 setzen
else
{ PORTD &= ~64; } // 0 setzen

if(Pin_SeriellerPort_Reset == 1)
{ PORTD |= 128; } // 1 setzen
else
{ PORTD &= ~128; } // 0 setzen


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


//----------------------------------------------------------------------------------
void TemperaturSeriellEinlesen(void)
{


//Abfrage hat sich das Pin Setzen geändert?
if((Pin_Serielle_Setzen == Pin_Serielle_Setzen_Merker))
{

if((Pin_Serielle_Bit == Pin_Serielle_Bit_Merker))
{
}
else
{
//Merkser setzen, um auf änderung des Pins Bit zu warten
Pin_Serielle_Bit_Merker = Pin_Serielle_Bit;

// if(BitEmpfangen == 9)
{
BitEmpfangen = 0;

Temperatur = TemperaturTmp - 50;

//Markiert Temperatur erfolgreich eingelesen
FertigTemperatur = 1;


TemperaturTmp = 0;
}



}


}
else
{
if((Pin_Serielle_Bit == Pin_Serielle_Bit_Merker))
{
}
else
{
//Merkser setzen, um auf änderung des Pins Bit zu warten
Pin_Serielle_Bit_Merker = Pin_Serielle_Bit;
}


//Merkser setzen, um auf änderung des Pins Setzen zu warten
Pin_Serielle_Setzen_Merker = Pin_Serielle_Setzen;

//Setzt das Pin, das als nechstes empfangen werden soll
++ BitEmpfangen;

if(Pin_Serielle_Bit == 1)
{
TemperaturTmp = TemperaturTmp + (BitAdresse[BitEmpfangen]);
}
}






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


//----------------------------------------------------------------------------------
void SeriellesNetzwerkSender(void)
{

//Sobalt die Zeit SenderImpulslaenge abgelaufen ist, wird das nechste Bit gesendet.
if(SenderImpulslaengeZaehler == 0)
{
SenderImpulslaengeZaehler = SenderImpulslaenge;


//Ist das letzte Bit erreicht, .
if(SenderBitRegisterZaehler > 20)
{
//wird ein Reset befehl gesendet
if(SeriellerPort_Reset == 1)
{
SeriellerPort_Reset = 0;
}
else
{
SeriellerPort_Reset = 1;
}

//der Registerzähler zurückgesetzt
SenderBitRegisterZaehler = 0;
}

//Ist das letzte Bit nicht erreicht, wird das nechste gesendet.
else
{
//dann nechstes Bit
++ SenderBitRegisterZaehler;

//Wenn das Momentan Bit ist Hi,
if(SenderBitRegister[SenderBitRegisterZaehler] == 1)
{
//dann Wechsler Pin Hi
if(SeriellerPort_Hi == 1)
{
SeriellerPort_Hi = 0;
}
else
{
SeriellerPort_Hi = 1;
}
}

//wenn nicht,
else
{
//dann Wechsler Pin Lo
if(SeriellerPort_Lo == 1)
{
SeriellerPort_Lo = 0;
}
else
{
SeriellerPort_Lo = 1;
}
}
}

}

//wenn nicht
else
{
//dann incrementiere SenderImpulslängeZaehler
-- SenderImpulslaengeZaehler;
}

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