examples/basic/application-generated.cpp

   1 #include "application.hpp"
   2 #include "../can/can-decoder.hpp"
   3 #include "../can/can-encoder.hpp"
   4
   5 #include "can/canread.h"
   6
   7 using openxc::can::read::publishNumericalMessage;
   8
   9 void handleSteeringWheelMessage(CanMessage* message,
  10         CanSignal* signals, int signalCount, Pipeline* pipeline) {
  11     publishNumericalMessage("latitude", 42.0, pipeline);
  12 }
  13
  14 openxc_DynamicField handleInverted(CanSignal* signal, CanSignal* signals,
  15         int signalCount, float value, bool* send) {
  16     return openxc::payload::wrapNumber(value * -1);
  17 }
  18
  19 void initializeMyStuff() { }
  20
  21 void initializeOtherStuff() { }
  22
  23 void myLooper() {
  24     // this function will be called once, each time through the main loop, after
  25     // all CAN message processing has been completed
  26 }
  27
  28 // >>>>> handlers.cpp >>>>>
  29 #include "can/canread.h"
  30
  31 using openxc::can::read::publishNumericalMessage;
  32
  33 void handleSteeringWheelMessage(CanMessage* message,
  34         CanSignal* signals, int signalCount, Pipeline* pipeline) {
  35     publishNumericalMessage("latitude", 42.0, pipeline);
  36 }
  37
  38 openxc_DynamicField handleInverted(CanSignal* signal, CanSignal* signals,
  39         int signalCount, float value, bool* send) {
  40     return openxc::payload::wrapNumber(value * -1);
  41 }
  42
  43 void initializeMyStuff() { }
  44
  45 void initializeOtherStuff() { }
  46
  47 void myLooper() {
  48     // this function will be called once, each time through the main loop, after
  49     // all CAN message processing has been completed
  50 }
  51
  52 // <<<<< handlers.cpp <<<<<
  53
  54 application_t::application_t()
  55         : can_bus_manager_{utils::config_parser_t{"/etc/dev-mapping.conf"}}
  56         , message_set_{
  57                 {std::make_shared<message_set_t>(message_set_t{0,"example",
  58                         { // beginning message_definition_ vector
  59                                 {std::make_shared<message_definition_t>(message_definition_t{"hs",0x128,"ECM_z_5D2",8,0,true,frequency_clock_t(5.00000f),true,
  60                                         { // beginning signals vector
  61                                                 {std::make_shared<signal_t> (signal_t{
  62                                                         "engine_speed",// generic_name
  63                                                         12,// bit_position
  64                                                         8,// bit_size
  65                                                         1.00000f,// factor
  66                                                         0.00000f,// offset
  67                                                         0,// min_value
  68                                                         0,// max_value
  69                                                         frequency_clock_t(15.0000f),// frequency
  70                                                         true,// send_same
  71                                                         false,// force_send_changed
  72                                                         {
  73                                                         },// states
  74                                                         false,// writable
  75                                                         nullptr,// decoder
  76                                                         nullptr,// encoder
  77                                                         false,// received
  78                                                         std::make_pair<bool, int>(false, 0),// multiplex
  79                                                         false,// is_big_endian
  80                                                         static_cast<sign_t>(0),// signed
  81                                                         -1,// bit_sign_position
  82                                                         ""// unit
  83                                                 })},
  84                                                 {std::make_shared<signal_t> (signal_t{
  85                                                         "GearshiftPosition",// generic_name
  86                                                         41,// bit_position
  87                                                         3,// bit_size
  88                                                         1.00000f,// factor
  89                                                         0.00000f,// offset
  90                                                         0,// min_value
  91                                                         0,// max_value
  92                                                         frequency_clock_t(0.00000f),// frequency
  93                                                         true,// send_same
  94                                                         false,// force_send_changed
  95                                                         {
  96                                                                 {1,"FIRST"},
  97                                                                 {4,"FOURTH"},
  98                                                                 {6,"NEUTRAL"},
  99                                                                 {5,"REVERSE"},
 100                                                                 {2,"SECOND"},
 101                                                                 {3,"THIRD"}
 102                                                         },// states
 103                                                         false,// writable
 104                                                         decoder_t::decode_state,// decoder
 105                                                         nullptr,// encoder
 106                                                         false,// received
 107                                                         std::make_pair<bool, int>(false, 0),// multiplex
 108                                                         false,// is_big_endian
 109                                                         static_cast<sign_t>(0),// signed
 110                                                         -1,// bit_sign_position
 111                                                         ""// unit
 112                                                 })},
 113                                                 {std::make_shared<signal_t> (signal_t{
 114                                                         "SteeringWheelAngle",// generic_name
 115                                                         52,// bit_position
 116                                                         12,// bit_size
 117                                                         0.153920f,// factor
 118                                                         0.00000f,// offset
 119                                                         0,// min_value
 120                                                         0,// max_value
 121                                                         frequency_clock_t(0.00000f),// frequency
 122                                                         true,// send_same
 123                                                         false,// force_send_changed
 124                                                         {
 125                                                         },// states
 126                                                         false,// writable
 127                                                         decoder_t::v1_to_v2_gnedSteeringWheelAngle,// decoder
 128                                                         nullptr,// encoder
 129                                                         false,// received
 130                                                         std::make_pair<bool, int>(false, 0),// multiplex
 131                                                         false,// is_big_endian
 132                                                         static_cast<sign_t>(0),// signed
 133                                                         -1,// bit_sign_position
 134                                                         ""// unit
 135                                                 })},
 136                                                 {std::make_shared<signal_t> (signal_t{
 137                                                         "steering_wheel_angle_error",// generic_name
 138                                                         44,// bit_position
 139                                                         12,// bit_size
 140                                                         1.00000f,// factor
 141                                                         0.00000f,// offset
 142                                                         0,// min_value
 143                                                         0,// max_value
 144                                                         frequency_clock_t(0.00000f),// frequency
 145                                                         true,// send_same
 146                                                         false,// force_send_changed
 147                                                         {
 148                                                         },// states
 149                                                         false,// writable
 150                                                         decoder_t::v1_to_v2_der,// decoder
 151                                                         nullptr,// encoder
 152                                                         false,// received
 153                                                         std::make_pair<bool, int>(false, 0),// multiplex
 154                                                         false,// is_big_endian
 155                                                         static_cast<sign_t>(0),// signed
 156                                                         -1,// bit_sign_position
 157                                                         ""// unit
 158                                                 })},
 159                                                 {std::make_shared<signal_t> (signal_t{
 160                                                         "steering_angle_sign",// generic_name
 161                                                         52,// bit_position
 162                                                         12,// bit_size
 163                                                         1.00000f,// factor
 164                                                         0.00000f,// offset
 165                                                         0,// min_value
 166                                                         0,// max_value
 167                                                         frequency_clock_t(0.00000f),// frequency
 168                                                         true,// send_same
 169                                                         false,// force_send_changed
 170                                                         {
 171                                                         },// states
 172                                                         false,// writable
 173                                                         decoder_t::v1_to_v2_der,// decoder
 174                                                         nullptr,// encoder
 175                                                         false,// received
 176                                                         std::make_pair<bool, int>(false, 0),// multiplex
 177                                                         false,// is_big_endian
 178                                                         static_cast<sign_t>(0),// signed
 179                                                         -1,// bit_sign_position
 180                                                         ""// unit
 181                                                 })}
 182                                         } // end signals vector
 183                                 })} // end message_definition entry
 184
 185                 }, // end message_definition vector
 186                         { // beginning diagnostic_messages_ vector
 187                                 {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 188                                         12,
 189                                         "",
 190                                         0,
 191                                         0,
 192                                         UNIT::INVALID,
 193                                         1.00000f,
 194                                         decoder_t::v1_to_v2_Pid,
 195                                         nullptr,
 196                                         true,
 197                                         false
 198                                 })}
 199 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 200                                         12,
 201                                         "",
 202                                         0,
 203                                         0,
 204                                         UNIT::INVALID,
 205                                         1.00000f,
 206                                         nullptr,
 207                                         nullptr,
 208                                         true,
 209                                         false
 210                                 })}
 211 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 212                                         6,
 213                                         "",
 214                                         0,
 215                                         0,
 216                                         UNIT::INVALID,
 217                                         1.00000f,
 218                                         decoder_t::v1_to_v2_agRequest,
 219                                         nullptr,
 220                                         true,
 221                                         false
 222                                 })}
 223
 224                         } // end diagnostic_messages_ vector
 225                 })} // end message_set entry
 226         } // end message_set vector
 227 {
 228         for(std::shared_ptr<message_set_t> cms: message_set_)
 229         {
 230                 std::vector<std::shared_ptr<message_definition_t>> messages_definition = cms->get_messages_definition();
 231                 for(std::shared_ptr<message_definition_t> cmd : messages_definition)
 232                 {
 233                         cmd->set_parent(cms);
 234                         std::vector<std::shared_ptr<signal_t>> signals = cmd->get_signals();
 235                         for(std::shared_ptr<signal_t> sig: signals)
 236                         {
 237                                 sig->set_parent(cmd);
 238                         }
 239                 }
 240
 241                 std::vector<std::shared_ptr<diagnostic_message_t>> diagnostic_messages = cms->get_diagnostic_messages();
 242                 for(std::shared_ptr<diagnostic_message_t> dm : diagnostic_messages)
 243                 {
 244                         dm->set_parent(cms);
 245                 }
 246         }
 247                 }
 248
 249 const std::string application_t::get_diagnostic_bus() const
 250 {
 251         return "hs";
 252 }
 253
 254
 255 openxc_DynamicField decoder_t::v1_to_v2_gnedSteeringWheelAngle(signal_t& signal, std::shared_ptr<message_t> message, bool* send){
 256         float value = decoder_t::parse_signal_bitfield(signal, message);
 257         openxc_DynamicField ret = decoder_t::gnedSteeringWheelAngle(signal, value, send);
 258         if ((signal.get_last_value() == value && !signal.get_send_same()) || !*send ){
 259                 *send = false;
 260         }
 261         signal.set_last_value(value);
 262         return ret;
 263 }
 264
 265 openxc_DynamicField decoder_t::v1_to_v2_der(signal_t& signal, std::shared_ptr<message_t> message, bool* send){
 266         float value = decoder_t::parse_signal_bitfield(signal, message);
 267         openxc_DynamicField ret = decoder_t::der(signal, value, send);
 268         if ((signal.get_last_value() == value && !signal.get_send_same()) || !*send ){
 269                 *send = false;
 270         }
 271         signal.set_last_value(value);
 272         return ret;
 273 }
 274
 275 openxc_DynamicField decoder_t::v1_to_v2_Pid(signal_t& signal, std::shared_ptr<message_t> message, bool* send){
 276         float value = decoder_t::parse_signal_bitfield(signal, message);
 277         openxc_DynamicField ret = decoder_t::Pid(signal, value, send);
 278         if ((signal.get_last_value() == value && !signal.get_send_same()) || !*send ){
 279                 *send = false;
 280         }
 281         signal.set_last_value(value);
 282         return ret;
 283 }
 284
 285 openxc_DynamicField decoder_t::v1_to_v2_agRequest(signal_t& signal, std::shared_ptr<message_t> message, bool* send){
 286         float value = decoder_t::parse_signal_bitfield(signal, message);
 287         openxc_DynamicField ret = decoder_t::agRequest(signal, value, send);
 288         if ((signal.get_last_value() == value && !signal.get_send_same()) || !*send ){
 289                 *send = false;
 290         }
 291         signal.set_last_value(value);
 292         return ret;
 293 }
 294