src/can-message.hpp

   1 /*
   2  * Copyright (C) 2015, 2016 "IoT.bzh"
   3  * Author "Romain Forlot" <romain.forlot@iot.bzh>
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *       http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #pragma once
  19
  20 #include <string>
  21 #include <cstdint>
  22 #include <linux/can.h>
  23
  24 #include "timer.hpp"
  25
  26 #define CAN_MESSAGE_SIZE 8
  27
  28 /**
  29  * @enum CanMessageFormat
  30  * @brief The ID format for a CAN message.
  31  */
  32 enum CanMessageFormat {
  33         STANDARD, /*!< STANDARD - standard 11-bit CAN arbitration ID. */
  34         EXTENDED, /*!< EXTENDED - an extended frame, with a 29-bit arbitration ID. */
  35         ERROR,    /*!< ERROR - ERROR code used at initialization to signify that it isn't usable'*/
  36 };
  37 typedef enum CanMessageFormat CanMessageFormat;
  38
  39 /**
  40  * @class can_message_t
  41  *
  42  * @brief A compact representation of a single CAN message, meant to be used in in/out
  43  * buffers.
  44  */
  45
  46 /*************************
  47  * old CanMessage struct *
  48  *************************
  49 struct CanMessage {
  50         uint32_t id;
  51         CanMessageFormat format;
  52         uint8_t data[CAN_MESSAGE_SIZE];
  53         uint8_t length;
  54 };
  55 typedef struct CanMessage CanMessage;
  56 */
  57 class can_message_t {
  58         private:
  59                 uint32_t id_; /*!< uint32_t id - The ID of the message. */
  60                 bool rtr_flag_; /*!< bool rtr_flag - Telling if the frame has RTR flag positionned. Then frame hasn't data field*/
  61                 uint8_t length_; /*!<  uint8_t length - the length of the data array (max 8). */
  62                 uint8_t flags_; /*!< unint8_t flags of a CAN FD frame. Needed if we catch FD frames.*/
  63                 CanMessageFormat format_; /*!< CanMessageFormat format - the format of the message's ID.*/
  64                 uint8_t data_[CAN_MESSAGE_SIZE]; /*!< uint8_t data  - The message's data field with a size of 8 which is the standard about CAN bus messages.*/
  65
  66                 uint8_t maxdlen_;
  67
  68         public:
  69                 /**
  70                  * @brief Class constructor
  71                  *
  72                  * Constructor about can_message_t class.
  73                  */
  74                 can_message_t();
  75
  76                 /**
  77                  * @brief Retrieve id_ member value.
  78                  *
  79                  * @return uint32_t id_ class member
  80                  */
  81                 uint32_t get_id() const;
  82
  83                 /**
  84                  * @brief Retrieve RTR flag member.
  85                  *
  86                  * @return bool rtr_flags_ class member
  87                  */
  88                 bool get_rtr_flag_() const;
  89
  90                 /**
  91                  * @brief Retrieve format_ member value.
  92                  *
  93                  * @return CanMessageFormat format_ class member
  94                  */
  95                 int get_format() const;
  96
  97                 /**
  98                  * @brief Retrieve format_ member value.
  99                  *
 100                  * @return CanMessageFormat format_ class member
 101                  */
 102                 uint8_t get_flags() const;
 103
 104                 /**
 105                  * @brief Retrieve data_ member value.
 106                  *
 107                  * @return uint8_t data_ pointer class member
 108                  */
 109                 const uint8_t* get_data() const;
 110
 111                 /**
 112                  * @brief Retrieve length_ member value.
 113                  *
 114                  * @return uint8_t length_ class member
 115                  */
 116                 uint8_t get_length() const;
 117
 118                 void set_max_data_length(const struct canfd_frame& frame);
 119
 120                 /**
 121                  * @brief Control whether the object is correctly initialized
 122                  *  to be sent over the CAN bus
 123                  *
 124                  * @return true if object correctly initialized and false if not...
 125                  */
 126                 bool is_correct_to_send();
 127
 128                 /**
 129                  * @brief Set id_ member value.
 130                  *
 131                  * Preferred way to initialize these members by using
 132                  * convert_from_canfd_frame method.
 133                  *
 134                  * @param uint32_t id_ class member
 135                  */
 136                 void set_id_and_format(const uint32_t new_id);
 137
 138                 /**
 139                  * @brief Set format_ member value.
 140                  *
 141                  * Preferred way to initialize these members by using
 142                  * convert_from_canfd_frame method.
 143                  *
 144                  * @param CanMessageFormat format_ class member
 145                  */
 146                 void set_format(const CanMessageFormat new_format);
 147
 148                 /**
 149                  * @brief Set format_ member value. Deducing from the can_id
 150                  *  of a canfd_frame.
 151                  *
 152                  * Preferred way to initialize these members by using
 153                  * convert_from_canfd_frame method.
 154                  *
 155                  * @param uint32_t can_id integer from a canfd_frame
 156                  */
 157                 void set_format(const uint32_t can_id);
 158
 159                 /**
 160                  * @brief Set format_ member value.
 161                  *
 162                  * Preferred way to initialize these members by using
 163                  * convert_from_canfd_frame method.
 164                  *
 165                  * @param CanMessageFormat format_ class member
 166                  */
 167                 void set_flags(const uint8_t flags);
 168
 169                 /**
 170                  * @brief Set data_ member value.
 171                  *
 172                  * Preferred way to initialize these members by using
 173                  * convert_from_canfd_frame method.
 174                  *
 175                  * @param uint8_t data_ array with a max size of 8 elements.
 176                  */
 177                 void set_data(const __u8 new_data[], size_t dlen);
 178
 179                 /**
 180                  * @brief Set length_ member value.
 181                  *
 182                  * Preferred way to initialize these members by using
 183                  * convert_from_canfd_frame method.
 184                  *
 185                  * @param uint8_t length_ array with a max size of 8 elements.
 186                  */
 187                 void set_length(const uint8_t new_length);
 188
 189                 /**
 190                  * @brief Take a canfd_frame struct to initialize class members
 191                  *
 192                  * This is the preferred way to initialize class members.
 193                  *
 194                  * @param canfd_frame struct read from can bus device.
 195                  */
 196                 void convert_from_canfd_frame(const struct canfd_frame& frame);
 197
 198                 /**
 199                  * @brief Take all initialized class's members and build an
 200                  * canfd_frame struct that can be use to send a CAN message over
 201                  * the bus.
 202                  *
 203                  * @return canfd_frame struct built from class members.
 204                  */
 205                 canfd_frame convert_to_canfd_frame();
 206 };
 207
 208 /**
 209  * @struct CanMessageDefinition
 210  *
 211  * @brief The definition of a CAN message. This includes a lot of metadata, so
 212  * to save memory this struct should not be used for storing incoming and
 213  * outgoing CAN messages.
 214  */
 215 struct CanMessageDefinition {
 216         //can_bus_dev_t bus; /*!< bus - A pointer to the bus this message is on. */
 217         uint32_t id; /*!<  id - The ID of the message.*/
 218         CanMessageFormat format; /*!< format - the format of the message's ID.*/
 219         FrequencyClock frequencyClock; /*!<  clock - an optional frequency clock to control the output of this
 220                                                                         *       message, if sent raw, or simply to mark the max frequency for custom
 221                                                                         *       handlers to retriec++ if ? syntaxve.*/
 222         bool forceSendChanged; /*!< forceSendChanged - If true, regardless of the frequency, it will send CAN
 223                                                         *       message if it has changed when using raw passthrough.*/
 224         uint8_t lastValue[CAN_MESSAGE_SIZE]; /*!< lastValue - The last received value of the message. Defaults to undefined.
 225                                                                                 *       This is required for the forceSendChanged functionality, as the stack
 226                                                                                 *       needs to compare an incoming CAN message with the previous frame.*/
 227 };
 228 typedef struct CanMessageDefinition CanMessageDefinition;
 229
 230 /**
 231  * @struct CanMessageSet
 232  *
 233  * @brief A parent wrapper for a particular set of CAN messages and associated
 234  *      CAN buses(e.g. a vehicle or program).
 235  */
 236  typedef struct {
 237         uint8_t index; /*!<index - A numerical ID for the message set, ideally the index in an array
 238                                         *       for fast lookup*/
 239         const std::string name; /*!< name - The name of the message set.*/
 240         uint8_t busCount; /*!< busCount - The number of CAN buses defined for this message set.*/
 241         unsigned short messageCount; /*!< messageCount - The number of CAN messages (across all buses) defined for
 242                                                                         *       this message set.*/
 243         unsigned short signalCount; /*!< signalCount - The number of CAN signals (across all messages) defined for
 244                                                                 *       this message set.*/
 245         unsigned short commandCount; /*!< commandCount - The number of CanCommmands defined for this message set.*/
 246 } CanMessageSet;
 247
 248 /** Public: Return the currently active CAN configuration. */
 249 CanMessageSet* getActiveMessageSet();
 250
 251 /** Public: Retrive a list of all possible CAN configurations.
 252  *
 253  * Returns a pointer to an array of all configurations.
 254  */
 255 CanMessageSet* getMessageSets();
 256
 257 /** Public: Return the length of the array returned by getMessageSets() */
 258 int getMessageSetCount();
 259
 260 /* Public: Return an array of all CAN messages to be processed in the active
 261  * configuration.
 262  */
 263 CanMessageDefinition* getMessages();
 264
 265 /* Public: Return the length of the array returned by getMessages(). */
 266 int getMessageCount();