Test4.c

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

This program was produced by the

CodeWizardAVR V2.03.9 Standard

Automatic Program Generator

© Copyright 1998-2008 Pavel Haiduc, HP InfoTech s.r.l.

http://www.hpinfotech.com

Project : 

Version : 

Date    : 05.03.2011

Author  : -

Company : -

Comments: 

Chip type               : ATmega8

Program type            : Application

AVR Core Clock frequency: 4,000000 MHz

Memory model            : Small

External RAM size       : 0

Data Stack size         : 256

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

#include <mega8.h>

// SPI functions

#include <spi.h>

#include <mcp2515_defs.h>

#include <delay.h>

#include <stdio.h>

int timer1 = 0;

bit CAN_message_received_CAN1 = 0;

bit CAN_message_received_CAN2 = 0;

// Timer 1 output compare A interrupt service routine

interrupt [TIM1_COMPA] void timer1_compa_isr(void)

{

  //  timer1++;

}

// Declare your global variables here

#define PORT_CS     PORTB

#define P_CS_CAN1   2

#define P_CS_CAN2   1

typedef struct 

{

    unsigned int    id;

    unsigned char   rtr;

    unsigned char   length;

    unsigned char   data[8];

} CANMessage; 

// Neue Nachricht erzeugen

CANMessage message, Receive_msg_CAN1, Receive_msg_CAN2, Transmit_msg_CAN1, Transmit_msg_CAN2;

// CS des entsprechenden MCP2515 auf Low ziehen

void mcp2515_CS_LOW (unsigned char channel)

{

    // CS des entsprechenden MCP2515 auf Low ziehen         

    switch (channel) 

    {

        case 1:

            PORT_CS &= ~(1<<P_CS_CAN1);  //CS = 2     

            break;

        case 2:

            PORT_CS &= ~(1<<P_CS_CAN2);  //CS = 1     

            break;  

        default:

            PORT_CS &= ~(1<<P_CS_CAN1);  //CS = 2  // default Channel1    

            break;                             

    } 

}

// CS des entsprechenden MCP2515 auf High ziehen, wieder freigeben

void mcp2515_CS_HIGH (unsigned char channel)

{

    // /CS Leitung wieder freigeben

    switch (channel)

    {

        case 1:

            PORT_CS |= (1<<P_CS_CAN1);  //CS = 2

            break;

        case 2:

            PORT_CS |= (1<<P_CS_CAN2);  //CS = 1   

            break;

        default:

            PORT_CS |= (1<<P_CS_CAN1);  // default Channel1

            break;         

    } 

}

// Bytes über den SPI Bus schieben

int spi_putc( int data )

{

    // Sendet ein Byte

    SPDR = data;

    // Wartet bis Byte gesendet wurde

    while( !( SPSR & (1<<7) ) )   //  SPIF = 7

        ;

    return SPDR;

}

// mcp2515 Registerwerte schreiben

void mcp2515_write_register( int adress, int data, unsigned char channel )

{

    // CS des entsprechenden MCP2515 auf Low ziehen         

    mcp2515_CS_LOW(channel);

    spi_putc(SPI_WRITE);    // SPI_WRITE = 0x02h  (mcp2515_defs.h)

    spi_putc(adress);

    spi_putc(data);

    // /CS Leitung wieder freigeben

    mcp2515_CS_HIGH(channel);  

}

// mcp2515 Registerwerte lesen

int mcp2515_read_register(int adress, unsigned char channel )

{

    int data;

    // /CS des MCP2515 auf Low ziehen

    mcp2515_CS_LOW(channel);

    spi_putc(SPI_READ);     // SPI_READ = 0x03h    (mcp2515_defs.h)

    spi_putc(adress);

    data = spi_putc(0xff);  

    // /CS Leitung wieder freigeben

    mcp2515_CS_HIGH(channel); 

    return data;

}

//  mcp2515 Einzelne Bits setzen/löschen

void mcp2515_bit_modify(int adress, int mask, int data, unsigned char channel)

{

    // /CS des MCP2515 auf Low ziehen

    mcp2515_CS_LOW(channel);

    spi_putc(SPI_BIT_MODIFY);  // SPI_BIT_MODIFY = 0x05  (mcp2515_defs.h)

    spi_putc(adress);

    spi_putc(mask);

    spi_putc(data);

    // /CS Leitung wieder freigeben

    mcp2515_CS_HIGH(channel); 

}

// Senden mit allen drei Puffern

unsigned char can_send_message(CANMessage *p_message, unsigned char channel)

{

    unsigned char status, address;

    unsigned char length = p_message->length;   

    unsigned char i;  

    // Status des MCP2515 auslesen

    // PORT_CS &= ~(1<<P_CS);       löschen  

    // /CS des MCP2515 auf Low ziehen

    mcp2515_CS_LOW(channel);         

    spi_putc(SPI_READ_STATUS);

    status = spi_putc(0xff);

    spi_putc(0xff);

    // PORT_CS |= (1<<P_CS);        löschen   

    // /CS Leitung wieder freigeben  

    mcp2515_CS_HIGH(channel);

    /* Statusbyte:

     *

     * Bit  Funktion

     *  2   TXB0CNTRL.TXREQ

     *  4   TXB1CNTRL.TXREQ

     *  6   TXB2CNTRL.TXREQ

     */

  /*if (bit_is_clear(status, 2)) {

        address = 0x00;

    }

    else if (bit_is_clear(status, 4)) {

        address = 0x02;

    } 

    else if (bit_is_clear(status, 6)) {

        address = 0x04;

    }

    else {

         Alle Puffer sind belegt,

           Nachricht kann nicht verschickt werden 

        return 0;

    }     

    */     

    if (!(status & 0x4))   

    {

        address = 0x00;

    }

    else if (!(status & 0x10)) 

    {

        address = 0x02;

    }

    else if (!(status & 0x40))

    {

        address = 0x04;

    }  

    else 

    {

        /* Alle Puffer sind belegt,

           Nachricht kann nicht verschickt werden */

        return 0;    

    }

    // PORT_CS &= ~(1<<P_CS);    // CS Low   // löschen   

    // /CS des MCP2515 auf Low ziehen

    mcp2515_CS_LOW(channel);

    spi_putc(SPI_WRITE_TX | address);

    // Standard ID einstellen

    spi_putc((unsigned char) (p_message->id>>3));

    spi_putc((unsigned char) (p_message->id<<5));

    // Extended ID

    spi_putc(0x00);

    spi_putc(0x00);

    if (length > 8) {

        length = 8;

    }

    // Ist die Nachricht ein "Remote Transmit Request" ?

    if (p_message->rtr)

    {

        /* Ein RTR hat zwar eine Laenge, 

           aber enthaelt keine Daten */

        // Nachrichten Laenge + RTR einstellen

        spi_putc((1<<RTR) | length);

    }

    else

    {

        // Nachrichten Laenge einstellen

        spi_putc(length);

        // Daten

        for (i=0;i<length;i++) {

            spi_putc(p_message->data[i]);

        }

    }

    // PORT_CS |= (1<<P_CS);      // CS auf High       löschen

    // /CS Leitung wieder freigeben  

    mcp2515_CS_HIGH(channel);

    /*asm*/  volatile ("nop");    // asm ???

    /* CAN Nachricht verschicken

       die letzten drei Bit im RTS Kommando geben an welcher

       Puffer gesendet werden soll */

    // PORT_CS &= ~(1<<P_CS);    // CS wieder Low                                                                           löschen     

    // /CS des MCP2515 auf Low ziehen

    mcp2515_CS_LOW(channel);

    if (address == 0x00) {                                                                                              

        spi_putc(SPI_RTS | 0x01);

    } else {

        spi_putc(SPI_RTS | address);

    }

    // PORT_CS |= (1<<P_CS);      // CS auf High                                                                            löschen       

    // /CS Leitung wieder freigeben  

    mcp2515_CS_HIGH(channel);

    return 1;

}

unsigned char mcp2515_read_rx_status(unsigned char channel)

{

    unsigned char data;

    // /CS des MCP2515 auf Low ziehen

    mcp2515_CS_LOW(channel);

    spi_putc(SPI_RX_STATUS);

    data = spi_putc(0xff);

    // Die Daten werden noch einmal wiederholt gesendet,

    // man braucht also nur eins der beiden Bytes auswerten.

    spi_putc(0xff);

    // /CS Leitung wieder freigeben  

    mcp2515_CS_HIGH(channel);

    return data;

}

unsigned char can_get_message(CANMessage *p_message, unsigned char channel)

{      

    unsigned char i;

    unsigned char length;

    // Status auslesen

    unsigned char status = mcp2515_read_rx_status(channel);

    //if (bit_is_set(status,6))

    if ((status & 0x40))

    {

        // Nachricht in Puffer 0

        // PORT_CS &= ~(1<<P_CS);    // CS Low                                                                  löschen

        // /CS des MCP2515 auf Low ziehen

        mcp2515_CS_LOW(channel);

        spi_putc(SPI_READ_RX);

    }

    else //if (bit_is_set(status,7)) 

    if ((status & 0x80))

    {

        // Nachricht in Puffer 1

        // PORT_CS &= ~(1<<P_CS);    // CS Low                                                                  löschen

        // /CS des MCP2515 auf Low ziehen

        mcp2515_CS_LOW(channel);

        spi_putc(SPI_READ_RX | 0x04);

    }

    else {

        /* Fehler: Keine neue Nachricht vorhanden */

        return 0xff;

    }

    // Standard ID auslesen

    p_message->id =  (unsigned int) spi_putc(0xff) << 3;

    p_message->id |= (unsigned int) spi_putc(0xff) >> 5;

    spi_putc(0xff);

    spi_putc(0xff);

    // Laenge auslesen

    length = spi_putc(0xff) & 0x0f;

    p_message->length = length;

    // Daten auslesen

    for (i=0;i<length;i++) {

        p_message->data[i] = spi_putc(0xff);

    }

    // PORT_CS |= (1<<P_CS);                                                                                    löschen

    // /CS Leitung wieder freigeben  

    mcp2515_CS_HIGH(channel);

    //if (bit_is_set(status,3))    

    if ((status & 0x8))

    {

        p_message->rtr = 1;

    } else {

        p_message->rtr = 0;

    }

    // Interrupt Flag loeschen

    // if (bit_is_set(status,6))  

    if ((status & 0x40))

    {

        mcp2515_bit_modify(CANINTF, (1<<RX0IF), 0, channel);

    } else {

        mcp2515_bit_modify(CANINTF, (1<<RX1IF), 0, channel);

    }

    return (status & 0x07);

}

void mcp2515_reset (unsigned char channel)

{

    // MCP2515 per Software Reset zuruecksetzten,

    // danach ist der MCP2515 im Configuration Mode

    // /CS des MCP2515 auf Low ziehen

    mcp2515_CS_LOW(channel);

    spi_putc( SPI_RESET );

    delay_ms(1);

    // /CS Leitung wieder freigeben  

    mcp2515_CS_HIGH(channel);

} 

// External Interrupt 1 service routine

// Interrupt für CAN1

interrupt [EXT_INT1] void ext_int1_isr(void)

{

     can_get_message(&Receive_msg_CAN1, P_CS_CAN1);

     CAN_message_received_CAN1=1;      

}

// External Interrupt 0 service routine

// Interrupt  für CAN2

interrupt [EXT_INT0] void ext_int0_isr(void)

{

     can_get_message(&Receive_msg_CAN2, P_CS_CAN2);

     CAN_message_received_CAN2=1; 

}

// Zeichen über USART einlesen

int uart_getc(void)

{

    while (!(UCSRA & (1<<7)))      // warten bis Zeichen verfuegbar 7= RXC

        ;

    return UDR;                   // Zeichen aus UDR an Aufrufer zurueckgeben

} 

// String über USART einlesen

void uart_gets( char* Buffer, int MaxLen )

{

  int NextChar;

  int StringLen = 0;

  NextChar = uart_getc();         // Warte auf und empfange das nächste Zeichen

                                  // Sammle solange Zeichen, bis:

                                  // * entweder das String Ende Zeichen kam

                                  // * oder das aufnehmende Array voll ist

   while( NextChar != '\n' && StringLen < MaxLen - 1 )

   {

    *Buffer++ = NextChar;

    StringLen++;

    NextChar = uart_getc();

  }

                                  // Noch ein '\0' anhängen um einen Standard

                                  // C-String daraus zu machen

  *Buffer = '\0';

} 

void main(void)

{

// Declare your local variables here

// Daten eintragen

message.id = 0x0125;

message.rtr = 0;

message.length = 2;

message.data[0] = 0x04;

message.data[1] = 0xf3;

// Input/Output Ports initialization

// Port B initialization

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

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

PORTB=0x00;

DDRB=0x2F;

// Port C initialization

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

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

PORTC=0x00;

DDRC=0x00;

// Port D initialization

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

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

PORTD=0x00;

DDRD=0x00;

// Timer/Counter 0 initialization

// Clock source: System Clock

// Clock value: Timer 0 Stopped

TCCR0=0x00;

TCNT0=0x00;

// Timer/Counter 1 initialization

// Clock source: System Clock

// Clock value: 4000,000 kHz

// Mode: CTC top=OCR1A

// OC1A output: Discon.

// OC1B output: Discon.

// Noise Canceler: Off

// Input Capture on Falling Edge

// Timer 1 Overflow Interrupt: Off

// Input Capture Interrupt: Off

// Compare A Match Interrupt: On

// Compare B Match Interrupt: Off

TCCR1A=0x00;

TCCR1B=0x09;

TCNT1H=0x00;

TCNT1L=0x00;

ICR1H=0x00;

ICR1L=0x00;

OCR1AH=0x9C;

OCR1AL=0x3F;

OCR1BH=0x00;

OCR1BL=0x00;

// Timer/Counter 2 initialization

// Clock source: System Clock

// Clock value: Timer 2 Stopped

// Mode: Normal top=FFh

// OC2 output: Disconnected

ASSR=0x00;

TCCR2=0x00;

TCNT2=0x00;

OCR2=0x00;

// External Interrupt(s) initialization

// INT0: On

// INT0 Mode: Low level

// INT1: On

// INT1 Mode: Low level

GICR|=0xC0;

MCUCR=0x00;

GIFR=0xC0;

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

TIMSK=0x10;

// USART initialization

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

// USART Receiver: Off

// USART Transmitter: On

// USART Mode: Asynchronous

// USART Baud Rate: 9600

UCSRA=0x00;

UCSRB=0x18;

UCSRC=0x86;

UBRRH=0x00;

UBRRL=0x19;

// Analog Comparator initialization

// Analog Comparator: Off

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

ACSR=0x80;

SFIOR=0x00;

// SPI initialization

// SPI Type: Master

// SPI Clock Rate: 2*1000,000 kHz

// SPI Clock Phase: Cycle Half

// SPI Clock Polarity: Low

// SPI Data Order: MSB First

SPCR=0x50;   // SPE=1   Beschreibt ob SPI angeschaltet ist oder abgeschaltet

             // MSTR=1  Beschreibt ob der Mikrocontroller als Master fungiert oder als Slave

SPSR=0x01;   // CPU Takt durch 2, SPI2X=1

// MCP2515 per Software Reset zuruecksetzten,

// danach ist der MCP2515 im Configuration Mode

//PORT_CS &= ~(1<<P_CS);

//spi_putc( SPI_RESET );

//delay_ms(1);

//PORT_CS |= (1<<P_CS);

mcp2515_reset (P_CS_CAN1);

mcp2515_reset (P_CS_CAN2);

// etwas warten bis sich der MCP2515 zurueckgesetzt hat

delay_ms(10);

    /* 

     *  Einstellen des Bit Timings

     *  

     *  Fosc       = 16MHz

     *  BRP        = 7                (teilen durch 8)

     *  TQ = 2 * (BRP + 1) / Fosc  (=> 1 uS)

     *  

     *  Sync Seg   = 1TQ

     *  Prop Seg   = (PRSEG + 1) * TQ  = 1 TQ

     *  Phase Seg1 = (PHSEG1 + 1) * TQ = 3 TQ

     *  Phase Seg2 = (PHSEG2 + 1) * TQ = 3 TQ

     *  

     *  Bus speed  = 1 / (Total # of TQ) * TQ

     *             = 1 / 8 * TQ = 125 kHz

     */

// BRP = 7

// mcp2515_write_register( CNF1, (1<<BRP0)|(1<<BRP1)|(1<<BRP2) );     // CAN Bitrate 125 kbps

mcp2515_write_register( CNF1, (1<<BRP0) , P_CS_CAN1);         // 500 kps    

mcp2515_write_register( CNF1, (1<<BRP0) , P_CS_CAN2);         // 500 kps

// Prop Seg und Phase Seg1 einstellen

mcp2515_write_register( CNF2, (1<<BTLMODE)|(1<<PHSEG11) , P_CS_CAN1);

mcp2515_write_register( CNF2, (1<<BTLMODE)|(1<<PHSEG11) , P_CS_CAN2);

// Wake-up Filter deaktivieren, Phase Seg2 einstellen

mcp2515_write_register( CNF3, (1<<PHSEG21) , P_CS_CAN1);

mcp2515_write_register( CNF3, (1<<PHSEG21) , P_CS_CAN2);

// Aktivieren der Rx Buffer Interrupts

mcp2515_write_register(CANINTE, (1<<RX1IE)|(1<<RX0IE), P_CS_CAN1);

mcp2515_write_register(CANINTE, (1<<RX1IE)|(1<<RX0IE), P_CS_CAN2);

/*

*  Einstellen der Filter

*/

// Buffer 0 : Empfangen aller Nachrichten

mcp2515_write_register( RXB0CTRL, (1<<RXM1)|(1<<RXM0), P_CS_CAN1);

mcp2515_write_register( RXB0CTRL, (1<<RXM1)|(1<<RXM0), P_CS_CAN2);

// Buffer 1 : Empfangen aller Nachrichten

mcp2515_write_register( RXB1CTRL, (1<<RXM1)|(1<<RXM0), P_CS_CAN1);

mcp2515_write_register( RXB1CTRL, (1<<RXM1)|(1<<RXM0), P_CS_CAN2);

// Alle Bits der Empfangsmaske loeschen, 

// damit werden alle Nachrichten empfangen

mcp2515_write_register( RXM0SIDH, 0,  P_CS_CAN1);

mcp2515_write_register( RXM0SIDL, 0,  P_CS_CAN1);

mcp2515_write_register( RXM0EID8, 0,  P_CS_CAN1);

mcp2515_write_register( RXM0EID0, 0,  P_CS_CAN1);

mcp2515_write_register( RXM1SIDH, 0,  P_CS_CAN1);

mcp2515_write_register( RXM1SIDL, 0,  P_CS_CAN1);

mcp2515_write_register( RXM1EID8, 0,  P_CS_CAN1);

mcp2515_write_register( RXM1EID0, 0,  P_CS_CAN1);

mcp2515_write_register( RXM0SIDH, 0,  P_CS_CAN2);

mcp2515_write_register( RXM0SIDL, 0,  P_CS_CAN2);

mcp2515_write_register( RXM0EID8, 0,  P_CS_CAN2);

mcp2515_write_register( RXM0EID0, 0,  P_CS_CAN2);

mcp2515_write_register( RXM1SIDH, 0,  P_CS_CAN2);

mcp2515_write_register( RXM1SIDL, 0,  P_CS_CAN2);

mcp2515_write_register( RXM1EID8, 0,  P_CS_CAN2);

mcp2515_write_register( RXM1EID0, 0,  P_CS_CAN2);

/*

*  Einstellen der Pin Funktionen

*/

// Deaktivieren der Pins RXnBF Pins (High Impedance State)

mcp2515_write_register( BFPCTRL, 0,  P_CS_CAN1);

mcp2515_write_register( BFPCTRL, 0,  P_CS_CAN2);

// TXnRTS Bits als Inputs schalten

mcp2515_write_register( TXRTSCTRL, 0,  P_CS_CAN1);

mcp2515_write_register( TXRTSCTRL, 0,  P_CS_CAN2);

// Device zurueck in den normalen Modus versetzten

mcp2515_bit_modify( CANCTRL, 0xE0, 0,  P_CS_CAN1);

mcp2515_bit_modify( CANCTRL, 0xE0, 0,  P_CS_CAN2);

// Global enable interrupts

#asm("sei")   

// PORTB |= (1<<0);  // LED AUS

while (1)

      {

      // Place your code here  

 /*     if (timer1 == 100)

      {

        //PORTB |= (1<<0);  // LED AUS

      // Nachricht verschicken

      can_send_message(&message, P_CS_CAN1);

      can_send_message(&message, P_CS_CAN2); 

      printf("Sende ID: 123\r");  

      }     

      if (timer1 == 200)

      {

         //PORTB &= ~(1<<0);   // LED Ein

         timer1=0;

      }

      if (CAN_message_received_CAN1==1)

      {

             CAN_message_received_CAN1 = 0;   

              printf("%d\r",Receive_msg_CAN1.id) ;      

              printf("%d\r",Receive_msg_CAN1.data[0]) ; 

              printf("%d\r",Receive_msg_CAN1.data[1]) ; 

             if(Receive_msg_CAN1.id == 0x124) 

             {

                    PORTB &= ~(1<<0);  // LED Ein

             }

      }  */

     /* if (timer1 == 100)

      {

        //PORTB |= (1<<0);  // LED AUS

      // Nachricht verschicken

      can_send_message(&message, P_CS_CAN1);

      can_send_message(&message, P_CS_CAN2); 

     // printf("Sende ID: 123\r");  

      }     

      if (timer1 == 200)

      {

         //PORTB &= ~(1<<0);   // LED Ein

         timer1=0;

      }        

       */

      if (CAN_message_received_CAN1 ==1)

      {

            CAN_message_received_CAN1 = 0;

            //can_send_message(&Receive_msg_CAN1, P_CS_CAN2);

            //can_send_message(&message, P_CS_CAN1);   

            printf("CAN1\r");  

            printf("%d\r",Receive_msg_CAN1.id) ;

      }                                                    

      if (CAN_message_received_CAN2 ==1)

      {

            CAN_message_received_CAN2 = 0;

            //can_send_message(&Receive_msg_CAN2, P_CS_CAN1); 

            //can_send_message(&message, P_CS_CAN1);   

            printf("CAN2\r");

      }         

      };

}