readsend.cpp

/*------------------------------------------------------|

|                            |

|  Version 1.3    Date: 09/10/2009          |

|  Author:      Dennis Schuethe            |

|  Company:    Anders Electronics          |

|  file name:    readsend.cpp            |

|                            |

|  Description:                    |

|    This subprogramm includes the functions      |

|    for receive and transmit a message        |

|    over the CAN bus.                |

|    The transmition of a message is only done by  |

|    the TX0 register and only for standart      |

|    identifier.                    |

|    The receive function reads messages only for  |

|    standart identifier, but from both registers  |

|------------------------------------------------------*/

extern "C"

{

#include "main.h"

/*send specific data to MCP2515 and enables transmission-------------------------------------------*/

// send only via TXB0 register

int sendMessageStdId(tStdID *identifier, BYTE *pDataIn, unsigned char dataLength)

{

  //local variables

  BYTE idBits10to3= identifier->stdID >> 3;

  BYTE idBits2to0 = identifier->stdID << 5;

  int i= 0;

  int j= 0;

  short returnValue;

  while( (readRegister(TXB0CTRL) & 0x08 != 0x00) BREAKAFTER ) i++; //Check if last message has been send before start writing new message

  if (BREAK) //if the while loop one line above has been quited by register readout

  {

    i=0;

    resetFlags( 0x04);  // reset the transmission complete flag

    // all addresses needed for sending data

    BYTE addresses[6] = {TXB0D0, TXB0D2, TXB0D4, TXB0D6, TXB0EID0, TXB0SIDH};

    //variables for transmission via SPI

    DWORD speed = SPISPEED;

    BYTE dataIn[4];

    dataIn[0]= WRITE_SPI;

    DWORD lengthIn = 4;

    BYTE dataOut[4];

    DWORD bytesreturn = 0;

    // write data into the data registers

    while( j < dataLength) {  

      dataIn[1]= addresses[i++]; 

      dataIn[2]= pDataIn[j++]; 

      if( j < dataLength) dataIn[3]= pDataIn[j++];

      SPIRW

    }

    i= 4;

    // write how many data bytes will be sent

    dataIn[1]= addresses[i++];

    dataIn[2]= 0x00;

    dataIn[3]= dataLength;

    SPIRW

    // write the std identifier into the registers

    dataIn[1]= addresses[i];

    dataIn[2]= idBits10to3;

    dataIn[3]= idBits2to0;

    SPIRW

    // enable transmission of the stored data

    dataIn[0] = RTS_TXB0; 

    lengthIn = 1;

    SPIRW

    returnValue = 0;

  }  

  else

    returnValue = ERR;

  return returnValue;

}

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

/*-read-data from MCP2515 and resets the reading flags----------------------------------------*/

int readMessageStdId(BYTE *pDataOut , tStdID *pID, int *dataLength)

{

  short returnValue = -1;

  short i=0,j=0;

  BYTE msgaddress[8] = { RXB0D0 , RXB0D2, RXB0D4, RXB0D6,

               RXB1D0, RXB1D2, RXB1D4, RXB1D6  };

  BYTE dataIn[4]={RX_STATUS , 0x00, 0x00 , 0x00};

  BYTE dataOut[4] = {0x00, 0x00, 0x00, 0x00};

  DWORD speed = SPISPEED;

  DWORD lengthIn = 4;

  DWORD bytesreturn = 0;

  SPIRW

  for (i=0; i < 8 ; i++) pDataOut[i]= (i << 4 | i);// initialization of the data out

  if (dataOut[1] == dataOut[2])

  {

    switch (dataOut[1] & 0xC0){

      // no message in any receive register

      case 0x00: 

        returnValue = 0; 

        break;

      // Message in Buffer 0 is reading out

      case 0x40:

        if ( readRegister(RXB0CTRL) & 0x08 == 0x08)  //a remote transfer request arrived

        {

          dataIn[0] = READ_RX_BF00; //read the SIDH and SIDL registers of BF0

          SPIRW

          pID->stdID = (dataOut[1] << 3) | (dataOut[2] >> 5); //write identifier into the address

          returnValue = 11; // signalisation of a remote transfer request

        }

        else

        {

          dataIn[0] = READ_RX_BF00; //read the SIDH and SIDL registers of BF0

          SPIRW

          pID->stdID = (dataOut[1] << 3) | (dataOut[2] >> 5); //write identifier into the address

          *dataLength = (int) readRegister(RXB0DLC) & 0x0f; //read how much data bytes has been sent

          dataIn[0] = READ_SPI;

          i = 0;

          // read out the data from data register 0 to 7

          for (j=0 ; j< *dataLength ; j++)

          {

            dataIn[1] = msgaddress[i++];

            SPIRW

            pDataOut[j] = dataOut[2];

            if(++j < *dataLength)

            pDataOut[j] = dataOut[3];

          }

          returnValue = 10; //msg read out from register 0

        }

        resetFlags(0x01);

        break;

      // Message in Buffer 1 reading out

      case 0x80:

        if ( readRegister(RXB1CTRL) & 0x08 == 0x08)  //a remote transfer request arrived

        {

          dataIn[0] = READ_RX_BF10; //read the SIDH and SIDL registers of BF0

          SPIRW

          pID->stdID = (dataOut[1] << 3) | (dataOut[2] >> 5); //write identifier into the address

          returnValue = 21; // signalisation of a remote transfer request

        }

        else

        {

          dataIn[0] = READ_RX_BF10; //read the SIDH and SIDL registers of BF1

          SPIRW

          pID->stdID = (dataOut[1] << 3) | (dataOut[2] >> 5); //write identifier into the address

          *dataLength = (int) readRegister(RXB1DLC) & 0x0f; //read how much data bytes has been sent

          dataIn[0] = READ_SPI;

          i = 0;

          // read out the data from data register 0 to 7

          for (j=0 ; j< *dataLength ; j++)

          {

            dataIn[1] = msgaddress[i++];

            SPIRW

            pDataOut[j] = dataOut[2];

            if(++j < *dataLength)

            pDataOut[++j] = dataOut[3];

          }

          returnValue = 20; //msg read out from register 1

        }

        resetFlags(0x02);

        break;

      // data in both registers, reading only the BF0

      case 0xC0:

        if ( readRegister(RXB0CTRL) & 0x08 == 0x08)  //a remote transfer request arrived

        {

          dataIn[0] = READ_RX_BF00; //read the SIDH and SIDL registers of BF0

          SPIRW

          pID->stdID = (dataOut[1] << 3) | (dataOut[2] >> 5); //write identifier into the address

          returnValue = 31; // signalisation of a remote transfer request

        }

        else

        {

          dataIn[0] = READ_RX_BF00; //read the SIDH and SIDL registers of BF0

          SPIRW

          pID->stdID = (dataOut[1] << 3) | (dataOut[2] >> 5); //write identifier into the address

          *dataLength = (int) readRegister(RXB0DLC) & 0x0f; //read how much data bytes has been sent

          dataIn[0] = READ_SPI;

          i = 0;

          // read out the data from data register 0 to 7

          for (j=0 ; j<*dataLength ; j++)

          {

            dataIn[1] = msgaddress[i++];

            SPIRW

            pDataOut[++j] = dataOut[2];

            if(j+1 < *dataLength)

            pDataOut[j] = dataOut[3];

          }

          returnValue = 30; //msg read out from register 0

        }

        resetFlags(0x01);

        break;

    }

  }

  else

    returnValue = -1; //failure-two different data bytes are read from the status register

  return returnValue;

}

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

}