Yeah, I can see where my post was confusing. Let me clarify a few things.
That Microchip code doesn't make any sense at all in this context. I see a lot of USB references but nothing about the MSSP module or the MCP2515.I attached the main code but I meant to attach another sheet.
/** D E C L A R A T I O N S **************************************************/
#define Mode00 0
#define Mode11 1
#define ON 1
#define OFF 0
#define HIGH 1
#define LOW 0
//#pragma code
//-----------------------------------------------------------------------------
// SPIReset()
//-----------------------------------------------------------------------------
void SPIReset(void)
{
CS_2515_LOW();
WriteSPI(CAN_RESET);
CS_2515_HIGH();
for(dummy=0; dummy<255; dummy++);
}
//-------------------------------------------------------------------------
// SPIByteWrite()
//-------------------------------------------------------------------------
void SPIByteWrite(unsigned char addr, unsigned char value )
{
CS_2515_LOW();
while(WriteSPI(CAN_WRITE));
while(WriteSPI(addr));
while(WriteSPI(value));
CS_2515_HIGH();
}
//-------------------------------------------------------------------------
// Function Name: SPISegWrite
// Return Value: None
// Parameters: Starting address, numbytes, and pointer
// to an array.
// Description: This routine performs a sequential write.
//-------------------------------------------------------------------------
void SPISeqWrite(unsigned char startaddr, unsigned char numbytes, char *data)
{
unsigned char n;
CS_2515_LOW();
while( WriteSPI(CAN_WRITE) );
while( WriteSPI(startaddr) );
for(n=0; n<numbytes; n++)
while( WriteSPI(data[n]) );
CS_2515_HIGH();
}
//-----------------------------------------------------------------------------
// SPIByteRead()
//-----------------------------------------------------------------------------
unsigned char SPIByteRead(unsigned char addr)
{
unsigned char tempdata;
CS_2515_LOW();
WriteSPI(CAN_READ);
WriteSPI(addr);
tempdata = ReadSPI();
CS_2515_HIGH();
return tempdata;
}
//-----------------------------------------------------------------------------
// SPISeqRead(unsigned char startaddr, unsigned char numbytes, *data)
// Return Value: None (puts read data in string)
// Parameters: Starting address, numbytes, and pointer
// to an array.
// Description: Sequential read from the MCP2515
//-----------------------------------------------------------------------------
void SPISeqRead(unsigned char startaddr, unsigned char numbytes, char *data)
{
unsigned char n;
CS_2515_LOW();
while( WriteSPI(CAN_READ) );
while( WriteSPI(startaddr) );
for(n=0; n<numbytes; n++)
{
data[n] = ReadSPI();
}
data[n] = ReadSPI(); //Last byte
CS_2515_HIGH();
}
//-----------------------------------------------------------------------------
// SPIReadRX(unsigned char opcode, unsigned char numbytes, unsigned char *data)
// opcode = SPI opcode and pointer to RXBn register location// (see datasheet)
// numbytes = number of bytes to read
// *data = pointer to a string of data
//
//-----------------------------------------------------------------------------
void SPIReadRX(unsigned char opcode, unsigned char numbytes, char *data)
{
unsigned char n;
CS_2515_LOW();
while( WriteSPI(opcode));
for(n=0; n<numbytes; n++)
{
data[n] = ReadSPI();
}
data[n] = ReadSPI(); //Last byte
CS_2515_HIGH();
}
//-----------------------------------------------------------------------------
// SPILoadTX(unsigned char opcode, unsigned char numbytes, unsigned char *data)
// opcode = SPI opcode and pointer to TXBn register location// (see datasheet)
// numbytes = number of bytes to write
// *data = pointer to a string of data
//
//-----------------------------------------------------------------------------
char SPILoadTX(unsigned char opcode, unsigned char numbytes, char *data)
{
unsigned char n, buff;
//Check if this function is suppossed to choose the TX buffer to load
if(opcode == CAN_LOAD_TX)//This function chooses the buffer
{
n = SPIReadStatus();
//Check for free buffer
if(!(n & 0x04)) //TXB0 is available
opcode = CAN_LD_TXB0_ID; //Point to TXB0SIDH
else if(!(n & 0x10)) //TXB1 is available
opcode = CAN_LD_TXB1_ID; //Point to TXB1SIDH
else if(!(n & 0x40)) //TXB2 is available
opcode = CAN_LD_TXB2_ID; //Point to TXB2SIDH
else if(n & 0x54) //No buffers available
{
SPIByteWrite(TXB0CTRL, 0x00); //Clear TXREQ (and whole register)
for(dummy=0; dummy<255; dummy++);
opcode = CAN_LD_TXB0_ID; //Point to TXB0SIDH
}
}
CS_2515_LOW();
while( WriteSPI(opcode) );
for(n=0; n<numbytes; n++)
while( WriteSPI(data[n]) );
CS_2515_HIGH();
return(opcode); //So calling function knows which buffer was loaded
}
//-----------------------------------------------------------------------------
// RTS(buffer)
// buffer = CAN_RTS_TXBn; where 'n' = 0, 1, 2
// OR
// buffer = CAN_RTS; followed by | 0 - 7 (e.g., "CAN_RTS | 7" sends TX0 and TX1)
// OR
// buffer = CAN_RTS_TXBn | CAN_RTS_TXBn | CAN_RTS_TXBn; where 'n' = 0, 1, 2
//-----------------------------------------------------------------------------
void SPI_RTS(unsigned char buffer)
{
unsigned char tempdata;
tempdata = SPIReadStatus();
if(buffer & 0x01) //Buffer 0
if(tempdata & 0x04) //Check TXREQ first
{
Delay_ms(1);
SPIByteWrite(TXB0CTRL, 0); //Clear TXREQ (and everything else... not clean)
while(SPIReadStatus() & 0x04); //Wait for TXREQ to clear
}
if(buffer & 0x02) //Buffer 1
if(tempdata & 0x10) //Check TXREQ first
{
Delay_ms(1);
SPIByteWrite(TXB1CTRL, 0); //Clear TXREQ (and everything else... not clean)
while(SPIReadStatus() & 0x10); //Wait for TXREQ to clear
}
if(buffer & 0x04) //Buffer 2
if(tempdata & 0x40) //Check TXREQ first
{
Delay_ms(1);
SPIByteWrite(TXB2CTRL, 0); //Clear TXREQ (and everything else... not clean)
while(SPIReadStatus() & 0x40); //Wait for TXREQ to clear
}
CS_2515_LOW();
WriteSPI(buffer);
CS_2515_HIGH();
}
//-----------------------------------------------------------------------------
// char SPIReadStatus//(void)
// Performs Read Status command and returns result
//-----------------------------------------------------------------------------
char SPIReadStatus(void)
{
unsigned char tempdata;
CS_2515_LOW();
WriteSPI(CAN_RD_STATUS);
tempdata = ReadSPI();
CS_2515_HIGH();
return tempdata;
}
//-----------------------------------------------------------------------------
// Delay_ms()
// Tcy = 1 us
// Tcy X 1000 = 1 ms
// FFFFh - 3E8h (1000d) = FC17h
// For(){} loop is in 1 ms increments
//-----------------------------------------------------------------------------
void Delay_ms(unsigned char num_ms)
{
unsigned char n;
TMR1H = 0xFC;
TMR1L = 0x17;
T1CONbits.TMR1ON = 1; //Start timer
for(n = 0; n < num_ms; n++)
{
while(!PIR1bits.TMR1IF); //Wait for timer flag
PIR1bits.TMR1IF = 0; //Clear flag
TMR1H = 0xFC;
TMR1L = 0x17;
}
T1CONbits.TMR1ON = 0; //Stop timer
}
/** P R I V A T E P R O T O T Y P E S ***************************************/
void CheckLoadButton(void);
unsigned char ReadSPI( void );
void SetBitTiming(char data_rate);
void CANLoadTX(void);
/** D E C L A R A T I O N S **************************************************/
#define CAN_1000kbps 0 //BRP setting in CNF1
#define CAN_500kbps 1 //
#define CAN_250kbps 3 //
#define CAN_125kbps 7 //
/** S T R U C T S ************************************************** ******/
struct {
unsigned char INTF:1; //bit 0
unsigned char MCP_RXBn:2;
unsigned char SOF:1;
unsigned char USBsend:1;
unsigned char USBQueue:1;
unsigned char CANLoading:1;
unsigned char Flag8:1;
} UserFlag;
struct {
unsigned char BusLoad:2; //bit 0
unsigned char TX_buff:2; //OUT message to instruct TX buff to send
unsigned char CAN_USB_PTR:2;
unsigned char nu2:1;
unsigned char nu3:1;
} usbcan_STATUS;
/** V A R I A B L E S ************************************************** ******/
#pragma udata
//byte old_sw2,old_sw3;
BOOL emulate_mode;
rom signed char dir_table[]={-4,-4,-4, 0, 4, 4, 4, 0};
byte movement_length;
byte vector = 0;
byte AquireData = 1; //0 = STOP; 1 = Aquire (Not Used)
char buffer[3];
char inbuffer[BUF_SIZE]; // 64 byte input to USB device buffer
char outbuffer[BUF_SIZE]; // 64 byte output to USB device buffer
byte TimerCounter = 0xF0;
static unsigned char gTimeout = 0;
unsigned int CANLoadTimer = 0x00;
unsigned int LoadPrescaler = 0x8000;
static byte LOAD_FLAG = PERCENT_0;
static char USB_ptr = 0xFF; //Points to the USB location of the start of the
//four possible CAN messages
static char old_CANCTRL; //Used to track CANCTRL changes from host
char DataArray[32];
char ReadArray[32];
#pragma code
/************************************************** ****************************
* Function: void ProcessIO
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function is a place holder for other user routines.
* It is a mixture of both USB and non-USB tasks.
*
* Note: None
************************************************** ***************************/
void ProcessIO(void)
{
unsigned char n, b, c, y;
int a;
// User Application USB tasks
if(!(usb_power_check)) //Only generate traffic if NOT connected to USB
{
CheckLoadButton();
CANLoadTX();
}
if((usb_device_state < CONFIGURED_STATE)||(UCONbits.SUSPND==1)) return;
//----- Read USB buffer if it has data from the host -----
if (HIDRxReport(inbuffer, 64)) // USB receive buffer has data
{
LED_RX_ON(); //Turn LED on
T0CONbits.TMR0ON = 1; //Start timer for TX LED on time
gTimeout = 0; //Reset timout
//---- CANmsgs: Check if host has requested CAN messages to be transmited
switch(inbuffer[u_CANmsgs]) // interpret command
{
case 0x00: // No messages are available
break;
case 0x01: // Message 1 is available
GetUSBData(m1_SIDH, 13, DataArray);
n = SPILoadTX(CAN_LOAD_TX, 13, DataArray);
if(n == CAN_LD_TXB0_ID) //if TX0 is loaded
{
RTS0_2515_LOW();
RTS0_2515_HIGH();
}
else if(n == CAN_LD_TXB1_ID) //if TX1 is loaded
{
RTS1_2515_LOW();
RTS1_2515_HIGH();
}
else if(n == CAN_LD_TXB2_ID) //if TX2 is loaded
{
RTS2_2515_LOW();
RTS2_2515_HIGH();
}
break;
case 0x02: // Message 1 and 2 are available
//Message 1
GetUSBData(m1_SIDH, m1_DLC + 5, DataArray);
n = SPILoadTX(CAN_LOAD_TX, m1_DLC + 5, DataArray);
if(n == CAN_LD_TXB0_ID) //if TX0 is loaded
{
RTS0_2515_LOW();
RTS0_2515_HIGH();
}
else if(n == CAN_LD_TXB1_ID) //if TX1 is loaded
{
RTS1_2515_LOW();
RTS1_2515_HIGH();
}
else if(n == CAN_LD_TXB2_ID) //if TX2 is loaded
{
RTS2_2515_LOW();
RTS2_2515_HIGH();
}
//Message 2
GetUSBData(m2_SIDH, m2_DLC + 5, DataArray);
n = SPILoadTX(CAN_LOAD_TX, m2_DLC + 5, DataArray);
if(n == CAN_LD_TXB0_ID) //if TX0 is loaded
{
RTS0_2515_LOW();
RTS0_2515_HIGH();
}
else if(n == CAN_LD_TXB1_ID) //if TX1 is loaded
{
RTS1_2515_LOW();
RTS1_2515_HIGH();
}
else if(n == CAN_LD_TXB2_ID) //if TX2 is loaded
{
RTS2_2515_LOW();
RTS2_2515_HIGH();
}
break;
case 0x03: // Message 1, 2, and 3 are available
//Message 1
GetUSBData(m1_SIDH, m1_DLC + 5, DataArray);
n = SPILoadTX(CAN_LOAD_TX, m1_DLC + 5, DataArray);
if(n == CAN_LD_TXB0_ID) //if TX0 is loaded
{
RTS0_2515_LOW();
RTS0_2515_HIGH();
}
else if(n == CAN_LD_TXB1_ID) //if TX1 is loaded
{
RTS1_2515_LOW();
RTS1_2515_HIGH();
}
else if(n == CAN_LD_TXB2_ID) //if TX2 is loaded
{
RTS2_2515_LOW();
RTS2_2515_HIGH();
}
//Message 2
GetUSBData(m2_SIDH, m2_DLC + 5, DataArray);
n = SPILoadTX(CAN_LOAD_TX, m2_DLC + 5, DataArray);
if(n == CAN_LD_TXB0_ID) //if TX0 is loaded
{
RTS0_2515_LOW();
RTS0_2515_HIGH();
}
else if(n == CAN_LD_TXB1_ID) //if TX1 is loaded
{
RTS1_2515_LOW();
RTS1_2515_HIGH();
}
else if(n == CAN_LD_TXB2_ID) //if TX2 is loaded
{
RTS2_2515_LOW();
RTS2_2515_HIGH();
}
//Message 3
GetUSBData(m3_SIDH, m3_DLC + 5, DataArray);
n = SPILoadTX(CAN_LOAD_TX, m3_DLC + 5, DataArray);
if(n == CAN_LD_TXB0_ID) //if TX0 is loaded
{
RTS0_2515_LOW();
RTS0_2515_HIGH();
}
else if(n == CAN_LD_TXB1_ID) //if TX1 is loaded
{
RTS1_2515_LOW();
RTS1_2515_HIGH();
}
else if(n == CAN_LD_TXB2_ID) //if TX2 is loaded
{
RTS2_2515_LOW();
RTS2_2515_HIGH();
}
break;
case 0x04: //--FUTURE-- Message 1, 2, 3, and 4 are available
break;
default: // unrecognized or null command
;
}// END switch: inbuffer[u_CANmsgs]
//---- CANCTRL: Write to the CANCTRL register if changed
if(inbuffer[u_CANCTRL] != old_CANCTRL) //If host sent new CANCTRL value
{
SPIByteWrite(CANCTRL,inbuffer[u_CANCTRL]); //Write to CANCTRL
EEPROMBYTEWrite(CANCTRL,inbuffer[u_CANCTRL]);
EEPROMCRCWrite(0,128);
old_CANCTRL = inbuffer[u_CANCTRL]; //
outbuffer[u_CANSTAT] = SPIByteRead(CANSTAT);
while((outbuffer[u_CANSTAT] & 0xE0) != (inbuffer[u_CANCTRL] & 0xE0))//if didn't change modes yet
{
outbuffer[u_CANSTAT] = SPIByteRead(CANSTAT);
}
UserFlag.USBsend = 1; //Set flag so will send USB message
}
//---- SPI: SPI command from host
if(inbuffer[u_SPI]) //If host sent SPI command (non-zero)
{
switch(inbuffer[u_SPI])
{
case CAN_RESET: //
SPIReset();
break;
case CAN_READ: //
if(!UserFlag.USBQueue) // If previous message is queued
{
outbuffer[u_SPI] = CAN_READ; //Send back to host
outbuffer[u_REG] = inbuffer[u_REG]; //Send back to host
outbuffer[u_DATA] = SPIByteRead(inbuffer[u_REG]); //Send back to host
}
UserFlag.USBsend = 1; //Set flag so will send USB message
UserFlag.USBQueue = 1; //Indicates msg is queued, but not sent
break;
case CAN_WRITE: //
//outbuffer[u_SPI] = 0; //Send back to host //JM
SPIByteWrite(inbuffer[u_REG],inbuffer[u_DATA]);
EEPROMBYTEWrite(inbuffer[u_REG],inbuffer[u_DATA]);
EEPROMCRCWrite(0,128);
break;
case CAN_RTS: //
SPI_RTS(inbuffer[u_DATA]);
break;
case CAN_RD_STATUS: //
outbuffer[u_DATA] = SPIReadStatus();
UserFlag.USBsend = 1; //Set flag so will send USB message
break;
default: // unrecognized or null command
;
}// END switch: inbuffer[u_SPI]
}
}//END if (HIDRxReport(inbuffer, 1)
//---- Check RXnBF pins and service messages as needed ---
switch(CheckCANRX()) // Check if CAN message received
{
case 0x01: // Message in RXB0 (Msgs in this buffer are Standard)
SPIReadRX(CAN_RD_START_RXB0SIDH, 13, ReadArray);
LoadUSBString(ReadArray);
break;
case 0x02: // Message in RXB1 (Msgs in this buffer are Extended)
SPIReadRX(CAN_RD_START_RXB1SIDH, 13, ReadArray);
LoadUSBString(ReadArray);
break;
case 0x03: // Message in RXB0 and RXB1
SPIReadRX(CAN_RD_START_RXB0SIDH, 13, ReadArray);
LoadUSBString(ReadArray);
SPIReadRX(CAN_RD_START_RXB1SIDH, 13, ReadArray);
LoadUSBString(ReadArray);
break;
default: // unrecognized or null command
;
}// END switch: CheckCANRX()
//---- The following turns off the TX and RX USB indicator LEDs after some time
//Inst. cycle = 200 ns; TMR0IF sets every 51 us
if(INTCONbits.TMR0IF)
{
TimerCounter++;
if (!TimerCounter) //if rolled over, set flag. User code will handle the rest.
{
LED_TX_OFF(); //Turn LED off
LED_RX_OFF(); //Turn LED off
T0CONbits.TMR0ON = 0; //Start timer for TX LED on time
TimerCounter = 0xFE;
gTimeout = 1; //Reset timout
}
INTCONbits.TMR0IF = 0;
}
//------ Load USB Data to be transmitted to the host --------
if(UserFlag.MCP_RXBn | UserFlag.USBsend)
{
if(!mHIDTxIsBusy())
{
HIDTxReport(outbuffer, 64);
outbuffer[0] = 0x00; //PKR$$$ Need this??
UserFlag.MCP_RXBn = 0; //clear flag
UserFlag.USBsend = 0; //clear flag
UserFlag.USBQueue = 0; //Clear message queue
LED_TX_ON(); //Turn LED on
T0CONbits.TMR0ON = 1; //Start timer for TX LED on time
gTimeout = 0; //Reset timout
outbuffer[u_SPI] = 0x00; //clear back to 00h so host doesn't detect "SPI response"
USB_ptr = 0xFF; //Point to location 0xFF
outbuffer[u_CANmsgs] = 0x00; //Clear message status
}
}
}//end ProcessIO
/************************************************** ****************************
* Function: char CheckCANRX(void)
*
* PreCondition: None
*
* Input: None
*
* Output: Which RX buffer have message
* 0 = None; 1 = RXB0; 2 = RXB1; 3 = Both buffers
*
* Side Effects: None
*
* Overview:
*
* Note:
************************************************** ***************************/
char CheckCANRX(void)
{
//First, set the correct flag. ORs with flag because this might not be the
//1st time through
UserFlag.MCP_RXBn = 0;
if(!RXB0_2515) UserFlag.MCP_RXBn = UserFlag.MCP_RXBn | 0x01; //RXB0 is active low
if(!RXB1_2515) UserFlag.MCP_RXBn = UserFlag.MCP_RXBn | 0x02; //RXB1 is active low
return UserFlag.MCP_RXBn;
}
/************************************************** ****************************
* Function: void LoadUSBString//(char *data)
*
* PreCondition: Set the pointer to the USB array "USB_ptr"
*
* Input: Pointer to array that contains the data to write to USB
*
* Output: None
*
* Side Effects: None
*
* Overview: Loads data read from the MCP2515 RX buffer. Note, the
* function already knows the *data is 13 bytes
*
* Note:
************************************************** ***************************/
void LoadUSBString(char *data)
{
unsigned char n, rtr, ide, dlc, num_bytes, CAN_ptr;
CAN_ptr = 0;
if(USB_ptr == 0xFF) //If 0xFF, then this is the 1st time through
USB_ptr = 0;
//-----Calculate how big the CAN msg is... how many USB bytes to use---
if(data[mx_SIDL] & 0x08){ //If extended ID
ide = 0x20; //Maps to 'INFO' byte in USB
num_bytes = 0x04; ` //All four ID registers (extended ID)
}
else{
ide = 0x00; //Maps to 'INFO' byte in USB
num_bytes = 0x02; //Just the standard ID registers
}
if(ide) //If extended ID, then RTR is in DLC; else in SIDL
{
if(data[mx_DLC] & 0x40){ //RTR bit in DLC
rtr = 0x10; //Maps to 'INFO' byte in USB
}
else{
rtr = 0x00; //Maps to 'INFO' byte in USB
}
}
else
{
if(data[mx_SIDL] & 0x10){ //RTR bit in SIDL
rtr = 0x10; //Maps to 'INFO' byte in USB
}
else{
rtr = 0x00; //Maps to 'INFO' byte in USB
}
}
dlc = data[mx_DLC] & 0x0F; //Determine the data length code
//END--Calculate how big the CAN msg is... how many USB bytes to use---END
//Calculate if there is enough room to add the CAN message to USB:
//52 is the location of the 1st control message. Subract the pointer location
//If this is larger than the current CAN message (includes the "INFO" byte)
//then can load 'outbuffer[]'. Otherwise, will need to switch interfaces
//(assuming currently on the 1st interface).
//If enough room, add the bytes
if(52 - USB_ptr > num_bytes)
{
//Now load the 'INFO' byte
outbuffer[USB_ptr] = 0x80 + ide + rtr + dlc;
USB_ptr++;
//Load the identifier registers
for(n=0; n<num_bytes; n++)
{
outbuffer[USB_ptr] = data[CAN_ptr];
USB_ptr++;
CAN_ptr++;
}
if(!ide) CAN_ptr = CAN_ptr + 2; //skip over EXIDE regs
CAN_ptr++; //skip over the DLC register
if(!rtr) //if a data frame
{
//Load the data registers
for(n=0; n<dlc; n++) //
{
outbuffer[USB_ptr] = data[CAN_ptr];
USB_ptr++;
CAN_ptr++;
}
}
//Now clear next byte (STATUS). Cleared to 0 in case this is the last time through.
//PC looks at MSb and, if clear, no message follows
outbuffer[USB_ptr] = 0x00;
//Next, need to load the other status bytes from byte 53 - 59
//[CANINTF, EFLG, TEC, REC, CANSTAT, CANCTRL]
//Need to read TEC, REC, and CANSTAT to report to host
SPISeqRead(TEC, 3, ReadArray);
outbuffer[u_TEC] = ReadArray[0];
outbuffer[u_REC] = ReadArray[1];
outbuffer[u_CANSTAT] = ReadArray[2];
}
}
/************************************************** ****************************
* Function: void GetUSBData//(char start_ptr, char num_bytes, char *data)
*
* PreCondition: None
*
* Input: Pointer to location in USB string
* Number of bytes to get
* Pointer to array that contains the data to write to USB
*
* Output: None
*
* Side Effects: None
*
* Overview: Gets data from the USB string.
*
* Note:
************************************************** ***************************/
void GetUSBData(char start_ptr, char num_bytes, char *data)
{
unsigned char n;
for(n=start_ptr; n<start_ptr+num_bytes; n++)
data[n - start_ptr] = inbuffer[n];
}
/************************************************** ****************************
* Function: void UserInit
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function initializes the PIC.
*
*
* Note: None
************************************************** ***************************/
void UserInit(void)
{
byte i;
CS_2515_HIGH(); //Drive high
tris_CS = 0; //Output
OpenSPI(SPI_FOSC_16, MODE_00, SMPMID);
TRISBbits.TRISB0 = 1; //SDI
TRISBbits.TRISB1 = 0; //SCK
//-------------------------
// initialize variables
//-------------------------
for (i=0; i<BUF_SIZE; i++) // initialize input and output buffer to 0
{
inbuffer[i]=0;
outbuffer[i]=0;
}
//Timer 0
TMR0H = 0; //clear timer
TMR0L = 0; //clear timer
T0CONbits.PSA = 0; //Assign prescaler to Timer 0
T0CONbits.T0PS2 = 1; //Setup prescaler
T0CONbits.T0PS1 = 1; //Will time out every 51 us based on
T0CONbits.T0PS0 = 1; //20 MHz Fosc
T0CONbits.T0CS = 0; //Increment on instuction cycle
INTCON2 = 0xFF; //INT2 on rising edge
INTCON3bits.INT2IP = 0; //Low priority
INTCON3bits.INT2IF = 0; //Clear flag
INTCON3bits.INT2IE = 1; //Enable INT2 interrupt
//Outputs for the LEDs
ADCON1 = 0x0F; //Digital pins
CMCON = 0x07; //Digital pins
LED_25PCT_OFF();
LED_50PCT_OFF();
LED_75PCT_OFF();
LED_100PCT_OFF();
tris_LED_25PCT = OUTPUT_PIN;
tris_LED_50PCT = OUTPUT_PIN;
tris_LED_75PCT = OUTPUT_PIN;
tris_LED_100PCT = OUTPUT_PIN;
UserFlag.CANLoading = OFF;
LED_RX_OFF();
LED_TX_OFF();
tris_LED_TX = OUTPUT_PIN;
tris_LED_RX = OUTPUT_PIN;
tris_SW_LOAD = INPUT_PIN;
//RTS Pin Outputs
RTS0_2515_HIGH();
tris_RTS0_pin = OUTPUT_PIN;
RTS1_2515_HIGH();
tris_RTS1_pin = OUTPUT_PIN;
RTS2_2515_HIGH();
tris_RTS2_pin = OUTPUT_PIN;
tris_CAN_RES = OUTPUT_PIN;
CAN_RES_ON(); //JM
// CAN_RES_OFF(); //Disconnect the termination resistor by default
UserFlag.MCP_RXBn = 0; //clear flag
UserFlag.USBsend = 0; //clear flag
UserFlag.USBQueue = 0; //Clear message queue
//Need to set up MCP2515 before enabling interrupts
CANInit(); // See BusMon.c & .h
RCONbits.IPEN = 1;
INTCONbits.PEIE = 1;
INTCONbits.GIE = 1;
}//end UserInit
/************************************************** ****************************
* Function: void CANInit//(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function initializes the MCP2515.
*
*
* Note: None
************************************************** ***************************/
void CANInit()
{
unsigned char n,EEPROM_ver;
SPIReset(); //Wait state is in SPIReset() function
EEPROM_ver=EEPROMCRCCheck(0,128);
EEPROM_ver=0;
for(n=0; n<250; n++); //Wait anyway
//Set Config Mode and verify
//CANCTRL Register
/*
if(EEPROM_ver)
{
CANCTRL_byte=EEPROMBYTERead(CANCTRL);
}
else
{
EEPROMBYTEWrite(CANCTRL,CANCTRL_byte);
}
*/
SET_CONFIG; //Set Configuration mode
CLEAR_OSM; //Not One-Shot-Mode
CLEAR_ABORT; //Clear ABAT bit
CLKOUT_ENABLED; //Enabled CLKOUT pin (will configure as SOF pin in CNF3)
//EEPROMBYTEWrite(CANCTRL,CANCTRL_byte);
SPIByteWrite(CANCTRL,CANCTRL_byte); //Write to CANCTRL
//Verify Mode change
if ((SPIByteRead(CANSTAT)& 0xE0) != OPMODE_CONFIG)
SPIByteWrite(CANCTRL,CANCTRL_byte); //Try again
if(usb_power_check) //Only if connected to USB. Traffic gen board doesn't process RX msgs
{
//Configure INTERRUPTS
/*
if(EEPROM_ver)
{
CANINTE_byte=EEPROMBYTERead(CANINTE);
}
else
{
EEPROMBYTEWrite(CANINTE,CANINTE_byte);
}
*/
G_RXB_INT_ENABLED;
G_TXB_INT_ENABLED;
//EEPROMBYTEWrite(CANINTE,CANINTE_byte);
SPIByteWrite(CANINTE, CANINTE_byte);
}
//Use RXnBF pins as interrupts on RX //(BFPCTRL register)
RXB0BF_PIN_INT;
RXB1BF_PIN_INT;
SPIByteWrite(BFPCTRL, BFPCTRL_byte);
//Configure TXnRTS pins as RTS pins
TXRTSCTRL_byte = 0x07;
SPIByteWrite(TXRTSCTRL, TXRTSCTRL_byte);
//Configure MASKS
DataArray[0] = 0x00;
DataArray[1] = 0x00;
DataArray[2] = 0x00;
DataArray[3] = 0x00;
/*
if(EEPROM_ver)
{
DataArray[0]=EEPROMBYTERead(RXM0SIDH);
DataArray[1]=EEPROMBYTERead(RXM0SIDL);
DataArray[2]=EEPROMBYTERead(RXM0EID8);
DataArray[3]=EEPROMBYTERead(RXM0EID0);
}
else
{
EEPROMDataWrite(RXM0SIDH,&DataArray[0],4);
}
*/
SPISeqWrite(RXM0SIDH, 4, DataArray); //RX Mask 0
DataArray[0] = 0x00;
DataArray[1] = 0x00;
DataArray[2] = 0x00;
DataArray[3] = 0x00;
/*
if(EEPROM_ver)
{
DataArray[0]=EEPROMBYTERead(RXM1SIDH);
DataArray[1]=EEPROMBYTERead(RXM1SIDL);
DataArray[2]=EEPROMBYTERead(RXM1EID8);
DataArray[3]=EEPROMBYTERead(RXM1EID0);
}
else
{
EEPROMDataWrite(RXM1SIDH,&DataArray[0],4);
}
*/
SPISeqWrite(RXM1SIDH, 4, DataArray); //RX Mask 1
//SPISeqWrite(RXB0CTRL, 1, 0); //RXB0 Control JM
//SPISeqWrite(RXB1CTRL, 1, 0); //RXB1 Control JM
//Configure FILTERS
//Will RX standard messages into RXB0 and extended into RXB1
DataArray[0] = 0x00;
DataArray[1] = 0x00;
DataArray[2] = 0x00;
DataArray[3] = 0x00;
/*
if(EEPROM_ver)
{
DataArray[0]=EEPROMBYTERead(RXF0SIDH);
DataArray[1]=EEPROMBYTERead(RXF0SIDL);
DataArray[2]=EEPROMBYTERead(RXF0EID8);
DataArray[3]=EEPROMBYTERead(RXF0EID0);
}
else
{
EEPROMDataWrite(RXF0SIDH,&DataArray[0],4);
}
*/
SPISeqWrite(RXF0SIDH, 4, DataArray);
//SPIByteWrite(RXF0SIDL, 0x00); //Clearing EXIDE... the rest is "don't care"
DataArray[0] = 0x00;
DataArray[1] = 0x00;
DataArray[2] = 0x00;
DataArray[3] = 0x00;
/*
if(EEPROM_ver)
{
DataArray[0]=EEPROMBYTERead(RXF1SIDH);
DataArray[1]=EEPROMBYTERead(RXF1SIDL);
DataArray[2]=EEPROMBYTERead(RXF1EID8);
DataArray[3]=EEPROMBYTERead(RXF1EID0);
}
else
{
EEPROMDataWrite(RXF1SIDH,&DataArray[0],4);
}
*/
SPISeqWrite(RXF1SIDH, 4, DataArray);
//SPIByteWrite(RXF1SIDL, 0x00); //Clearing EXIDE... the rest is "don't care" //JM
DataArray[0] = 0x00;
DataArray[1] = 0x08;
DataArray[2] = 0x00;
DataArray[3] = 0x00;
/*
if(EEPROM_ver)
{
DataArray[0]=EEPROMBYTERead(RXF2SIDH);
DataArray[1]=EEPROMBYTERead(RXF2SIDL);
DataArray[2]=EEPROMBYTERead(RXF2EID8);
DataArray[3]=EEPROMBYTERead(RXF2EID0);
}
else
{
EEPROMDataWrite(RXF2SIDH,&DataArray[0],4);
}
*/
SPISeqWrite(RXF2SIDH, 4, DataArray);
//SPIByteWrite(RXF2SIDL, 0x08); //Setting EXIDE... the rest is "don't care"
DataArray[0] = 0x00;
DataArray[1] = 0x08;
DataArray[2] = 0x00;
DataArray[3] = 0x00;
/*
if(EEPROM_ver)
{
DataArray[0]=EEPROMBYTERead(RXF3SIDH);
DataArray[1]=EEPROMBYTERead(RXF3SIDL);
DataArray[2]=EEPROMBYTERead(RXF3EID8);
DataArray[3]=EEPROMBYTERead(RXF3EID0);
}
else
{
EEPROMDataWrite(RXF3SIDH,&DataArray[0],4);
}
*/
SPISeqWrite(RXF3SIDH, 4, DataArray);
//SPIByteWrite(RXF3SIDL, 0x08); //Setting EXIDE... the rest is "don't care" //JM
DataArray[0] = 0x00;
DataArray[1] = 0x08;
DataArray[2] = 0x00;
DataArray[3] = 0x00;
/*
if(EEPROM_ver)
{
DataArray[0]=EEPROMBYTERead(RXF4SIDH);
DataArray[1]=EEPROMBYTERead(RXF4SIDL);
DataArray[2]=EEPROMBYTERead(RXF4EID8);
DataArray[3]=EEPROMBYTERead(RXF4EID0);
}
else
{
EEPROMDataWrite(RXF4SIDH,&DataArray[0],4);
}
*/
SPISeqWrite(RXF4SIDH, 4, DataArray);
//SPIByteWrite(RXF4SIDL, 0x08); //Setting EXIDE... the rest is "don't care" //JM
DataArray[0] = 0x00;
DataArray[1] = 0x08;
DataArray[2] = 0x00;
DataArray[3] = 0x00;
/*
if(EEPROM_ver)
{
DataArray[0]=EEPROMBYTERead(RXF5SIDH);
DataArray[1]=EEPROMBYTERead(RXF5SIDL);
DataArray[2]=EEPROMBYTERead(RXF5EID8);
DataArray[3]=EEPROMBYTERead(RXF5EID0);
}
else
{
EEPROMDataWrite(RXF5SIDH,&DataArray[0],4);
}
*/
SPISeqWrite(RXF5SIDH, 4, DataArray);
//SPIByteWrite(RXF5SIDL, 0x08); //Setting EXIDE... the rest is "don't care" //JM
//Configure TX BUFFER 0
DataArray[0] = 0xA3;
DataArray[1] = 0x09;
DataArray[2] = 0x12;
DataArray[3] = 0x34;
DataArray[4] = 0x04;
DataArray[5] = 0x00;
DataArray[6] = 0x01;
DataArray[7] = 0x02;
DataArray[8] = 0x03;
DataArray[9] = 0x04;
DataArray[10] = 0x05;
DataArray[11] = 0x06;
DataArray[12] = 0x07;
/*
if(EEPROM_ver)
{
DataArray[0]=EEPROMBYTERead(TXB0SIDH);
DataArray[1]=EEPROMBYTERead(TXB0SIDL);
DataArray[2]=EEPROMBYTERead(TXB0EID8);
DataArray[3]=EEPROMBYTERead(TXB0EID0);
DataArray[4]=EEPROMBYTERead(TXB0DLC);
DataArray[5]=EEPROMBYTERead(TXB0D0);
DataArray[6]=EEPROMBYTERead(TXB0D1);
DataArray[7]=EEPROMBYTERead(TXB0D2);
DataArray[8]=EEPROMBYTERead(TXB0D3);
DataArray[9]=EEPROMBYTERead(TXB0D4);
DataArray[10]=EEPROMBYTERead(TXB0D5);
DataArray[11]=EEPROMBYTERead(TXB0D6);
DataArray[12]=EEPROMBYTERead(TXB0D7);
}
else
{
EEPROMDataWrite(TXB0SIDH,&DataArray,13);
}
*/
SPILoadTX(CAN_LD_TXB0_ID, 13, DataArray);
//Configure TX BUFFER 1
DataArray[0] = 0x22;
DataArray[1] = 0x00;
DataArray[2] = 0x64;
DataArray[3] = 0x68;
DataArray[4] = 0x02;
DataArray[5] = 0x00;
DataArray[6] = 0x11;
DataArray[7] = 0x22;
DataArray[8] = 0x33;
DataArray[9] = 0x44;
DataArray[10] = 0x55;
DataArray[11] = 0x66;
DataArray[12] = 0x77;
/*
if(EEPROM_ver)
{
DataArray[0]=EEPROMBYTERead(TXB1SIDH);
DataArray[1]=EEPROMBYTERead(TXB1SIDL);
DataArray[2]=EEPROMBYTERead(TXB1EID8);
DataArray[3]=EEPROMBYTERead(TXB1EID0);
DataArray[4]=EEPROMBYTERead(TXB1DLC);
DataArray[5]=EEPROMBYTERead(TXB1D0);
DataArray[6]=EEPROMBYTERead(TXB1D1);
DataArray[7]=EEPROMBYTERead(TXB1D2);
DataArray[8]=EEPROMBYTERead(TXB1D3);
DataArray[9]=EEPROMBYTERead(TXB1D4);
DataArray[10]=EEPROMBYTERead(TXB1D5);
DataArray[11]=EEPROMBYTERead(TXB1D6);
DataArray[12]=EEPROMBYTERead(TXB1D7);
}
else
{
EEPROMDataWrite(TXB1SIDH,&DataArray,13);
}
*/
SPILoadTX(CAN_LD_TXB1_ID, 13, DataArray);
//Configure TX BUFFER 2
DataArray[0] = 0xAA;
DataArray[1] = 0x03;
DataArray[2] = 0x33;
DataArray[3] = 0x33;
DataArray[4] = 0x08;
DataArray[5] = 0xAA;
DataArray[6] = 0xBB;
DataArray[7] = 0xCC;
DataArray[8] = 0xDD;
DataArray[9] = 0xEE;
DataArray[10] = 0xFF;
DataArray[11] = 0x0A;
DataArray[12] = 0x0B;
SPILoadTX(CAN_LD_TXB2_ID, 13, DataArray);
/*
if(EEPROM_ver)
{
DataArray[0]=EEPROMBYTERead(TXB2SIDH);
DataArray[1]=EEPROMBYTERead(TXB2SIDL);
DataArray[2]=EEPROMBYTERead(TXB2EID8);
DataArray[3]=EEPROMBYTERead(TXB2EID0);
DataArray[4]=EEPROMBYTERead(TXB2DLC);
DataArray[5]=EEPROMBYTERead(TXB2D0);
DataArray[6]=EEPROMBYTERead(TXB2D1);
DataArray[7]=EEPROMBYTERead(TXB2D2);
DataArray[8]=EEPROMBYTERead(TXB2D3);
DataArray[9]=EEPROMBYTERead(TXB2D4);
DataArray[10]=EEPROMBYTERead(TXB2D5);
DataArray[11]=EEPROMBYTERead(TXB2D6);
DataArray[12]=EEPROMBYTERead(TXB2D7);
}
else
{
EEPROMDataWrite(TXB2SIDH,&DataArray,13);
}
*/
SPISeqRead(TXB1SIDH, 13, ReadArray);
//Configure BIT TIMING
SOF_ENABLED; //Start-of-Frame signal enabled. Will set when "SetBitTiming()" is called
/*
if(EEPROM_ver)
{
DataArray[0] = EEPROMBYTERead(CNF3); //Load array
DataArray[1] = EEPROMBYTERead(CNF2); //
DataArray[2] = EEPROMBYTERead(CNF1); //
SPISeqWrite(CNF3, 3, DataArray); //Write registers
}
else
*/
{
SetBitTiming(CAN_125kbps); //Note, this function puts device in Normal Mode
}
//Set Normal Mode and verify
SET_NORMAL;
SPIByteWrite(CANCTRL,CANCTRL_byte); //Write to CANCTRL
old_CANCTRL = 0x00;
//EEPROMCRCWrite(0,128);
//Verify Mode change
if ((SPIByteRead(CANSTAT)& 0xE0) != OPMODE_NORMAL)
SPIByteWrite(CANCTRL,CANCTRL_byte); //Try again
}
/************************************************** ****************************
* Function: void SetBitTiming//(char data_rate)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function sets the bit timing.
*
*
* Note: None
************************************************** ***************************/
void SetBitTiming(char data_rate)
{
unsigned char a,b,c,dummy;
//Set Config Mode and verify
SET_CONFIG; //Set Configuration mode
SPIByteWrite(CANCTRL,CANCTRL_byte); //Write to CANCTRL
//Verify Mode change
if ((SPIByteRead(CANSTAT)& 0xE0) != OPMODE_CONFIG)
SPIByteWrite(CANCTRL,CANCTRL_byte); //Try again
//Need 10TQ based on 20 MHz osc
//Will only need to modify BRP to acheive the 4 bit rates
//First clear CNFn registers
CNF1_byte = 0;
CNF2_byte = 0;
CNF3_byte = 0;
//Now set individual bits
SJW_1TQ; //Sync Jump Width
PRSEG_3TQ; //Prop Segment
PHSEG1_3TQ; //Phase Seg 1
PHSEG2_3TQ; //Phase Seg 2
BTLMODE_CNF3; //Use CNF3 to set Phase Seg 2
SOF_ENABLED; //Start-of-Frame signal enabled. Will set when "SetBitTiming()" is called
//Configure Baud Rate Prescaler
switch(data_rate) // interpret command
{
case CAN_125kbps: // Set to 125 kbps
BRP7; //
break;
case CAN_250kbps: // Set to 250 kbps
BRP3; //
break;
case CAN_500kbps: // Set to 500 kbps
BRP1; //
break;
case CAN_1000kbps: // Set to 1000 kbps
BRP0; //
break;
default: // unrecognized or null command
;
}// END switch: data_rate
//Now write the CNFn registers
DataArray[0] = CNF3_byte; //Load array
DataArray[1] = CNF2_byte; //
DataArray[2] = CNF1_byte; //
SPISeqWrite(CNF3, 3, DataArray); //Write registers
//Set Normal Mode and verify
SET_NORMAL;
SPIByteWrite(CANCTRL,CANCTRL_byte); //Write to CANCTRL
//Verify Mode change
if ((SPIByteRead(CANSTAT)& 0xE0) != OPMODE_CONFIG)
SPIByteWrite(CANCTRL,CANCTRL_byte); //Try again
EEPROMDataWrite(CNF3,&DataArray,3);
}
/************************************************** ****************************
* Function: void CANLoadTX(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function transmits messages on the CAN bus depending
* on the Load Button setting
*
* Note:
************************************************** ***************************/
void CANLoadTX(void)
{
static char buffer_q;
if(UserFlag.CANLoading) //if bus loading is turned on
{
CANLoadTimer++; //Increment the counter
if (!CANLoadTimer) //if rolled over, set flag. User code will handle the rest.
{
CANLoadTimer = LoadPrescaler;
switch(buffer_q) // interpret command
{
case 0: // Send buffer 0
RTS0_2515_LOW();
RTS0_2515_HIGH();
buffer_q = 1; //For next time around
break;
case 1: // Send buffer 1
RTS1_2515_LOW();
RTS1_2515_HIGH();
buffer_q = 2; //For next time around
break;
case 2: // Send buffer 2
RTS2_2515_LOW();
RTS2_2515_HIGH();
buffer_q = 0; //For next time around
break;
default: // unrecognized or null command
buffer_q = 0;
}// END switch:
}//END: if (!CANLoadTimer)
}//END: if(UserFlag.CANLoading)
}
/************************************************** ****************************
* Function: void EEPROMBYTEWrite(char addr,char data)
*
* PreCondition: None
*
* Input: data and address
*
* Output: None
*
* Side Effects: None
*
* Overview: This function writes a byte to EEPROM in addr
*
* Note:
************************************************** ***************************/
void EEPROMBYTEWrite(char addr,char data)
{
char buf_con=INTCON;
return;
EEADR=addr;
EEDATA=data;
EECON1bits.EEPGD=0;
EECON1bits.CFGS=0;
EECON1bits.WREN=1;
INTCONbits.GIE=0;
EECON2=0x55;
EECON2=0xaa;
EECON1bits.WR=1;
while(EECON1bits.WR==1);
EECON1bits.WREN=0;
//INTCONbits.GIE=1;
INTCON=buf_con;
}
/************************************************** ****************************
* Function: void EEPROMDataWrite(char addr,char* data,char len)
*
* PreCondition: void EEPROMBYTEWrite(char addr,char data)
*
* Input: begin address,data address,data length
*
* Output: None
*
* Side Effects: None
*
* Overview: This function writes a byte to EEPROM in addr
*
* Note:
************************************************** ***************************/
void EEPROMDataWrite(char addr,char* data,char len)
{
unsigned char i;
for(i=0;i<len;i++)
{
EEPROMBYTEWrite(addr+i,data[i]);
}
}
/************************************************** ****************************
* Function: void EEPROMBYTERead(char addr,char data)
*
* PreCondition: None
*
* Input: address
*
* Output: data
*
* Side Effects: None
*
* Overview: This function writes a byte to EEPROM in addr
*
* Note:
************************************************** ***************************/
char EEPROMBYTERead(char addr)
{
EEADR=addr;
EECON1bits.EEPGD=0;
EECON1bits.CFGS=0;
EECON1bits.RD=1;
return EEDATA;
}
/************************************************** ****************************
* Function: void EEPROMDataRead(char addr,char data)
*
* PreCondition: None
*
* Input: address in EEPROM,buffer address,data length
*
* Output: data
*
* Side Effects: None
*
* Overview: This function writes a byte to EEPROM in addr
*
* Note:
************************************************** ***************************/
void EEPROMDataRead(char addr,char* data,char len)
{
unsigned char i;
for(i=0;i<len;i++)
{
data[i]=EEPROMBYTERead(addr+i);
}
}
/************************************************** ****************************
* Function: void EEPROMCRCWrite(char addr,char len)
*
* PreCondition: None
*
* Input: address in EEPROM,data length
*
* Output: data
*
* Side Effects: None
*
* Overview: This function writes a byte to EEPROM in addr
*
* Note:
************************************************** ***************************/
void EEPROMCRCWrite(char addr,char len)
{
unsigned char buf,i;
buf=0;
for(i=0;i<len;i++)
{
buf+=EEPROMBYTERead(i+addr);
}
EEPROMBYTEWrite(128,buf);
}
/************************************************** ****************************
* Function: bool EEPROMCRCCheck(char addr,char len)
*
* PreCondition: None
*
* Input: address in EEPROM,data length
*
* Output: true for checksum equal
*
* Side Effects: None
*
* Overview: This function writes a byte to EEPROM in addr
*
* Note:
************************************************** ***************************/
BOOL EEPROMCRCCheck(char addr,char len)
{
unsigned char buf,i;
buf=0;
for(i=0;i<len;i++)
{
buf+=EEPROMBYTERead(i+addr);
}
if(buf==EEPROMBYTERead(128))
{
return TRUE;
}
else
{
return FALSE;
}
}
/** EOF BusMon.c****************************************** **************/
But I took another look at your code.... At the very beginning, in the INITIALIZE MCP2515 section you have this piece of code:
Code:
LOW CS
SSPBUF = MCPRST ' COMMAND TO RESET THE MCP2515
PIR1.3 = 0
WHILE PIR1.3=0 :WEND
HIGH CS
I then went to see exactly what MCPRST was and the only thing I found in your code was an alias to PortC.0 so what's happening in that piece of code is that the PIC reads PortC.0 and then the result of that read operation (1 or 0) to SSPBUF. To reset the device you either pull the hardware reset line LOW or send $C0 over SPI.I tried $C0 and pulling the reset line low, both of which didn't seem to work. The problem is, I was trying multiple things at the same time and I ended up just putting the MCPRST command thinking it was $C0 when I meant to use CAN_RST, which is already in my code! Good catch! Maybe I should not work on this until 1am tonight!;)
Properly resetting the device automatically puts in the configuration mode so therotically you shouldn't need to put it in that mode directly after a (proper) reset. Then your comments says that you're writing to "part of baudrate" or something but $07 is the EXTENDED IDENTIFIER LOW register receiver 1, $03 is EXTENDED IDENTIFIER LOW register for receiver 0 and I can't even find what $BA is.I was confused about this too so I searched the internet for someone who has written this code properly AND it worked. I found this:
Public Sub mcp2515_CAN_Freq()
mcp_assert_cs() ' start comms to MCP2515
spi_transfer(SPI_WRITE) ' send write command
spi_transfer(CNF3) ' address
spi_transfer(config3) ' CNF3
spi_transfer(config2) ' CNF2
spi_transfer(config1) ' CNF1
mcp_deassert_cs() ' stop comms to MCP2515
End Sub
This portion of C code seems self explanatory but configuring CNF1, CNF2 AND CNF3 was confusing. They talk about propagation segment, bit time length, Fosc, BRP, etc. It's all new to me and confusing so I went with values I found on the internet, which were $07, $BA and $03. It has to do with timing the MCP frequency with the oscillator frequency and I *think* those numbers are correct.
OK, moving to MAIN then....
You send the command to write then you send the value 0 to CANINTE at adress $02, that all seems OK to me if disabling interrupts is what you want to do.For now I just want to send something so I'm disabling the interrupts.
Next you set the TXB0CTRL register for a high priority message and request it to send. Then you write the TRANSMIT BUFFER STANDARD IDENTIFIER register. I have no idea what these does so I'm going to asume it's correct. Then, you tell it you want to send a single byte by writing the value 1 to TXB0DLC and then you write the actual data.The SID, if I understand correctly, is the ID of the message. I've circled it in red and I think this is the SID:6604
Personally I would've thought you should first load the data to be sent THEN tell the device to send it. Ie write TXB0CTRL after you've loaded the data but the way you have it might be correct.I'll play around with it and see what works better.
I don't understand what Fosc command to use. I have 20 MhZ oscillator. Do I use:
SSPM3:SSPM0: Master Synchronous Serial Port Mode Select bits
0101 = SPI Slave mode, clock = SCK pin, SS pin control disabled, SS can be used as I/O pin(3)
0100 = SPI Slave mode, clock = SCK pin, SS pin control enabled(3)
0011 = SPI Master mode, clock = TMR2 output/2(3)
0010 = SPI Master mode, clock = FOSC/64(3)
0001 = SPI Master mode, clock = FOSC/16(3)
0000 = SPI Master mode, clock = FOSC/4(3)
Thanks for all of your help Henrik, I wouldn't have gotten this far without it.