Defining CAN Signals and Messages

To get a higher level of abstraction, CAN Signals and Messages can be used to abstract information mappings to the Bus communication objects. In this topic example, two signals called 'Nodestatus' and 'CPU-Load' will be sent in a CAN Message called 'Status' and updated through a CAN Message called 'Command' with the following Signal and Message definitions:

Signal Configuration

The Message Configuration below uses CAN Signals. Before CAN Messages can be used, each CAN signal must be configured accordingly. The Signal Configuration can be found in can_cfg.c. However, the "Signal Enumerations" are typically found in can_cfg.h. Signals allow the user to not worry about where a given signal is found within a CAN Message frame, while containing different types of data. For more information about CAN Signals click Here.

Note:

  • A CAN Signal can be defined without any CAN communication knowledge. No information about sending or receiving information is needed during configuration.


#include  "can_sig.h"

enum {                                           [1]            /* ---------------- SIGNAL ENUMERATIONS --------------- */
   S_NODESTATUS = 0, 
   S_CPULOAD,
   S_MAX,
};

const  CANSIG_PARA  CanSig[CANSIG_N] = {         [2]
                                                                /* ---------------- SIGNAL NODESTATUS ----------------- */
    {CANSIG_UNCHANGED,                           [3A]           /*      Initial Status                                  */ 
      1,                                          [B]           /*      Width in Bytes                                  */ 
      0,                                          [C]           /*      Initial Value                                   */ 
#if (CANSIG_CALLBACK_EN > 0)
      StatusChange},                              [D]           /*      Callback Function: User Defined                 */ 
#else
    },
#endif
                                                                /* ----------------- SIGNAL CPULOAD ------------------- */ 
    {CANSIG_UNCHANGED,                           [3A]           /*      Initial Status                                  */ 
      1,                                          [B]           /*      Width in Bytes                                  */ 
      0,                                          [C]           /*      Initial Value                                   */ 
#if (CANSIG_CALLBACK_EN > 0)
      0}                                          [D]           /*      No Callback                                     */ 
#else
    },
#endif
}; 

1] Enumeration is used to simpilfy CAN Signal definitions and to ensure a consistent Message-to-Signal mapping.

2] CAN Signal configuration is done as a global constant to save RAM space and get a write-protected configuration. Also, the configuration data will be read while using the CAN Signal Layer.

3] The following will explain the required configuration for each Signal.

A]  States the Initial Status of each signal.

B] States the width in bytes of the CAN signal. The Value here affects the Message Configuration's DLC & Number of Link parameters.

C] States the Initial Value for Each signal.

D] The Callback Function definition can be omitted by configuring the CANSIG_CALLBACK_EN parameter to 0 in can_cfg.h


Message Configuration

The Message Configuration can be found in can_cfg.c. However, the "Message Enumerations" are typically found in can_cfg.h. Please note that CAN Signals must be configured prior to be used in CAN Messages. For more information on CAN Messages click Here.

Note:

  • A CAN Message can be defined without any knowledge of the information generated and/or the usage of the payload. Only the mapping of the payload (and it's respective parts) must be known.


#include  "can_msg.h"

enum {                                           [1]            /* --------------- MESSAGE ENUMERATIONS --------------- */
   M_STATUS = 0, 
   M_COMMAND, 
   M_MAX
};

const  CANMSG_PARA  CanMsg[CANMSG_N] =           [2]
{ 
                                                                /* ------------------ MESSAGE STATUS ------------------ */
   { 0x123L,                                     [3A]           /*      CAN-Identifier                                  */  
     CANMSG_TX,                                   [B]           /*      Message Type                                    */ 
     2,                                           [C]           /*      DLC of Message                                  */ 
     2,                                                         /*      No. of Links                                    */ 
      { { S_NODESTATUS,                           [D]           /*      Signal ID                                       */ 
         0 },                                     [E]           /*      Byte Position                                   */ 
        { S_CPULOAD,                                            /*      Signal ID                                       */ 
         2 }                                                    /*      Byte Position                                   */ 
      },
   },
                                                                /* ----------------- MESSAGE COMMAND ------------------ */
   { 0x122L,                                     [4A]           /*      CAN-Identifier                                  */ 
     CANMSG_RX,                                   [B]           /*      Message Type                                    */ 
     1,                                           [C]           /*      DLC of Message                                  */ 
     1,                                                         /*      No. of Links                                    */ 
     { { S_NODESTATUS,                            [D]           /*      Signal ID                                       */ 
         0 }                                      [E]           /*      Byte Position                                   */ 
     }
   }
}; 

1] Enumeration is used to simplify CAN Message definitions and to ensure a consistent Message-to-Signal mapping.

2] CAN Message configuration is done as a global constant to save RAM space and get a write-protected configuration. Also, the configuration data will be read while using the CAN Message Layer.

3] The following will explain the Message 'Status' that will be used to Transmit the current status of the 'Nodestatus' and 'CPU-Load' Signals. These signals will be described above in the Signal Configuration.

A] Shows the CAN ID used to transmit the 'Status' Message on the CAN Bus line.

B] Shows the Message Type for the given message configuration. The 'Status' Message is set to 'Tx'.

C] Explains the DLC of the CAN Message along with the Number of Links mapped. The DLC and the Number of Links can be different based on the amount of Signals, their respective Byte Positions, and the Signal byte width.

D] The specified Signal ID used in the 'Status' CAN Message.

E] The Byte Position of the above Signal ID.

4] The following will explain the Message 'Command' that will be used to Receive the updated status of 'Nodestatus' Signal. This signal will be described above in the Signal Configuration.

A] CAN ID used for the 'Command' Message. The 'Command' Message will not be updated, unless the Rx'd CAN Frame has this CAN ID.

B] Shows the Message Type for the given message configuration. The 'Command' Message is set to 'Rx'.

C] Explains the DLC of the CAN Message along with the Number of Links mapped. The DLC and the Number of Links can be different based on the amount of Signals, their respective Byte Positions, and the Signal byte width.

D] The specified Signal ID used in the 'Command' CAN Message.

E] The Byte Position of the above Signal ID.