multican.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/

 
#ifndef _MULTICAN_H
#define _MULTICAN_H
 
#ifdef DOXYGEN_STUFF
namespace canMCF5441x
{
#endif
 

 
#if (defined MOD5441X)
#define DEFAULT_CAN_MOD (0)
#elif (defined NANO54415)
#define DEFAULT_CAN_MOD (1)
#elif (defined SB800EX)
#define DEFAULT_CAN_MOD (0)
#endif
 
#define CAN_OK (0)
#define CAN_RATE_FAIL (-1)
#define CAN_ALREAD_OPEN (-2)
#define CAN_CHANNEL_USED (-3)
#define CAN_CHANNEL_NOT_USED (-4)
#define CAN_TIMEOUT (-5)
 
#define DONT_WAIT (0xFFFF)  // Non-blocking value for CanRxMessage and GetNewMessage timeout parameter
 
struct PrivateCanData;

class CanRxMessage
{
   private:
    PrivateCanData *pData;
    /* Private constructor used for received frames */
    CanRxMessage(PrivateCanData *pData);
 
    /* Helper method for the RTR constructors */
    void MultiCanSendRTR(int moduleNum, uint32_t id, uint16_t timeout, uint8_t length);
 
    inline void CanSendRTR(uint32_t id, uint16_t timeout, uint8_t length) { return MultiCanSendRTR(DEFAULT_CAN_MOD, id, timeout, length); }
 
   public:
    uint8_t GetLength();

    uint8_t GetData(uint8_t *buffer, uint8_t max_len);

    uint32_t GetId();

    uint16_t GetTimeStamp();

    BOOL IsValid();
 
    /* Constructors */

    CanRxMessage(OS_FIFO *pFifo, uint16_t timeout);

    CanRxMessage(int moduleNum, uint32_t id, uint16_t timeout);
 
    CanRxMessage(int moduleNum, uint32_t id, uint16_t timeout, uint8_t length);

    ~CanRxMessage();

    BOOL GetNewMessage(OS_FIFO *pFifo, uint16_t timeout);
};
 
/**********************************************************************************
 
               A special note about CAN identifiers
 
**********************************************************************************
 Can identifiers come in two flavors, Normal (11 bits ) and Extended. (29 bits)
 In this software API we always refer to can identifiers as 32 bit uint32_tS.
 A 32 bit uint32_t is bigger than either Identifier.
 
 A Normal identifier will always have bits 0 to 17 as zero
 
 An extended identifier can have bits 0 to 17 low. So extended identifiers
 that are received will have bit 29 set to 1. Any ID input into the
 system will be treated as extended if bit 29 is set or if bits
 0 to 17 are not zero.
 
 The following MACROS can help work with this ID scheme.
 */
 
/* The single bit used by this API to indicate an extended ID */
#define CAN_EXTENDED_ID_BIT (0x20000000)
 
/* This macro takes and id and returs an ID that is guarenteed
to be treated as an extended ID by the system
Make an id that is extended from either extended or normal */
#define ExtToNbId(id) (id | CAN_EXTENDED_ID_BIT)
 
/*Make Normal Id make an ID set from a normal id in the range 0 to 2048 */
#define NormToNbId(id) ((id & 0x7ff) << 18)
 
/* Is the ID extended ?  returns non zero if the id passed in was an extended ID */
#define IsNBIdExt(id) ((id & (CAN_EXTENDED_ID_BIT | 0x3FFFF)) != 0)
 
/* Strip the extra flag remove the API extended flage from the ID*/
#define NbToExtId(id) (id & 0x1FFFFFFF)
 
/* Shift a Normal ID so it hase value 0 to 1023
Some CAN systems will treat normal ID's as an integer from 0 to 2048
Other systems may treat normal ID's as 28 bit values wheer the bottom 17 bits are zero
This MACRO will convert our Normal ID format into the 0 to 2048 format.*/
#define NbToNormId(id) ((id >> 18) & 0x7FF)
 
/* Initialize the CAN system
parameters:
 
   bit_rate is the bitrate to run the CAN system at.
         The system will get as close as possible, but 1000000, 500000, 250000 and 125000 are
         the only values that are known to work.
 
   Global_Mask is the mask used to mask received ID's a bit =0 is don't care, 1= care.
 
   irq_level The interrupt level you want the CAN system to operate at.
 
Returns
   CAN_OK on success.
   CAN_RATE_FAIL if the bit rate could not be set withing 1.5%
   CAN_ALREADOPEN if the CAN system is already running. Youmust call CanShutDown first.
*/
int MultiCanInit(int moduleNum, uint32_t bit_rate, uint32_t Global_Mask, uint8_t irq_level = 4);
 
/* Shut down the CAN system */
void MultiCanShutDown(int moduleNum);
 
/* Change the global receive mask after the CAN system is started. */
void MultiCanChangeGlobalMask(int moduleNum, uint32_t Global_Mask);
 
/* The CAN system has 16 availible channels this tells how many are currently in use */
int MultiCanFreeCanChannels(int moduleNum);
 
/* This tells if a specific channel is currently free */
BOOL MultiCanIsChannelFree(int moduleNum, int channel);
 
/* RegisterCanRxFifo and RegisterCanSpecialRxFifo
Tell the CAN system to start listening for a specific CAN ID.
Any incoming CAN frames that match the id as set by the apropriate mask will
be placed into the fifo.
 
Parameters:
   uint32_t id The identifer to match on received frames. This is modified by
            the global mask, or in the case of the RegisterCanSpecial
            the passed in mask.
 
   uint32_t spl_mask Only used by RegisterCanSpecialRxFifo. There are only
               two channels availible for use with the speical mask
               so use this call sparinging and only if really needed.
 
   OSFifo * pFifo The Fifo used to communicate between the CAN subsystem and
               the CanRxMessageClass. This FIFO must be initialized before use.
               The same fifo can be passed to multiple receive regestration functions.
 
   int channel The Channel to place the receive request. A value of -1 allows the system to
            select an unused channel.
 
 
Returns
   Any value >=0 the channel this request is assigned to. This value must be stored to
            later call UnRegisterCanFifo.
   CAN_CHANNEL_USED If the channel is used or there are no free channels.
 
*/
int RegisterMultiCanRxFifo(int moduleNum, uint32_t id, OS_FIFO *pFifo, int channel = -1);
int RegisterMultiCanSpecialRxFifo(int moduleNum, uint32_t id, uint32_t spl_mask, OS_FIFO *pFifo, int channel = -1);
 
/* disconnect a receiver channel form a Fifo
Parameters:
   int channel The channel to remove.
 
returns
   CAN_OK if succesful.
   CAN_CHANNEL_NOT_USED if the channel was not currently in use
*/
int UnRegisterMultiCanFifo(int moduleNum, int channel);
 
/* Send a message
Parameters:
   uint32_t id The Identifier to send. See the earlier discussion of identifiers.
         and the identifier macros.
 
   uint8_t * data A pointer to the data to send
 
   uint8_t len The length of the Data must be <=8.
 
   uint16_t timeout How lont to wait for confirmation it sent.
      0 = wait forevver.
      0xFFFF = don't wait at all.
 
   int channel The channel to use. A value of -1
       will allow the system to pick and unused channel.
 
Returns
   CAN_OK   If the message was sent
   CAN_CHANNEL_USED Can't send because the channel was already in use or no channels availible.
   CAN_TIMEOUT Did not send in the time alotted
*/
int MultiCanSendMessage(int moduleNum, uint32_t id, uint8_t *data, uint8_t len, uint16_t timeout, int channel = -1);
 
/*RTR messages
Can can be configured to send messages in response to memessage requests.
The next three functions handle that functionality */
 
/* Set RTRMessage
This sets up a message to be sent in response to an incoming message that matches the
RTR message id. The system will continue to respond with this message forever.
 
Parameters:
   uint32_t id. The id to respond to and the id responded with.
   uint8_t * data The data to respond with
   uint8_t len The length of the responding data.
   int channel The channel to use, or -1 to let the system pic one.
 
Returns:
   value >0 the channel assigned to this tsk or the channel requested.
   CAN_CHANNEL_USED if the channel is already used or no free channels are availible.
*/
int MultiCanSetRTRMessage(int moduleNum, uint32_t id, uint8_t *data, uint8_t len, int channel = -1);
 
/*ReplaceRTRMessage
Replace the outgoing message in an RTR channel already set up
with a call to SetRTRMessage. Use of this function can
cause a brief instant (a few uSec.) when no message response would be sent
to an incoming request. If this is unacceptible register two identical RTR
messages and change them in sequence.
 
 
Parameters:
   int channel The channel value returned from the SetRTRMessage call
   uint8_t * data the data to send.
   uint8_t len the length of the data.
 
 
Returns
   CAN_OK if the replacement succeded.
   CAN_CHANNEL_NOT_USED if the passed in channed was not set up for RTR messages
 
*/
int MultiCanReplaceRTRMessage(int moduleNum, int channel, uint8_t *data, uint8_t len);
 
/* Stop an RTR message
Parameters:
   int channel The channel value returned from the SetRTRMessage call
 
Returns
   CAN_OK if the replacement succeded.
   CAN_CHANNEL_NOT_USED if the passed in channed was not set up for RTR messages
 
*/
int MultiCanStopRTRMessage(int moduleNum, int channel);
 
// Should a user include functions used in the canif.h file, these inline functions
// will call the MultiCan module function associated with that function.
 
inline int CanInit(uint32_t bit_rate, uint32_t Global_Mask, uint8_t irq_level = 4)
{
    return MultiCanInit(DEFAULT_CAN_MOD, bit_rate, Global_Mask, irq_level);
}
 
inline void CanShutDown(void)
{
    return MultiCanShutDown(DEFAULT_CAN_MOD);
}
 
inline void ChangeGlobalMask(uint32_t Global_Mask)
{
    return MultiCanChangeGlobalMask(DEFAULT_CAN_MOD, Global_Mask);
}
 
inline int RegisterCanRxFifo(uint32_t id, OS_FIFO *pFifo, int channel = -1)
{
    return RegisterMultiCanRxFifo(DEFAULT_CAN_MOD, id, pFifo, channel);
}
 
inline int RegisterCanSpecialRxFifo(uint32_t id, uint32_t spl_mask, OS_FIFO *pFifo, int channel = -1)
{
    return RegisterMultiCanSpecialRxFifo(DEFAULT_CAN_MOD, id, spl_mask, pFifo, channel);
}
 
inline int UnRegisterCanFifo(int channel)
{
    return UnRegisterMultiCanFifo(DEFAULT_CAN_MOD, channel);
}
 
inline int SendMessage(uint32_t id, uint8_t *data, uint8_t len, uint16_t timeout, int channel = -1)
{
    return MultiCanSendMessage(DEFAULT_CAN_MOD, id, data, len, timeout, channel);
}
 
inline int SetRTRMessage(uint32_t id, uint8_t *data, uint8_t len, int channel = -1)
{
    return MultiCanSetRTRMessage(DEFAULT_CAN_MOD, id, data, len, channel);
}
 
inline int ReplaceRTRMessage(int channel, uint8_t *data, uint8_t len)
{
    return MultiCanReplaceRTRMessage(DEFAULT_CAN_MOD, channel, data, len);
}
 
inline int StopRTRMessage(int channel)
{
    return MultiCanStopRTRMessage(DEFAULT_CAN_MOD, channel);
}
 
/* The CAN system has 16 availible channels this tells how many are currently in use */
inline int FreeCanChannels()
{
    return MultiCanFreeCanChannels(DEFAULT_CAN_MOD);
}
 
/* This tells if a specific channel is currently free */
inline BOOL IsChannelFree(int channel)
{
    return MultiCanIsChannelFree(DEFAULT_CAN_MOD, channel);
}
 
/*******************************************************************************
 Example #1
 
 To set up to receive frames:
 
 
OS_FIFO fifo;
OSFifoInit(&fifo);
 
//REgister to listen for CAN data
//We will listed for frames with a normal is of 123
int chan1=RegisterCanRxFifo( MakeIdFromNormal(123),& fifoifo);
 
//We will also listen for the extended frame id of 0x1234
int chan2=RegisterCanRxFifo( ox1234,& fifoifo);
 
if ((chan1 >0) || (chan2> 0)_
 {//We succeded in registering the fifo
  while(1)
  {
   CanRxMessage can_msg(&fifo,30*TICKS_PER_SECOND); //Wait up to 20 seconds
   if (can_msg.IsValid())
    {uint8_t buffer[8];
     uint8_t len;
     len=can_msg.GetData(buffer,8);
 
     iprintf("got a can message of %d bytes from ID %08X \r\n",len ,can_msg.GetId());
     iprintf("Data = [");
     for (int i=0; i<len; i++)
       iprintf("%02X ",buffer[i]);
     iprintf("]\r\n");
    }
   else
   iprintf("CAN received timed out ");
  }
 }
 
**************************************************************************************
End of example #1
**************************************************************************************/
 
/*******************************************************************************
 Example #2
 Setup an automatic response buffer (an RTR buffer)
 
// we want to setup an automatic response message (RTR
//We will update it every 5 seconds
uint16_t value=GetValue();
int RTRChan=SetRTRMessage(0x5678,(puint8_t),&value,sizeof(value));
 
 
while (1)
{
//Every 5 seconds update the value stored in the message
OSTimeDly(5 * TICKS_PER_SECOND);
 
//Get the new value
value=GetValue();
//Store it in the automatic response channel
ReplaceRTRMessage(RTRChan,(puint8_t),&value,sizeof(value) );
}
 
 
**************************************************************************************
End of example #2
**************************************************************************************/

 
#ifdef DOXYGEN_STUFF
}   // namespace
#endif
 
#endif