sourcecode.c

#include <avr/io.h>

#include <avr/interrupt.h>

#include <main.h> //Definitionen und Konstanten

#define RXB8 1

#define TXB8 0

#define UPE 2

#define OVR 3

#define FE 4

#define UDRE 5

#define RXC 7

#define FRAMING_ERROR (1<<FE)

#define PARITY_ERROR (1<<UPE)

#define DATA_OVERRUN (1<<OVR)

#define DATA_REGISTER_EMPTY (1<<UDRE)

#define RX_COMPLETE (1<<RXC)

// Standard Input/Output functions

#include <stdio.h>

// Declare your global variables here

struct {

    int     bytezeiger;             //Zeiger auf das Byte einer Busnachricht

    int     bitzeiger;              //Zeiger auf das Bit im Byte einer Busnachricht

    char    nachricht[6];           //Speicher fuer die Nachricht max. 6 Bytes

    char    buffer[4][6];           //Buffer fuer eine Nachricht max. 6 Bytes bereit zum Abarbeiten.

    int     flag[4];                //Zeigt an das im Buffer eine Nachricht abgearbeitet werden muss.

    int     laenge[4];              //Laenge der Nachricht in Bytes !inklusive Chksumme!

    int     eingangnr;              //Setzt auf den aktuellen empfangs Buffer 0 - 3

    int     ausgangsnr;             //Setzt auf den aktuellen zu bearbeitenden Buffer 0 - 3

    char    chksumme;               //Speicher fuer die Checksumme

    int     status;                 //Zeigt den Status an.

    } volatile bus_rx;    //Container fuer den Busempfaenger mit 4 Bufferstellen

struct {

    int     bytezeiger;             //Zeiger auf das Byte einer Busnachricht

    int     bitzeiger;              //Zeiger auf das Bit im Byte einer Busnachricht

    char    nachricht[6];           //Speicher fuer die Nachricht max. 6 Bytes

    int     laenge;                 //Laenge der Nachricht in Bytes !inklusive Chksumme!

    int     flag;                   //Zeigt an das im Buffer eine Nachricht abgearbeitet werden muss.

    int     status;                 //Zeigt den Status an.

    int     zeit;                   //Speicher fuer den Bussender

    } volatile bus_tx;    //Container fuer den Busdaten Sender

struct {

    int     status;                 //Status des Rs232 Empfaengers

    char    nachricht[5];           //Speicher fuer eine Nachricht zum Bus

    int     bytezeiger;             //Zeigt auf ein Byte in der Nachricht

    } rs232_rx; //Container fuer die rs232 Kommunikation  

int uart_putc(char daten);

ISR(BADISR_vect)

{

  uart_putc((char)0x24);

}

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

/*! Analog Comparator Interrupt

 */

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

ISR(ANALOG_COMP_vect)

{

  asm ("nop");

}//Ende analog comparator interrupt -- busdatenempfaenger

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

 *    Sendet ein Byte an den PC.

 *    !!! Nicht Interrupt gesteuert!!! Wartet bis Senden möglich ist, max. 125us bei 4MHz (500Zyklen)

 *

 *    - Return 0 wenn Daten gesendet werden konnten

 *    - Return 1 wenn Fehler auftrat 

 */

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

int uart_putc(char daten)

{

    int i;                        //Hilfzaehler fuer die Routine

    i= 0;                         //Um Verzoegerung mit zu zaehlen auf 0 setzen

    while ((!(UCSR0A & (1<<UDRE))) & (i <= 500))  //warten bis Senden moeglich aber nur 500 Zyklen

    {

        i++;

    }

    if( UCSR0A & (1<<UDRE) ) //Wenn der TX Buffer frei ist Daten senden

    {    

        UDR0 = daten;        //Daten in Sendebuffer schreiben

        return 0;           //Rückmeldung OK

    }

    else                    //Wenn der TX Buffer nach 500 Zyklen immer noch nicht frei ist

    { 

        return 1;           //Einen Fehler zurück melden

    }

}//Ende int uart_putc(char daten)

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

 *      

 *    Empfaengt RS232 Daten vom PC

 *   

 *   - Handshake: PC sendet Handshake Signal, Controller antwortet OK, PC sendet erneut 

 *                Handshake Signal. Controller antwortet OK und ist verbunden!

 *   - Senden:    PC sendet einen Befehl der auf den Bus gesendet werden soll

 *                Es werden 5 Bytes erwartet.

 */

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

ISR(USART0_RX_vect) 

{     

int i;

asm ("cli");

asm ("nop");

 uart_putc(rs232_rx.status);

   switch(rs232_rx.status)

    {

        case BUS_STANDBY:   //Bisher war RS232 Inaktiv

            if(UDR0 == HANDSHAKE) //Handshake anforderung

            {

                uart_putc(OK);   //Bestaetigen

                rs232_rx.status= BUS_HANDSHAKE;

         uart_putc(0x55);

        for(i= 0; i<500; i++)

          uart_putc(i);

            }

            break;

        case BUS_HANDSHAKE: //Handshake ausfuehren

            if(UDR0 == HANDSHAKE) //Handshake erfolgreich

            {

                uart_putc(OK);   //Bestaetigen

                rs232_rx.status= BUS_READY;

        uart_putc(0x66);

            }

            else  //Handshake fehlgeschlagen

            {

                uart_putc(FAULT);    //Fehler senden.

                rs232_rx.status= BUS_STANDBY;

            }

            break;

        case BUS_READY:     //Verbindung mit dem PC besteht

            switch(UDR0) //Je nach Befehl reagieren.

            {

                case SENDEN:  //naechsten 5 byte auf Bus senden

                    rs232_rx.status= BUS_SENDEN;

                    rs232_rx.bytezeiger= 0;

                    break;

                case DISCONNECT:  //Vom PC trennen

                    uart_putc(OK); //Bestaetigen

                    rs232_rx.status= BUS_STANDBY;

                    break;

                default:

                    uart_putc(FAULT); //Fehler senden

                    break;                    

            }

            break;

        case BUS_SENDEN:    //Nachricht zum Senden zusammen setzten

            //Es werden 5 Bytes vom PC + ein OK erwartet

            if(rs232_rx.bytezeiger >= 5) //Jetzt muesste OK kommen

            {

                if(UDR0 == OK)

                {

                    uart_putc(OK);  //Bestaetigen

                   // bustransmitter(rs232_rx.nachricht[0],rs232_rx.nachricht[1],rs232_rx.nachricht[2],rs232_rx.nachricht[3],rs232_rx.nachricht[4]);

                    rs232_rx.status= BUS_READY;

                }

                else //Falsche uebertragung --> Nachricht verwerfen.

                {

                    uart_putc(FAULT); //Fehler senden

                    rs232_rx.status= BUS_READY;

                }

            }

            else //Noch mit empfang beschaeftigt.

                rs232_rx.nachricht[rs232_rx.bytezeiger++]= UDR0;

           break;

    }                                  

    UCSR0A&= 0x7F;    //RXC flag loeschen

  asm ("sei");   

}//Ende Usart RX Interrupt -- RS232 Empfang

int main(void)

{

// Declare your local variables here

int i;

uart_putc(0x31);

//Watchdog Timer ausschalten

  WDTCR|= 0x18; //Logic 1 to WDCE and WDE

  WDTCR= 0x00; //Watchtog off

 // Input/Output Ports initialization

    // Port A initialization

    // Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out 

    // State7=0 State6=0 State5=0 State4=0 State3=0 State2=0 State1=0 State0=0 

    PORTA=0x00;

    DDRA=0xFF;

    // Port B initialization

    // Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out 

    // State7=0 State6=0 State5=0 State4=0 State3=0 State2=0 State1=0 State0=0 

    PORTB=0x00;

    DDRB=0xFF;

    // Port C initialization

    // Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=In Func0=In 

    // State7=0 State6=0 State5=0 State4=0 State3=0 State2=0 State1=P State0=P 

    PORTC=0x03;

    DDRC=0xFC;

    // Port D initialization

    // Func7=In Func6=In Func5=In Func4=Out Func3=In Func2=In Func1=Out Func0=Out 

    // State7=P State6=P State5=P State4=0 State3=T State2=T State1=0 State0=0 

    PORTD=0xE0;

    DDRD=0x13;

    // Port E initialization

    // Func7=Out Func6=Out Func5=Out Func4=Out Func3=In Func2=In Func1=In Func0=In 

    // State7=0 State6=0 State5=0 State4=0 State3=T State2=T State1=T State0=T 

    PORTE=0x00;

    DDRE=0xF0;

    // Port F initialization

    // Func7=Out Func6=Out Func5=Out Func4=In Func3=In Func2=In Func1=In Func0=In 

    // State7=0 State6=0 State5=0 State4=T State3=T State2=T State1=T State0=T 

    PORTF=0x00;

    DDRF=0xE0;

    // Port G initialization

    // Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out 

    // State4=0 State3=0 State2=0 State1=0 State0=0 

    PORTG=0x00;

    DDRG=0x1F;

    // Timer/Counter 0 initialization

    // Clock source: System Clock

    // Clock value: Timer 0 Stopped

    // Mode: Normal top=FFh

    // OC0 output: Disconnected

    ASSR=0x00;

    TCCR0=0x00;

    TCNT0=0x00;

    OCR0=0x00;

    // Timer/Counter 1 initialization

    // Clock source: System Clock

    // Clock value: Timer 1 Stopped

    // Mode: Normal top=FFFFh

    // OC1A output: Discon.

    // OC1B output: Discon.

    // OC1C output: Discon.

    // Noise Canceler: Off

    // Input Capture on Falling Edge

    // Timer 1 Overflow Interrupt: Off

    // Input Capture Interrupt: Off

    // Compare A Match Interrupt: Off

    // Compare B Match Interrupt: Off

    // Compare C Match Interrupt: Off

    TCCR1A=0x00;

    TCCR1B=0x00;

    TCNT1H=0x00;

    TCNT1L=0x00;

    ICR1H=0x00;

    ICR1L=0x00;

    OCR1AH=0x00;

    OCR1AL=0x00;

    OCR1BH=0x00;

    OCR1BL=0x00;

    OCR1CH=0x00;

    OCR1CL=0x00;

    // Timer/Counter 2 initialization

    // Clock source: System Clock

    // Clock value: Timer 2 Stopped

    // Mode: Normal top=FFh

    // OC2 output: Disconnected

    TCCR2=0x00;

    TCNT2=0x00;

    OCR2=0x00;

    // Timer/Counter 3 initialization

    // Clock source: System Clock

    // Clock value: Timer 3 Stopped

    // Mode: Normal top=FFFFh

    // Noise Canceler: Off

    // Input Capture on Falling Edge

    // OC3A output: Discon.

    // OC3B output: Discon.

    // OC3C output: Discon.

    // Timer 3 Overflow Interrupt: Off

    // Input Capture Interrupt: Off

    // Compare A Match Interrupt: Off

    // Compare B Match Interrupt: Off

    // Compare C Match Interrupt: Off

    TCCR3A=0x00;

    TCCR3B=0x00;

    TCNT3H=0x00;

    TCNT3L=0x00;

    ICR3H=0x00;

    ICR3L=0x00;

    OCR3AH=0x00;

    OCR3AL=0x00;

    OCR3BH=0x00;

    OCR3BL=0x00;

    OCR3CH=0x00;

    OCR3CL=0x00;

    // External Interrupt(s) initialization

    // INT0: Off

    // INT1: Off

    // INT2: Off

    // INT3: Off

    // INT4: Off

    // INT5: Off

    // INT6: Off

    // INT7: Off

    EICRA=0x00;

    EICRB=0x00;

    EIMSK=0x00;

    // Timer(s)/Counter(s) Interrupt(s) initialization

    TIMSK=0x00;

    ETIMSK=0x00;

    // USART0 initialization

    // Communication Parameters: 8 Data, 1 Stop, No Parity

    // USART0 Receiver: On

    // USART0 Transmitter: On

    // USART0 Mode: Asynchronous

    // USART0 Baud Rate: 9600

    UCSR0A=0x00;

    UCSR0B=0x98;

    UCSR0C=0x06;

    UBRR0H=0x00;

    UBRR0L=0x19;

    // USART1 initialization

    // Communication Parameters: 8 Data, 1 Stop, No Parity

    // USART1 Receiver: On

    // USART1 Transmitter: On

    // USART1 Mode: Asynchronous

    // USART1 Baud Rate: 9600

    UCSR1A=0x00;

    UCSR1B=0x18;

    UCSR1C=0x06;

    UBRR1H=0x00;

    UBRR1L=0x19;

    // Analog Comparator initialization

    // Analog Comparator: On

    // Interrupt on Falling Output Edge

    // Analog Comparator Input Capture by Timer/Counter 1: Off

    ACSR=0x0A;

    SFIOR=0x00;

uart_putc(0x32);

    // Global enable interrupts

    asm ("sei");

    //Variablen in Ausgangszustand bringen:

    bus_rx.status= BUS_STANDBY;

    for(i=0; i<4; i++)

        bus_rx.flag[i]=   0;

    bus_rx.eingangnr= 0;

    bus_rx.ausgangsnr= 0;

    bus_tx.status= BUS_STANDBY;

    bus_tx.flag=   0;

    rs232_rx.status= BUS_STANDBY;    

  uart_putc(0x33);

  uart_putc(MCUCSR);

  MCUSR= 0x00;

while (1)

      {

      PORTE ^= 0x20; 

      for(i=0 ; i<= 10000;i++)

        asm ("nop");

      };

}