PIC18F Can Hardwarefilter anstatt Software Filter?

[Manuel B. (desteini)]

Hallo Leute,

Ich habe eine Board entworfen, dass mit Hilfe des PIC18F258 
CAN-Nachrichten per Interrupt liest und schreibt. Soweit funktioniert 
das auch. Sobald der Bus aber eine höhere Last hat (2 Nachrichten alle 
10ms und eine alle 100ms) kommt die Nachricht für das Board (die, die 
alle 100ms verschickt wird) nichtmehr an, oder extrem spät.

Laut PCAN-View werden aber alle Nachrichten richtig auf den Bus 
geschickt. Das heißt es muss ein Problem mit dem Board sein und somit 
mit dem Chip sein.

Die Idee war nun einen Filter zu benutzen um nur diese Nachricht zu 
beachten, die wir brauchen. Leider scheint es mit der benutzten library 
nicht zu funktionieren. Der Code kommt später, vllt findet jemand den 
Fehler, obwohl wir schon einiges ausprobiert haben.

Nun habe ich von einem Hardware Filter gelesen. Eventuell ist das eine 
bessere Lösung als das gesammte Programm mit einer anderen Library neu 
zu schreiben. Habt ihr vorschläge für einen Hardware Filter bzw. glaubt 
ihr dass es nützen wird? Oder glaubt ihr, dass Problem liegt an was 
anderem?

Ist es ein großer Aufwand den Hardware Filter im Nachhinein zu 
integrieren? bzw größer, als das Programm mit einer neuen Library zu 
schreiben?

Can.h

/*********************************************************************
 *
 *                           This is the header for CAN.C
 *   
 *********************************************************************
 * FileName:        CAN.H
 * Dependencies:    CANDef.h
 * Processor:       PIC18FXX8
 * Compiler:        MCC18 v2.20 or higher
 *                  HITECH PICC-18 v8.20PL4 or higher
 * Linker:          
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * The software supplied herewith by Microchip Technology Incorporated
 * (the "Company") is intended and supplied to you, the Company’s
 * customer, for use solely and exclusively with products manufactured
 * by the Company. 
 *
 * The software is owned by the Company and/or its supplier, and is 
 * protected under applicable copyright laws. All rights are reserved. 
 * Any use in violation of the foregoing restrictions may subject the 
 * user to criminal sanctions under applicable laws, as well as to 
 * civil liability for the breach of the terms and conditions of this 
 * license.
 
 * THIS SOFTWARE IS PROVIDED IN AN "AS IS" CONDITION. NO WARRANTIES, 
 * WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED 
 * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
 * PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT, 
 * IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR 
 * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
 *
 *
 *
 *
 * Author               Date        Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Thomas Castmo        06/07/2003  Initial release
 * Thomas Castmo        07/07/2003  Cleared up a bit and implemented 
 *                                  the window function CANCON<3:1> 
 *                                  for interrupts
 * Thomas Castmo        16/07/2003  Added support for the Microchip
 *                                  MPLAB C18 compiler
 * 
 ********************************************************************/
#ifndef __CAN_H
#define __CAN_H

#include "candef.h"

#define CANInit() CANOpen(CAN_CONFIG_1, CAN_CONFIG_2, CAN_CONFIG_3)

#define MASK_ENABLE_ALL 0x00000000      //The mask to enable all incoming messages

#define ACCEPTANCE_MASK_0_1 RXMASK0      //Acceptance mask for filters 0 and 1
#define ACCEPTANCE_MASK_2_5 RXMASK1      //Acceptance mask for filters 2, 3, 4 and 5

//                          0x1FFFFFFF      Maximum extended identifier
//                          0x000007FF      Maximum standard identifier
#define ACCEPTANCE_FILTER_0 RXFILT0      //Acceptance filter 0
#define ACCEPTANCE_FILTER_1 RXFILT1      //Acceptance filter 1

//                          0x1FFFFFFF      Maximum extended identifier
//                          0x000007FF      Maximum standard identifier
#define ACCEPTANCE_FILTER_2 RXFILT2      //Acceptance filter 2
#define ACCEPTANCE_FILTER_3 RXFILT3      //Acceptance filter 3
#define ACCEPTANCE_FILTER_4 RXFILT4      //Acceptance filter 4
#define ACCEPTANCE_FILTER_5 RXFILT5      //Acceptance filter 5

//If a desired filter is to accept extended identifiers
//then comment the appropriate line out
#ifdef ST_FILTER_0
#define ACCEPT_STANDARD_FILTER_0
#endif
#ifdef ST_FILTER_1
#define ACCEPT_STANDARD_FILTER_1
#endif
#ifdef ST_FILTER_2
#define ACCEPT_STANDARD_FILTER_2
#endif
#ifdef ST_FILTER_3
#define ACCEPT_STANDARD_FILTER_3
#endif
#ifdef ST_FILTER_4
#define ACCEPT_STANDARD_FILTER_4
#endif
#ifdef ST_FILTER_5
#define ACCEPT_STANDARD_FILTER_5
#endif




//                            0x1FFFFFFF      Maximum extended identifier
//                            0x000007FF      Maximum standard identifier
#define MY_ADDRESS_IDENTIFIER MY_IDENT

//To use extended identifier for my address, comment the following line out
#ifdef STD_IDENT
#define MY_ADDRESS_IS_STANDARD
#endif


//If using normal mode, comment the following line out
#ifdef LPBACK
#define USE_LOOPBACK_MODE
#endif


//Size of RX buffer (14 bytes per buffer entry) has to be greater than or equal to 2
#define RXBUF RX_BUFFER

//Size of TX buffer (14 bytes per buffer entry) has to be greater than or equal to 2
#define TXBUF TX_BUFFER

#if TXBUF < 2 || RXBUF < 2
#error "The RXbuffer and TXbuffer has to greater than or equal to 2"
#endif
  
//CAN message structure (one message is 15 bytes wide)
struct CANMessage {
  unsigned long Address;
  unsigned char Data[8];
  unsigned char NoOfBytes;
  unsigned char Priority;
  unsigned Ext:1;
  unsigned Remote:1;
};

#define CAN_LISTEN_MODE 0x7F 
#define CAN_LOOPBACK_MODE 0x5F 
#define CAN_DISABLE_MODE 0x3F  
#define CAN_NORMAL_MODE 0x1F




/*********************************************************************
 * Function:        char CANOpen(unsigned char CONFIG1, unsigned char CONFIG2, unsigned char CONFIG3)
 *
 * PreCondition:    None
 *
 * Input:           Values to be written into BRGCON1 -> BRGCON3
 *
 * Output:          0 -> Initialasation succeeded
 *
 * Side Effects:    None
 *
 * Overview:        Sets up the appropriate register for the device to act
 *                  as a CAN node
 *
 * Note:            Input values 0x03, 0xAA, 0x05 at Fosc = 16MHz works with 
 *                  the default firmware at nodeB on the CAN I/O expander board.
 ********************************************************************/
char CANOpen(unsigned char, unsigned char, unsigned char);  


/*********************************************************************
 * Function:        void CANISR(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    Will modify the RX/TX Buffer registers´ Write/Read pointers
 *
 * Overview:        Checks if a CAN reception/transmission was complete 
 *                  and if so write/read to the CAN RX/TX FIFO buffers
 *
 * Note:            This function is supposed to be called from the ISR
 ********************************************************************/
void CANISR(void);


/*********************************************************************
 * Function:        char CANPut(struct CANMessage Message)
 *
 * PreCondition:    None
 *
 * Input:           A CAN message
 *
 * Output:          1 -> Failed to put a CAN on the buffer, buffer is full
 *                  0 -> The CAN message is put on the buffer and will be 
 *                       transmitted eventually 
 *
 * Side Effects:    Will modify the TX Buffer register´s Write pointer
 *
 * Overview:        Initially checks if at least one buffer slot is available
 *                  and if so push the requested message in the buffer
 *
 * Note:            None
 ********************************************************************/
char CANPut(struct CANMessage);


/*********************************************************************
 * Function:        char CANRXMessageIsPending(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          1 -> At least one received message is pending in the RX buffer
 *                  0 -> No received messages are pending
 *
 * Side Effects:    None
 *
 * Overview:        Checks if the RX Write pointer is equal to RX Read pointer and
 *                  if so returns 0, else returns 1
 *
 * Note:            Since no care is taken if the buffer overflow
 *                  this function has to be polled frequently to
 *                  prevent a software receive buffer overflow
 ********************************************************************/
char CANRXMessageIsPending(void);


/*********************************************************************
 * Function:        struct CANMessage CANGet(void)
 *
 * PreCondition:    An unread message has to be in the buffer
 *                  use RXCANMessageIsPending(void) prior to 
 *                  calling this function in order to determine
 *                  if an unread message is pending.
 *
 * Input:           None
 *
 * Output:          The received message
 *
 * Side Effects:    Will modify the RX Buffer register´s Read pointer
 *
 * Overview:        Pops the the first message of the RX buffer
 *
 * Note:            None
 ********************************************************************/
struct CANMessage CANGet(void);


/*********************************************************************
 * Function:        void CANSetMode(unsigned char Mode)
 *
 * PreCondition:    None
 *
 * Input:           Desired CAN Mode
 *                  (CAN_LISTEN_MODE, CAN_LOOPBACK_MODE
 *                   CAN_DISABLE_MODE, CAN_NORMAL_MODE)
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Requests to set the desired mode and waits until
 *          the mode has been set.
 *
 * Note:            If USE_LOOPBACK_MODE is defined the requested
 *                  mode will be loopback mode if the input is
 *                  Normal mode
 ********************************************************************/
void CANSetMode(unsigned char);

#endif

Definitions.h

#ifndef __DEFINITIONS_H
#define __DEFINITIONS_H

#include <p18f258.h> // Define PIC we are using
#include <stdlib.h>
#include <string.h>
#include <spi.h>
#include <timers.h>
#include <delays.h>


//#pragma config OSC = LP            //Oscillator Selection:LP
//#pragma config OSC = XT            //Oscillator Selection:XT
#pragma config OSC = HS            //Oscillator Selection:HS
//#pragma config OSC = RC            //Oscillator Selection:RC
//#pragma config OSC = EC            //Oscillator Selection:EC-OSC2 as Clock Out
//#pragma config OSC = ECIO          //Oscillator Selection:EC-OSC2 as RA6
//#pragma config OSC = HSPLL         //Oscillator Selection:HS-PLL Enabled
//#pragma config OSC = RCIO          //Oscillator Selection:RC-OSC2 as RA6
               
#pragma config OSCS = OFF           //Osc. Switch On Off

#pragma config    PWRT = OFF              //Power Up Timer
 
#pragma config BOR = OFF               //Brown Out Reset:
  
#pragma config BORV = 25               //Brown Out Voltage:4.5V
// #pragma config BORV = 42         //Brown Out Voltage:4.2V
// #pragma config BORV = 27         //Brown Out Voltage:2.7V
// #pragma config BORV = 25         //Brown Out Voltage:2.5V

 
#pragma config WDT = OFF             // Watchdog Timer
 
//#pragma config WDTPS = 1               //Watchdog Postscaler:1:1
//#pragma config WDTPS = 2               //Watchdog Postscaler:1:2
//#pragma config WDTPS = 4               //Watchdog Postscaler:1:4
//#pragma config WDTPS = 8               //Watchdog Postscaler:1:8
//#pragma config WDTPS = 16              //Watchdog Postscaler:1:16
//#pragma config WDTPS = 32              //Watchdog Postscaler:1:32
//#pragma config WDTPS = 64              //Watchdog Postscaler:1:64
//#pragma config WDTPS = 128             //Watchdog Postscaler:1:128

//#pragma config CCP2MUX = OFF           //CCP2 Mux:Disable (RB3)

#pragma config STVR = OFF              //Stack Overflow Reset:Disabled
    
#pragma config LVP = OFF               //Low Voltage ICSP:Disabled
       
#pragma config DEBUG = OFF             //Background Debugger Enable:Disabled
   
#pragma config CP0 = OFF               //Code Protection Block 0:Disabled
#pragma config CP1 = OFF               //Code Protection Block 1:Disabled
#pragma config CP2 = OFF               //Code Protection Block 2:Disabled
#pragma config CP3 = OFF               //Code Protection Block 3:Disabled
#pragma config CPB = OFF               //Boot Block Code Protection:Disabled
#pragma config CPD = OFF               //Data EEPROM Code Protection:Disabled
#pragma config WRT0 = OFF              //Write Protection Block 0:Disabled
#pragma config WRT1 = OFF              //Write Protection Block 1:Disabled
#pragma config WRT2 = OFF              //Write Protection Block 2:Disabled
#pragma config WRT3 = OFF              //Write Protection Block 3:Disabled
#pragma config WRTB = OFF              //Boot Block Write Protection:Disabled  
#pragma config WRTC = OFF              //Configuration Register Write Protection:Disabled
#pragma config WRTD = OFF              //Data EEPROM Write Protection:Disabled
#pragma config EBTR0 = OFF             //Table Read Protection Block 0:Disabled
#pragma config EBTR1 = OFF             //Table Read Protection Block 1:Disabled
#pragma config EBTR2 = OFF             //Table Read Protection Block 2:Disabled
#pragma config EBTR3 = OFF             //Table Read Protection Block 3:Disabled
#pragma config EBTRB = OFF             //Boot Block Table Read Protection:Disabled


/*-----------------------------------
----------- DEFINITIONS -------------
-----------------------------------*/

//Ecan 
#define CAN_RX      PORTBbits.RB3
#define CAN_TX      PORTBbits.RB2

//Canflag
#define CF0                      PIR3bits.RXB0IF
#define CF1                      PIR3bits.RXB1IF
#define CRF0                     PIR3bits.TXB0IF
#define CRF1                     PIR3bits.TXB1IF

//Timerflag
#define T0F                     INTCONbits.TMR0IF
#define T1F                     PIR1bits.TMR1IF
#define T2F                     PIR1bits.TMR2IF
#define T3F                     PIR2bits.TMR3IF

// Timerstatus
#define T0Status                T0CONbits.TMR0ON
#define T1Status                T1CONbits.TMR1ON
#define T2Status                T2CONbits.TMR2ON
//LED
#define LED        PORTAbits.RA0
//relay control PORTA
#define LAC        PORTAbits.RA1
#define RAC        PORTAbits.RA2
#define SLC        PORTAbits.RA3
//#define HBC        PORTAbits.RA4
#define HBMOC        PORTAbits.RA5

//relay control PORTC
#define HBC      PORTCbits.RC6
#define WWC      PORTCbits.RC5
#define HC      PORTCbits.RC4

//Inputs PORTC
#define SA                      PORTCbits.RC7
#define SLS      PORTCbits.RC3
#define SPT      PORTCbits.RC2
#define SFS      PORTCbits.RC1
#define SFD      PORTCbits.RC0

#define OFF       1
#define ON         !OFF

#define FALSE       0
#define TRUE       !FALSE

#define OK         1
#define ERROR       !OK

#define DEBUG_DEFAULT   0
#define DEBUG_SMALL   1
#define DEBUG_MEDIUM   2
#define DEBUG_FULL     3

//#define MY_IDENT
//#define THROTTLE_ID    0x110
//#define  GEAR_ID      0x120
#define HEBELID                 0x104


/*-----------------------------------
--------ERRORS CODE -----------------
-----------------------------------*/
#define UKNOWN_CMD     99
#define BAD_CMD     7
#define BAD_DEVC     1
#define BAD_DATA     2


//valore in percentuale di quanto sia premuto l'accelleratore. 0 sollevato - 255 premuto completamente
unsigned char LeftArrow, RightArrow, StopLight,HighBeam,HighBeamManual, Wipewasher, Horn;
unsigned int Buffer;

int len;
long timer;

char msg_ready;  //flag per inviare un messaggio tramite can
unsigned char Msg[8];

#endif

CANdef.h

/****************************************************
*       This file was created by                    *
*       Microchip Application Maestro               *
*       and holds the set-up parameters             *
*       specified when the code was generated.      *
*       The user is advised not to make any         *
*       changes to this file                        *
****************************************************/
#define BAUD_RATE_PRESC 1
#define SJW_TIME 4
#define SAMPLES 3
#define PROP_TIME 1
#define PH_SEG_1 4
#define PH_SEG_2 4
#define CAN_CONFIG_1 BAUD_RATE_PRESC-1|(SJW_TIME-1<<6)
#if SAMPLES == 1
#define CAN_CONFIG0_2 0x80|(PH_SEG_1-1<<3)|(PROP_TIME-1)
#elif SAMPLES == 3
#define CAN_CONFIG_2 0xC0|(PH_SEG_1-1<<3)|(PROP_TIME-1)
#else
#error "Number of samples is out of range"
#endif
#define CAN_CONFIG_3 PH_SEG_2-1
#define RXMASK0 -1
#define RXMASK1 -1
#define RXFILT0 0x104
#define ST_FILTER_0 
#define RXFILT1 0x104
#define ST_FILTER_1 
#define RXFILT2 0x104
#define ST_FILTER_2
#define RXFILT3 0x104
#define ST_FILTER_3
#define RXFILT4 0x104
#define ST_FILTER_4
#define RXFILT5 0x104
#define ST_FILTER_5
//#define LPBACK
//#define MY_IDENT 0x150
#define STD_IDENT
#define RX_BUFFER 4
#define TX_BUFFER 4
//#define CAN_INT_LOW
//#define CAN_ERROR_HANDLER_ENABLE

Can.c

/*********************************************************************
 *
 *   This file contains CAN drivers for PIC18Fxx8 devices
 *   
 *********************************************************************
 * FileName:        CAN.C
 * Dependencies:    CAN.H, PIC18.H or P18CXXX.H
 * Processor:       PIC18FXX8
 * Compiler:        MCC18 v2.20 or higher
 *                  HITECH PICC-18 v8.20PL4 or higher
 * Linker:          
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * The software supplied herewith by Microchip Technology Incorporated
 * (the "Company") is intended and supplied to you, the Company’s
 * customer, for use solely and exclusively with products manufactured
 * by the Company. 
 *
 * The software is owned by the Company and/or its supplier, and is 
 * protected under applicable copyright laws. All rights are reserved. 
 * Any use in violation of the foregoing restrictions may subject the 
 * user to criminal sanctions under applicable laws, as well as to 
 * civil liability for the breach of the terms and conditions of this 
 * license.
 
 * THIS SOFTWARE IS PROVIDED IN AN "AS IS" CONDITION. NO WARRANTIES, 
 * WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED 
 * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
 * PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT, 
 * IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR 
 * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
 *
 *
 *
 *
 * Author               Date        Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Thomas Castmo        06/07/2003  Initial release
 * Thomas Castmo        07/07/2003  Cleared up a bit and implemented 
 *                                  the window function CANCON<3:1> 
 *                                  for interrupts
 * Thomas Castmo        16/07/2003  Added support for the Microchip
 *                                  MPLAB C18 compiler
 * 
 ********************************************************************/
#include "can.h"

#if defined(HI_TECH_C)
    #if defined(_MPC_)
        #define HITECH_C18
    #else
        #error "Unknown part is selected."
    #endif
#else
    #define MCHP_C18
#endif

#if defined(MCHP_C18) && defined(HITECH_C18)
#error "Invalid Compiler selection."
#endif

#if !defined(MCHP_C18) && !defined(HITECH_C18)
#error "Compiler not supported."
#endif


#if defined(HITECH_C18)
#include <pic18.h>

#elif defined(MCHP_C18)
#include <p18cxxx.h>

#define TRISB2 TRISBbits.TRISB2
#define TRISB3 TRISBbits.TRISB3
#define TXB0REQ TXB0CONbits.TXREQ
#define RXB0FUL RXB0CONbits.RXFUL
#define RXB0RTRRO RXB0CONbits.RXRTRRO

#define RXB0IF PIR3bits.RXB0IF
#define RXB1IF PIR3bits.RXB1IF
#define TXB0IF PIR3bits.TXB0IF
#define TXB1IF PIR3bits.TXB1IF
#define TXB2IF PIR3bits.TXB2IF
#define ERRIF PIR3bits.ERRIF
#define WAKIF PIR3bits.WAKIF

#define RXB0IE PIE3bits.RXB0IE
#define RXB1IE PIE3bits.RXB1IE
#define TXB0IE PIE3bits.TXB0IE
#define TXB1IE PIE3bits.TXB1IE
#define TXB2IE PIE3bits.TXB2IE
#define ERRIE PIE3bits.ERRIE
#define WAKIE PIE3bits.WAKIE


#endif



#define CONFIG_MODE 0x9F
#define LISTEN_MODE 0x7F 
#define LOOPBACK_MODE 0x5F 
#define DISABLE_MODE 0x3F  
#define NORMAL_MODE 0x1F
#define MODE_MASK 0xE0

#define NoInterrupt 0x00
#define ErrorInterrupt 0x02
#define TXB2Interrupt 0x04
#define TXB1Interrupt 0x06
#define TXB0Interrupt 0x08
#define RXB1Interrupt 0x0A
#define RXB0Interrupt 0x0C
#define WakeUpInterrupt 0x0E


#ifdef CAN_ERROR_HANDLER_ENABLE
extern void CANErrorHandler(void);
#define CAN_INT_BITS 0x3F  //CAN interrupts which should be enabled, simply what PIE3 is to be loaded with (Note all TXB IE will be set regardless of this value)
#else
#define CAN_INT_BITS 0x1F  //CAN interrupts which should be enabled, simply what PIE3 is to be loaded with (Note all TXB IE will be set regardless of this value)
#endif

union RXBuffer {        //Receive buffer structure
  unsigned char Data[14];    //It has to be a bit messy/strict for
  struct {          //it to go trough the PICC18 compiler
    union {
      unsigned char Byte;
      struct {
        unsigned FILHIT0:1;
        unsigned JTOFF:1;
        unsigned RXB0DBEN:1;
        unsigned RXRTRRO:1;
        unsigned :1;
        unsigned RXM0:1;
        unsigned RXM1:1;
        unsigned RXFUL:1;
      } Bits;
    } RXBCON;
    union {
      unsigned char Byte;
    } RXBSIDH;
    union {
      unsigned char Byte;
      struct {
        unsigned EID16:1;
        unsigned EID17:1;
        unsigned :1;
        unsigned EXID:1;
        unsigned SRR:1;
        unsigned SID0:1;
        unsigned SID1:1;
        unsigned SID2:1;
      } Bits;
    } RXBSIDL;
    union {
      unsigned char Byte;
    } RXBEIDH;
    union {
      unsigned char Byte;
    } RXBEIDL;
    union {
      unsigned char Byte;
      struct {
        unsigned DLC0:1;
        unsigned DLC1:1;
        unsigned DLC2:1;
        unsigned DLC3:1;
        unsigned RB0:1;
        unsigned RB1:1;
        unsigned RXRTR:1;
        unsigned :1;
      } Bits;
    } RXBDLC;
    union {
      unsigned char Array[8];
      struct {
        unsigned char RXBD0;
        unsigned char RXBD1;
        unsigned char RXBD2;
        unsigned char RXBD3;
        unsigned char RXBD4;
        unsigned char RXBD5;
        unsigned char RXBD6;
        unsigned char RXBD7;
      } Bytes;
    } RXBD;
  } Specific;
};

union TXBuffer {          //Transmit buffer structure
  unsigned char Data[14];
  struct {
    union {
      unsigned char Byte;
      struct {
        unsigned TXPRI0:1;
        unsigned TXPRI1:1;
        unsigned :1;
        unsigned TXREQ:1;
        unsigned TXERR:1;
        unsigned TXLARB:1;
        unsigned TXABT:1;
      } Bits;
    } TXBCON;
    union {
      unsigned char Byte;
    } TXBSIDH;
    union {
      unsigned char Byte;
      struct {
        unsigned EID16:1;
        unsigned EID17:1;
        unsigned :1;
        unsigned EXIDE:1;
        unsigned :1;
        unsigned SID0:1;
        unsigned SID1:1;
        unsigned SID2:1;
      } Bits;
    } TXBSIDL;
    union {
      unsigned char Byte;
    } TXBEIDH;
    union {
      unsigned char Byte;
    } TXBEIDL;
    union {
      unsigned char Byte;
      struct {
        unsigned DLC0:1;
        unsigned DLC1:1;
        unsigned DLC2:1;
        unsigned DLC3:1;
        unsigned :1;
        unsigned :1;
        unsigned TXRTR:1;
        unsigned :1;
      } Bits;
    } TXBDLC;
    union {
      unsigned char Array[8];
      struct {
        unsigned char TXBD0;
        unsigned char TXBD1;
        unsigned char TXBD2;
        unsigned char TXBD3;
        unsigned char TXBD4;
        unsigned char TXBD5;
        unsigned char TXBD6;
        unsigned char TXBD7;
      } Bytes;
    } TXBD;
  } Specific;
};
union RXBuffer RXMessage[RXBUF];    //Received messages FIFO buffer
union TXBuffer TXMessage[TXBUF];    //Pending messages to transmit FIFO buffer
char RXRPtr = 0;            //Read pointer for RXMessage buffer
char RXWPtr = 0;            //Write pointer for RXMessage buffer
char TXRPtr = 0;            //Read pointer for TXMessage buffer
char TXWPtr = 0;            //Write pointer for TXMessage buffer


/*********************************************************************
 * Function:        void CANGetMessage(void)
 *
 * PreCondition:    <WIN2:WIN0> in the CANCON register has to set
 *                  to reflect the desired RXB registers
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    Will modify the RX FIFO Write pointer (RXWPtr)
 *
 * Overview:        Gets the registers for a RXB and puts them in the
 *                  CAN Receive buffer
 *
 * Note:            Care is not taken if buffer is full
 ********************************************************************/
void CANGetMessage(void);

/*********************************************************************
 * Function:        char CANPutMessage(void)
 *
 * PreCondition:    <WIN2:WIN0> in the CANCON register has to set
 *                  to reflect the desired TXB registers
 *
 * Input:           None
 *
 * Output:          0 -> A new message has been put in the transmit queue
 *                  1 -> There was no messages in the TX buffer to send
 *
 * Side Effects:    Will modify the TX buffer´s Read pointer (TXRPtr)
 *
 * Overview:        Checks if there is any messages to transmit and if so
 *                  place it in the registers reflected by <WIN2:WIN0> 
 *
 * Note:            None
 ********************************************************************/
 char CANPutMessage(void);

/*********************************************************************
 * Function:        char CANOpen(void)
 *
 * PreCondition:    None
 *
 * Input:           Values to be written into BRGCON1 -> BRGCON3
 *
 * Output:          0 -> Initialasation succeeded
 *
 * Side Effects:    None
 *
 * Overview:        Sets up the appropriate register for the device to act
 *                  as a CAN node
 *
 * Note:            Input values 0x03, 0xAA, 0x05 at Fosc = 16MHz works with 
 *                  the default firmware at nodeB on the CAN I/O expander board.
 ********************************************************************/
char CANOpen(unsigned char CONFIG1, unsigned char CONFIG2, unsigned char CONFIG3)
{
  TRISB2 = 0;
  TRISB3 = 1;
  PIE3 = 0;                    //Disable all CAN interrupts
  PIR3 = 0;                    //and clear all CAN interrupt flags
  CANCON = (CONFIG_MODE & MODE_MASK) | (CANCON & 0x3F);  //Set configuration mode
  while((CANSTAT & MODE_MASK) != (CONFIG_MODE & MODE_MASK));  //Wait until config mode is set

  BRGCON1 = CONFIG1;
  BRGCON2 = CONFIG2;
  BRGCON3 = CONFIG3;
  
  RXB0CON = 0x04;          //Receive all valid messages receive buffer overflow 
  RXB1CON = 0x00;          //writes to RXB1
  
  //Set the acceptance filters for all the filters
#ifdef ACCEPT_STANDARD_FILTER_0
  RXF0SIDL = (unsigned char)(ACCEPTANCE_FILTER_0 << 5);
  RXF0SIDH = (unsigned char)(ACCEPTANCE_FILTER_0 >> 3);
#else
  RXF0EIDL = (unsigned char)(ACCEPTANCE_FILTER_0 & 0xFF);  
  RXF0EIDH = (unsigned char)((ACCEPTANCE_FILTER_0 >> 8) & 0xFF);
  RXF0SIDL = (unsigned char)((ACCEPTANCE_FILTER_0 >> 16) & 0x03) | (unsigned char)((ACCEPTANCE_FILTER_0 >> 13) & 0xE0) | 0x08;
  RXF0SIDH = (unsigned char)((ACCEPTANCE_FILTER_0 >> 21) & 0xFF);
#endif
#ifdef ACCEPT_STANDARD_FILTER_1
  RXF1SIDL = (unsigned char)(ACCEPTANCE_FILTER_1 << 5);
  RXF1SIDH = (unsigned char)(ACCEPTANCE_FILTER_1 >> 3);
#else
  RXF1EIDL = (unsigned char)(ACCEPTANCE_FILTER_1 & 0xFF);  
  RXF1EIDH = (unsigned char)((ACCEPTANCE_FILTER_1 >> 8) & 0xFF);
  RXF1SIDL = (unsigned char)((ACCEPTANCE_FILTER_1 >> 16) & 0x03) | (unsigned char)((ACCEPTANCE_FILTER_1 >> 13) & 0xE0) | 0x08;
  RXF1SIDH = (unsigned char)((ACCEPTANCE_FILTER_1 >> 21) & 0xFF);
#endif

#ifdef ACCEPT_STANDARD_FILTER_2
  RXF2SIDL = (unsigned char)(ACCEPTANCE_FILTER_2 << 5);
  RXF2SIDH = (unsigned char)(ACCEPTANCE_FILTER_2 >> 3);
#else
  RXF2EIDL = (unsigned char)(ACCEPTANCE_FILTER_2 & 0xFF);  
  RXF2EIDH = (unsigned char)((ACCEPTANCE_FILTER_2 >> 8) & 0xFF);
  RXF2SIDL = (unsigned char)((ACCEPTANCE_FILTER_2 >> 16) & 0x03) | (unsigned char)((ACCEPTANCE_FILTER_2 >> 13) & 0xE0) | 0x08;
  RXF2SIDH = (unsigned char)((ACCEPTANCE_FILTER_2 >> 21) & 0xFF);
#endif

#ifdef ACCEPT_STANDARD_FILTER_3
  RXF3SIDL = (unsigned char)(ACCEPTANCE_FILTER_3 << 5);
  RXF3SIDH = (unsigned char)(ACCEPTANCE_FILTER_3 >> 3);
#else
  RXF3EIDL = (unsigned char)(ACCEPTANCE_FILTER_3 & 0xFF);  
  RXF3EIDH = (unsigned char)((ACCEPTANCE_FILTER_3 >> 8) & 0xFF);
  RXF3SIDL = (unsigned char)((ACCEPTANCE_FILTER_3 >> 16) & 0x03) | (unsigned char)((ACCEPTANCE_FILTER_3 >> 13) & 0xE0) | 0x08;
  RXF3SIDH = (unsigned char)((ACCEPTANCE_FILTER_3 >> 21) & 0xFF);
#endif

#ifdef ACCEPT_STANDARD_FILTER_4
  RXF4SIDL = (unsigned char)(ACCEPTANCE_FILTER_4 << 5);
  RXF4SIDH = (unsigned char)(ACCEPTANCE_FILTER_4 >> 3);
#else
  RXF4EIDL = (unsigned char)(ACCEPTANCE_FILTER_4 & 0xFF);  
  RXF4EIDH = (unsigned char)((ACCEPTANCE_FILTER_4 >> 8) & 0xFF);
  RXF4SIDL = (unsigned char)((ACCEPTANCE_FILTER_4 >> 16) & 0x03) | (unsigned char)((ACCEPTANCE_FILTER_4 >> 13) & 0xE0) | 0x08;
  RXF4SIDH = (unsigned char)((ACCEPTANCE_FILTER_4 >> 21) & 0xFF);
#endif

#ifdef ACCEPT_STANDARD_FILTER_5
  RXF5SIDL = (unsigned char)(ACCEPTANCE_FILTER_5 << 5);
  RXF5SIDH = (unsigned char)(ACCEPTANCE_FILTER_5 >> 3);
#else
  RXF5EIDL = (unsigned char)(ACCEPTANCE_FILTER_5 & 0xFF);  
  RXF5EIDH = (unsigned char)((ACCEPTANCE_FILTER_5 >> 8) & 0xFF);
  RXF5SIDL = (unsigned char)((ACCEPTANCE_FILTER_5 >> 16) & 0x03) | (unsigned char)((ACCEPTANCE_FILTER_4 >> 13) & 0xE0) | 0x08;
  RXF5SIDH = (unsigned char)((ACCEPTANCE_FILTER_5 >> 21) & 0xFF);
#endif

//Set the acceptance masks
  RXM0EIDL = (unsigned char)(ACCEPTANCE_MASK_0_1 & 0xFF);  
  RXM0EIDH = (unsigned char)((ACCEPTANCE_MASK_0_1 >> 8) & 0xFF);
  RXM0SIDL = (unsigned char)((ACCEPTANCE_MASK_0_1 >> 16) & 0x03) | (unsigned char)((ACCEPTANCE_MASK_0_1 >> 13) & 0xE0) | 0x08;
  RXM0SIDH = (unsigned char)((ACCEPTANCE_MASK_0_1 >> 21) & 0xFF);
  RXM1EIDL = (unsigned char)(ACCEPTANCE_MASK_2_5 & 0xFF);  
  RXM1EIDH = (unsigned char)((ACCEPTANCE_MASK_2_5 >> 8) & 0xFF);
  RXM1SIDL = (unsigned char)((ACCEPTANCE_MASK_2_5 >> 16) & 0x03) | (unsigned char)((ACCEPTANCE_MASK_2_5 >> 13) & 0xE0) | 0x08;
  RXM1SIDH = (unsigned char)((ACCEPTANCE_MASK_2_5 >> 21) & 0xFF);

  CIOCON = 0x20;            //Drive TX pin Vdd when recessive, disable capture

#ifdef CAN_LOW_INT
  IPR3 = 0x00;
#else
  IPR3 = 0xFF;
#endif

#ifdef USE_LOOPBACK_MODE
  CANCON = (LOOPBACK_MODE & MODE_MASK) | (CANCON & (MODE_MASK ^ 0xFF));          //Set loopback mode for debug purposes only
  while((CANSTAT & MODE_MASK) != (LOOPBACK_MODE & MODE_MASK));  //Wait until loopback mode is set
#else
  CANCON = (NORMAL_MODE & MODE_MASK) | (CANCON & (MODE_MASK ^ 0xFF));          //Set normal mode
  while((CANSTAT & MODE_MASK) != (NORMAL_MODE & MODE_MASK));    //Wait until normal mode is set
#endif
  PIE3 = CAN_INT_BITS & 0xE3;      //Enable CAN interrupts except TX interrupts
//  PIR3 = 0x18;            //Set TXB1 & TXB2 int flags
PIR3 = 0x0;            //Set TXB1 & TXB2 int flags

//Send my address to notify our presence
#ifdef MY_ADDRESS_IS_STANDARD
  TXB0SIDL = (unsigned char)(MY_ADDRESS_IDENTIFIER << 5);
  TXB0SIDH = (unsigned char)(MY_ADDRESS_IDENTIFIER >> 3);    //Load address with MY_ADDRESS_IDENTIFIER standard identifier
  TXB0DLC = 0x00;                        //0 data bytes to send
  TXB0CON = 0x00;                        //Initiate transmission
  TXB0REQ = 1;
#else
  TXB0EIDL = (unsigned char)(MY_ADDRESS_IDENTIFIER & 0xFF);  //Load address with MY_ADDRESS_IDENTIFIER extended identifier
  TXB0EIDH = (unsigned char)((MY_ADDRESS_IDENTIFIER >> 8) & 0xFF);
  TXB0SIDL = (unsigned char)((MY_ADDRESS_IDENTIFIER >> 16) & 0x03) | (unsigned char)((ACCEPTANCE_FILTER_2 >> 13) & 0xE0) | 0x08;
  TXB0SIDH = (unsigned char)((MY_ADDRESS_IDENTIFIER >> 21) & 0xFF);
  TXB0DLC = 0x00;                        //0 data bytes to send
  TXB0CON = 0x00;                        //Initiate transmission
  TXB0REQ = 1;
#endif
  
  return 0;
}


/*********************************************************************
 * Function:        void CANISR(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    Will modify the RX/TX interrupt flags 
 *                  and interrupt enable bits
 *
 * Overview:        Checks if a CAN reception/transmission was complete 
 *                  and if so write/read to the CAN RX/TX FIFO buffers
 *
 * Note:            This function is supposed to be called from the ISR
 ********************************************************************/
void CANISR(void)
{
  unsigned char TempCANCON;

  if(PIR3 & PIE3)
  {
    TempCANCON = CANCON;
    
    if(RXB0IF && RXB0IE)
    {
      RXB0IF = 0;    //Clear interrupt flag
      CANCON = CANCON & 0xF0 | RXB0Interrupt;
      CANGetMessage();
    }
    else if(RXB1IF && RXB1IE)
    {
      RXB1IF = 0;    //Clear interrupt flag
      CANCON = CANCON & 0xF0 | RXB1Interrupt;
      CANGetMessage();
    }
    else if(TXB0IF && TXB0IE)
    {
      CANCON = CANCON & 0xF0 | TXB0Interrupt;
      if(CANPutMessage())
        TXB0IE = 0;
      else
        TXB0IF = 0;
    }
    else if(TXB1IF && TXB1IE)
    {
      CANCON = CANCON & 0xF0 | TXB1Interrupt;
      if(CANPutMessage())
        TXB1IE = 0;
      else
        TXB1IF = 0;
    }
    else if(TXB2IF && TXB2IE)
    {
      CANCON = CANCON & 0xF0 | TXB2Interrupt;
      if(CANPutMessage())      //if there wasn't any more messages to send
        TXB2IE = 0;        //disable interrupts for TXB2 and leave TXB2IF 
      else            //still on so PutCAN() can reenable the interrupt and instantly vector to ISR
        TXB2IF = 0;        //message was sent, just clear the interrupt flag.
    }
    else if(ERRIF && ERRIE)
    {
      ERRIF = 0;      //Clear interrupt flag
#ifdef CAN_ERROR_HANDLER_ENABLE
      CANErrorHandler();
#endif      
                //No error handler implemented!!!
    }
    else if(WAKIF && WAKIE)
    {
      WAKIF = 0;      //Clear interrupt flag
    }

    CANCON = TempCANCON;
  }
}


/*********************************************************************
 * Function:        void CANGetMessage(void)
 *
 * PreCondition:    <WIN2:WIN0> in the CANCON register has to set
 *                  to reflect the desired RXB registers
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    Will modify the RX FIFO Write pointer (RXWPtr)
 *
 * Overview:        Gets the registers for a RXB and puts them in the
 *                  CAN Receive buffer
 *
 * Note:            Care is not taken if buffer is full
 ********************************************************************/
void CANGetMessage(void)
{
  unsigned char i;
  if(++RXWPtr >= RXBUF)    //If pointer overflowed
    RXWPtr = 0;        //Clear it
  
  for(i=0;i<14;i++)
  {
    RXMessage[RXWPtr].Data[i] = *(unsigned char *)(0xF60+i);
  }
  RXB0FUL = 0;
}


/*********************************************************************
 * Function:        char CANPutMessage(void)
 *
 * PreCondition:    <WIN2:WIN0> in the CANCON register has to set
 *                  to reflect the desired TXB registers
 *
 * Input:           None
 *
 * Output:          0 -> A new message has been put in the transmit queue
 *                  1 -> There was no messages in the TX buffer to send
 *
 * Side Effects:    Will modify the TX buffer´s Read pointer (TXRPtr)
 *
 * Overview:        Checks if there is any messages to transmit and if so
 *                  place it in the registers reflected by <WIN2:WIN0> 
 *
 * Note:            None
 ********************************************************************/
char CANPutMessage(void)
{
  unsigned char i;
  if(TXWPtr != TXRPtr)            //If there are any more data to send
  {
    if(++TXRPtr >= TXBUF)          //then increment the TX read pointer
      TXRPtr = 0;
    for(i=0;i<14;i++)
      *(unsigned char *)(0xF60+i) = TXMessage[TXRPtr].Data[i];
    RXB0RTRRO = 1;              //TXREQ = 1;
    return 0;
  }
  else
    return 1;
}


/*********************************************************************
 * Function:        char CANPut(struct CANMessage Message)
 *
 * PreCondition:    None
 *
 * Input:           A CAN message
 *
 * Output:          1 -> Failed to put a CAN on the buffer, buffer is full
 *                  0 -> The CAN message is put on the buffer and will be 
 *                       transmitted eventually 
 *
 * Side Effects:    Will modify the TX Buffer register´s Write pointer
 *
 * Overview:        Initially checks if at least one buffer slot is available
 *                  and if so push the requested message in the buffer.
 *                  Checks if the TX modules are idle and if they are, reactivate one.
 *
 * Note:            None
 ********************************************************************/
char CANPut(struct CANMessage Message)
{
  unsigned char TempPtr, i;
  if(TXWPtr == TXRPtr-1 || (TXWPtr == TXBUF-1 && TXRPtr == 0))  //if all transmit buffers are full return 1
    return 1;
    
  //Do not modify the TX pointer until the message has been successfully copied so the CANISR don't
  //send a message that isn't ready
  if(TXWPtr >= TXBUF-1)          //check if transmit write pointer will overflow
  {
    TempPtr = 0;              //and post clear write pointer
  }
  else
  {
    TempPtr = TXWPtr+1;              //and postincrement write pointer
  }
  
  if(Message.NoOfBytes > 8)          //Ensure we don't handle more than 8 bytes
    Message.NoOfBytes = 8;  
    
  TXMessage[TempPtr].Specific.TXBDLC.Byte = Message.NoOfBytes;        //Set the data count

  if(!Message.Remote)      //If dataframe
  {
    TXMessage[TempPtr].Specific.TXBDLC.Bits.TXRTR = 0;                //Clear the Remote Transfer Request bit
    
    for(i = 0; i < Message.NoOfBytes; i++)  //Load data registers
    {
      TXMessage[TempPtr].Specific.TXBD.Array[i] = Message.Data[i];
    }
  }
  else                      //Remote frame
  {
    TXMessage[TempPtr].Specific.TXBDLC.Bits.TXRTR = 1;                //Set TXRTR bit
  }
  if(Message.Ext)            //Extended identifier
  {
    TXMessage[TempPtr].Specific.TXBEIDL.Byte = (unsigned char)(Message.Address & 0xFF);      // Put address <7:0> in EIDL
    TXMessage[TempPtr].Specific.TXBEIDH.Byte = (unsigned char)((Message.Address >> 8) & 0xFF);  // Put address <15:8> in EIDH
    TXMessage[TempPtr].Specific.TXBSIDL.Byte = (unsigned char)((Message.Address >> 16) & 0x03) | (unsigned char)((Message.Address >> 13) & 0xE0);
    TXMessage[TempPtr].Specific.TXBSIDH.Byte = (unsigned char)((Message.Address >> 21) & 0xFF);
    TXMessage[TempPtr].Specific.TXBSIDL.Bits.EXIDE = 1;
  }
  else                      //Standard identifier
  {
    TXMessage[TempPtr].Specific.TXBSIDL.Byte = (unsigned char)((Message.Address << 5) & 0xFF);  //Put address <2:0> in SIDL
    TXMessage[TempPtr].Specific.TXBSIDH.Byte = (unsigned char)((Message.Address >> 3) & 0xFF);  //Put address <10:3> in SIDH
    TXMessage[TempPtr].Specific.TXBSIDL.Bits.EXIDE = 0;
  }
  TXMessage[TempPtr].Specific.TXBCON.Byte = Message.Priority & 0x03;  //Set the internal priority of the data frame
  
  TXWPtr = TempPtr;

  //Reenable an interrupt if it is idle, it doesn't matter if another TX source caught the pending message
  //before the source that is enabled here does since the interrupt CHECKS if there are any messages pending
  //and if the buffer is empty, it will disable itself again.
  if(!TXB0IE)      //TXB0 is idle
    TXB0IE = 1;    //enable TXB0 to fire an interrupt to send the pending message
  else if(!TXB1IE)    //else if TXB1 is idle
    TXB1IE = 1;    //same procedure
  else if(!TXB2IE)    //finally try TXB2
    TXB2IE = 1;  

  return 0;
}


/*********************************************************************
 * Function:        char CANRXMessageIsPending(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          1 -> At least one received message is pending in the RX buffer
 *                  0 -> No received messages are pending
 *
 * Side Effects:    None
 *
 * Overview:        Checks if the RX Write pointer is equal to RX Read pointer and
 *                  if so returns 0, else returns 1
 *
 * Note:            Since no care is taken if the buffer overflow
 *                  this function has to be polled frequently to
 *                  prevent a software receive buffer overflow
 ********************************************************************/
char CANRXMessageIsPending(void)
{
  if(RXWPtr != RXRPtr)
    return 1;
  else
    return 0;
}



/*********************************************************************
 * Function:        struct CANMessage CANGet(void)
 *
 * PreCondition:    An unread message has to be in the buffer
 *                  use RXCANMessageIsPending(void) prior to 
 *                  calling this function in order to determine
 *                  if an unread message is pending.
 *
 * Input:           None
 *
 * Output:          The received message
 *
 * Side Effects:    Will modify the RX Buffer register´s Read pointer
 *
 * Overview:        Pops the the first message of the RX buffer
 *
 * Note:            None
 ********************************************************************/
struct CANMessage CANGet(void)
{
  struct CANMessage ReturnMessage;
  unsigned char TempPtr, i;

  /*Do not modify the RX pointer until the message has been successfully
    copied to prevent ISR to overwrite it (Note. this is not implemented in the ISR yet)*/
  if(RXRPtr >= RXBUF-1)          //Check if pointer will overflow
  {
    TempPtr = 0;
  }
  else
  {
    TempPtr = RXRPtr+1;
  }
  
  ReturnMessage.NoOfBytes = RXMessage[TempPtr].Specific.RXBDLC.Byte & 0x0F;          //copy data count
  if(RXMessage[TempPtr].Specific.RXBCON.Bits.RXRTRRO)  //Remote frame request
  {
    ReturnMessage.Remote = 1;
  }
  else        //Data frame 
  {
    ReturnMessage.Remote = 0;                  //Clear remote flag
    for(i = 0; i < ReturnMessage.NoOfBytes; i++)        //copy data content
      ReturnMessage.Data[i] = RXMessage[TempPtr].Specific.RXBD.Array[i];
  }
  CANCON = CANCON & 0xF0;
  
  ReturnMessage.Address = (unsigned int)(RXMessage[TempPtr].Specific.RXBSIDH.Byte) << 3;      //Load the standard identifier into the address
  ReturnMessage.Address |= (RXMessage[TempPtr].Specific.RXBSIDL.Byte >> 5);

  if(RXMessage[TempPtr].Specific.RXBSIDL.Bits.EXID)        //Extended identifier
  {
    ReturnMessage.Ext = 1;                    //Set the extended identifier flag
    ReturnMessage.Address = (ReturnMessage.Address << 2) | (RXMessage[TempPtr].Specific.RXBSIDL.Byte & 0x03);
    ReturnMessage.Address = ReturnMessage.Address << 16;    //and copy the extended address 
    ReturnMessage.Address |= (unsigned int)(RXMessage[TempPtr].Specific.RXBEIDH.Byte) << 8;
    ReturnMessage.Address |= RXMessage[TempPtr].Specific.RXBEIDL.Byte;    
  }
  else                //Standard identifier
  {
    ReturnMessage.Ext = 0;    //clear the extended identifier flag
  }
  
  RXRPtr = TempPtr;
  return ReturnMessage;    
}


/*********************************************************************
 * Function:        void CANSetMode(unsigned char Mode)
 *
 * PreCondition:    None
 *
 * Input:           Desired CAN Mode
 *                  (CAN_LISTEN_MODE, CAN_LOOPBACK_MODE
 *                   CAN_DISABLE_MODE, CAN_NORMAL_MODE)
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Requests to set the desired mode and waits until
 *                  the mode has been set.
 *
 * Note:            If USE_LOOPBACK_MODE is defined the requested
 *                  mode will be loopback mode if the input is
 *                  Normal mode
 ********************************************************************/
void CANSetMode(unsigned char Mode)
{
#ifdef USE_LOOPBACK_MODE
  if(Mode == NORMAL_MODE)
  {
    CANCON = (LOOPBACK_MODE & MODE_MASK) | (CANCON & (MODE_MASK ^ 0xFF));
    while((CANSTAT & MODE_MASK) != (LOOPBACK_MODE & MODE_MASK));  
  }
  else
#endif
  {
    CANCON = (Mode & MODE_MASK) | (CANCON & (MODE_MASK ^ 0xFF));
    while((CANSTAT & MODE_MASK) != (Mode & MODE_MASK));
  }

}

Vielen Dank für eure Hilfe ;)

PS: wie kann man den Code so einfügen, dass man in ihm hoch und runter 
scrollen kann, ohne dass gleich der ganze Code dargestellt wird?

[mknoelke (Gast)]

Oh schön, lese ich mal alles wenn ich einen langen harten Winter nix 
vorhab.
Bitte poste doch noch den Quellcode Deines Betriebssystems des 
Entwicklungsrechners plus aller Treiber.

CAN macht doch schon fast alles in Hardware.
Deine Lösung nennt sich - de BUG en.

Wird von erfahrenen Programmierern in dem unwahrscheinlichen Fall 
angewendet das Programme nicht nach dem ersten compilerdurchlauf 
vollständig fehlerfrei laufen.

Manuel Bali schrieb:
> Oder glaubt ihr, dass Problem liegt an was
> anderem?

Ja, zwischen Deinen Ohren.
Z.B. wahrscheinlich daran das Du zu lange Zeit alles blockierst während 
Du eine Nachricht auswertest.
Höchstwahrscheinlich durch zu langer Verweildauer in der IRQ.

[Manuel B. (desteini)]

Ok sehr nette Antwort.

Wobei ich das mit dem Hardware-Filter tatsächlich falsch verstanden 
habe. Mein Fehler!

Im Receive Interrupt wird zuerst der ID gecheckt, falls es der Falsche 
ist, wird garnichts gemacht. Nur bei richtigem ID macht er überhaupt 
etwas. Aber dann hätte er die Nachricht ja schon empfangen -> Sprich 
daran kann es wohl nicht liegen.

Und in wie fern hilft mir der Debug Mode, wenn es nur auftritt, wenn ich 
ne Hohe Buslast hab, und verspätet. Wenn ich da von Hand durch debugge, 
ist es klar, dass er zu langsam ist.

Trotzdem Danke für die Antwort, eventuell könntest du das nächstemal auf 
deine Beleididungen verzichten ;)

[mknoelke (Gast)]

Sei nicht so empfindlich, ich habe Dich nicht beleidigt.
Das der Fehler meist zwischen den Ohren zu finden ist, ist keine 
Beleidigung sondern eine anerkannte Tatsache und eine geflügelter Spruch 
unter Entwicklern.

Du kommst schon ziemlich schräg rüber wenn Du damit anfängst 
(Kurzfassung) das Du alles richtig gemacht hast, der Chip oder die LIB 
es aber einfach nicht bringen und jetzt wohl alles neu geschrieben 
werden muß.

Debuggen heißt im ursprünglichen Wortsinn den Bug, den Fehler, das 
Fehlverhalten zu identifizieren und zu entfernen.
Das hat überhaupt nix mit von Hand im Einzelschritt durchpimpern zu tun.

Meine Empfehlung wäre mal im Detail zu schauen (per pin debuging + oszi) 
welchen zeitlichen Verlauf dein Code hat und warum der Nachrichten 
verpasst.
Irgendwas in Deinem Code oder der LIB braucht zu viel Zeit und blockiert 
da was.
Herauszufinden was das ist Deine Aufgabe.
Dazu wirst Du wohl tiefer in die LIB und/oder die CAN Hardware 
einsteigen müssen.

Der PIC18F258 hat im CAN Teil umfangreiche Möglichkeiten HW RX Message 
Filter und Priorities einzurichten und Fehlerzustände abzufragen.
Wenn eine Nachricht verloren geht dann bekommt der das mit und sagt Dir 
auch was wenn Du ihm zuhörst. Geht z.B. perfekt indem Du die Chip 
Register über den Debugger anschaust.
Fehlerbit in IRQ auswerten und Breakpoint auf die Bedingung legen 
behindert nicht die normale Ausführung.

Beherrschung der Werkzeuge + Datenblatt lesen statt nur LIB einbinden 
würde ein unhöflicher Mensch jetzt sagen.
Ich natürlich nicht.

[Manuel B. (desteini)]

Alles klar, dann haben wir uns wohl auf dem falschen Fuß erwischt.

Ich bin Neuling in Mikrokontroller und vorallem CAN. Ich hatte es ein 
Semester an der Uni und das mit einem anderen Mikrochip. Deshalb sorry 
wenn es falsch rüber kam, ich meinte nich, dass es nicht meine Schuld 
war.

Meine Ansicht war nur: Wenn alles mit einer geringen Buslast 
funktioniert, und alle Daten auf dem Mikrochip ankommen, ist es ein 
Problem des Controllers. (stimmt wohl auch soweit). Eine mögliche Lösung 
wäre dann wohl ein Filter, jedoch funktioniert dieser nicht wie er 
sollte.

Allerdings hab ich wirklich nicht in Betracht bezogen, dass es ein 
Problem des Codes und nicht der Settings ist. Danke dafür! Ich hab auch 
schon einen Verdacht woran es liegen kann, falls ich es morgen Testen 
kann, werde ich berichten.

Also danke mknoelke ;)

[Peter D. (peda)]

Dein Codemonster wird so keiner lesen.

Wozu meinst Du, ist der Salm über dem Eingabefenster gedacht?
Natürlich zum Ignorieren.


Antwort schreiben
Wichtige Regeln - erst lesen, dann posten!

    Groß- und Kleinschreibung verwenden
    Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

[mknoelke (Gast)]

Manuel Bali schrieb:
> Alles klar, dann haben wir uns wohl auf dem falschen Fuß erwischt.

Hart aber herzlich.

Glück auf...

[Manuel B. (desteini)]

@Peter Danegger: Hab ich gelesen, hab aber in einem anderen Thread 
gesehen, dass der Code quasi eingefügt wurde, aber als "Scroll-Window". 
Ich dachte, dass ich das so auch machen könnte. Und dachte, dass wenn 
ich sie hinzufüge als Datei, dass man sie nur downloaden könnte und Sie 
deshalb keiner lesen würde.

Deshalb auch die Frage: Wie man den Code in das "Scroll-Window" 
verfrachten könnte...

[Manuel B. (desteini)]

So gerade ausprobiert und jetzt scheint es tatsächlich zu funktionieren. 
Das Problem war, dass beim Empfang der Nachricht zwar der Interrupt 
ausgelöst wurde und die Nachricht in den Buffer gespeichert wurde, ich 
den Buffer aber nur in der Main() ausgelesen habe. Zudem war in der Main 
noch ne 100ms Schleife(Weil ich keinen Timer mehr frei hatte), die damit 
quasi das auslesen des Buffers blockierte.

Die Lösung: Einfach das auslesen des Buffers mit in den Interrupt hauen, 
und alles scheint zu funktionieren.

Also vielen Dank nochmal mknoelke!

[Peter D. (peda)]

Manuel Bali schrieb:
> Zudem war in der Main
> noch ne 100ms Schleife(Weil ich keinen Timer mehr frei hatte), die damit
> quasi das auslesen des Buffers blockierte.

Das ist natürlich ein dicker Hund, dafür wirst Du ewig in der 
Programmiererhölle schmoren.

Manuel Bali schrieb:
> Die Lösung: Einfach das auslesen des Buffers mit in den Interrupt hauen,
> und alles scheint zu funktionieren.

Das ist nur ein Würg-Around.
Die saubere Lösung wäre es, den Zeitverschwender aus der Main zu nehmen.

[Manuel B. (desteini)]

Haste Recht! Grad nochmal umgeschrieben, läuft jetzt auch über einen 
Interrupt Timer... Hätt ich echt auch früher machen können. Naja Ende 
jut alles jut ;)

[mknoelke (Gast)]

Na siehst Du, geht doch ;-)

Diese Art von Delay Schleifen werden zwar häufig verwendet sind aber 
wirklich dreckig. 10% der Rechenpower einfach so im Gulli.

Bau Dir einen 1ms system timer und mach z.B sowas in der IRQ
--t_100ms;
if (!t_100ms) {t_100ms = 100; flag_100ms = 1;}

Das Flag wertest Du in der main aus und setzt das nach Bearbeitung 
zurück.
So brauchst Du nur einen Hardwaretimer für beliebig viele Zeiten.

[Manuel B. (desteini)]

Genau so hab ichs jetzt auch umgesetzt. Zwar mit nem 100ms Timer, aber 
das passt für meine Zwecke.

Aber echt guter Tipp mit dem 1ms Timer. Werd ich ab jetzt wohl immer 
verwenden. Dann spart man sich auch noch nen 2. Timer zu setzen und die 
Sache bliebt übersichtlicher =)

learning by doing...

Danke!

[Manuel B. (desteini)]

So hier nochmal die Ergänzung zum Filter Problem, dass ich nun endlich 
gelöst habe. Scheinbar mag der PIC18F258 es nicht, wenn man die Filter 
direkt mit dem initialisieren des CAN-Moduls setzt. Also muss man nach 
dem Initialisieren nochmal in den Configurationsmodus und die Filter 
setzen. Dann zurück in den OP Modus und alles sollte funktionieren.

Zudem musste ich beide Masken benutzen, damit der Filter0 wirklich 
funktionierte. Hier mein Codeausschnitt

CANCON = (0x9F & 0xE0) | (CANCON & 0x3F);  //Set configuration mode
  while((CANSTAT & 0xE0) != (0x9F & 0xE0));  //Wait until config mode is set

        RXB0CON =  0b00100000; // Buffer Overload Off, use Filter 0, only std messages
        RXF0SIDH = 0b00100000; // SetHighbyte for Filter0   ID=0x104
        RXF0SIDL = 0b10000000; //SetLowbyte and activate STD Message

        RXM0SIDH = 0b11111111; // SetHighbyte Mask0
        RXM0SIDL = 0b11100000; //Set Lowbyte Mask0     0xFFF

        RXM1SIDH = 0b11111111; // SetHighbyte Mask1    0xFFF
        RXM1SIDL = 0b11100000; //Set Lowbyte Mask1
        
        CANCON = (0x1F & 0xE0) | (CANCON & (0xE0 ^ 0xFF)); //Set Normal mode
    while((CANSTAT & 0xE0) != (0x1F & 0xE0));  // Wait until Normal mode is set

Eventuell hilfts ja jemandem ;)