examples/basic/application-generated.cpp

   1 #include "application.hpp"
   2 #include "../can/can-decoder.hpp"
   3 #include "../can/can-encoder.hpp"
   4
   5
   6 // >>>>> handlers.cpp >>>>>
   7 #include "can/canread.h"
   8
   9 using openxc::can::read::publishNumericalMessage;
  10
  11 void handleSteeringWheelMessage(CanMessage* message,
  12         CanSignal* signals, int signalCount, Pipeline* pipeline) {
  13     publishNumericalMessage("latitude", 42.0, pipeline);
  14 }
  15
  16 openxc_DynamicField handleInverted(CanSignal* signal, CanSignal* signals,
  17         int signalCount, float value, bool* send) {
  18     return openxc::payload::wrapNumber(value * -1);
  19 }
  20
  21 void initializeMyStuff() { }
  22
  23 void initializeOtherStuff() { }
  24
  25 void myLooper() {
  26     // this function will be called once, each time through the main loop, after
  27     // all CAN message processing has been completed
  28 }
  29
  30 // <<<<< handlers.cpp <<<<<
  31
  32 application_t::application_t()
  33         : can_bus_manager_{utils::config_parser_t{"/etc/dev-mapping.conf"}}
  34         , message_set_{
  35                 {std::make_shared<message_set_t>(message_set_t{0,"example",
  36                         { // beginning message_definition_ vector
  37                                 {std::make_shared<message_definition_t>(message_definition_t{"hs", 0x128,"ECM_z_5D2", 0, false, message_format_t::STANDARD, frequency_clock_t(5.00000f), true,
  38                                         { // beginning signals vector
  39                                                 {std::make_shared<signal_t> (signal_t{
  40                                                         "engine_speed",// generic_name
  41                                                         12,// bit_position
  42                                                         8,// bit_size
  43                                                         1.00000f,// factor
  44                                                         0.00000f,// offset
  45                                                         0,// min_value
  46                                                         0,// max_value
  47                                                         frequency_clock_t(15.0000f),// frequency
  48                                                         true,// send_same
  49                                                         false,// force_send_changed
  50                                                         {
  51                                                         },// states
  52                                                         false,// writable
  53                                                         nullptr,// decoder
  54                                                         nullptr,// encoder
  55                                                         false,// received
  56                                                         std::make_pair<bool, int>(false, 0),// multiplex
  57                                                         0,// is_big_endian
  58                                                         0,// is_signed
  59                                                         ""// unit
  60                                                 })},
  61                                                 {std::make_shared<signal_t> (signal_t{
  62                                                         "GearshiftPosition",// generic_name
  63                                                         41,// bit_position
  64                                                         3,// bit_size
  65                                                         1.00000f,// factor
  66                                                         0.00000f,// offset
  67                                                         0,// min_value
  68                                                         0,// max_value
  69                                                         frequency_clock_t(0.00000f),// frequency
  70                                                         true,// send_same
  71                                                         false,// force_send_changed
  72                                                         {
  73                                                                 {1,"FIRST"},
  74                                                                 {4,"FOURTH"},
  75                                                                 {6,"NEUTRAL"},
  76                                                                 {5,"REVERSE"},
  77                                                                 {2,"SECOND"},
  78                                                                 {3,"THIRD"}
  79                                                         },// states
  80                                                         false,// writable
  81                                                         decoder_t::decode_state,// decoder
  82                                                         nullptr,// encoder
  83                                                         false,// received
  84                                                         std::make_pair<bool, int>(false, 0),// multiplex
  85                                                         0,// is_big_endian
  86                                                         0,// is_signed
  87                                                         ""// unit
  88                                                 })},
  89                                                 {std::make_shared<signal_t> (signal_t{
  90                                                         "SteeringWheelAngle",// generic_name
  91                                                         52,// bit_position
  92                                                         12,// bit_size
  93                                                         0.153920f,// factor
  94                                                         0.00000f,// offset
  95                                                         0,// min_value
  96                                                         0,// max_value
  97                                                         frequency_clock_t(0.00000f),// frequency
  98                                                         true,// send_same
  99                                                         false,// force_send_changed
 100                                                         {
 101                                                         },// states
 102                                                         false,// writable
 103                                                         handleUnsignedSteeringWheelAngle,// decoder
 104                                                         nullptr,// encoder
 105                                                         false,// received
 106                                                         std::make_pair<bool, int>(false, 0),// multiplex
 107                                                         0,// is_big_endian
 108                                                         0,// is_signed
 109                                                         ""// unit
 110                                                 })},
 111                                                 {std::make_shared<signal_t> (signal_t{
 112                                                         "steering_wheel_angle_error",// generic_name
 113                                                         44,// bit_position
 114                                                         12,// bit_size
 115                                                         1.00000f,// factor
 116                                                         0.00000f,// offset
 117                                                         0,// min_value
 118                                                         0,// max_value
 119                                                         frequency_clock_t(0.00000f),// frequency
 120                                                         true,// send_same
 121                                                         false,// force_send_changed
 122                                                         {
 123                                                         },// states
 124                                                         false,// writable
 125                                                         ignoreDecoder,// decoder
 126                                                         nullptr,// encoder
 127                                                         false,// received
 128                                                         std::make_pair<bool, int>(false, 0),// multiplex
 129                                                         0,// is_big_endian
 130                                                         0,// is_signed
 131                                                         ""// unit
 132                                                 })},
 133                                                 {std::make_shared<signal_t> (signal_t{
 134                                                         "steering_angle_sign",// generic_name
 135                                                         52,// bit_position
 136                                                         12,// bit_size
 137                                                         1.00000f,// factor
 138                                                         0.00000f,// offset
 139                                                         0,// min_value
 140                                                         0,// max_value
 141                                                         frequency_clock_t(0.00000f),// frequency
 142                                                         true,// send_same
 143                                                         false,// force_send_changed
 144                                                         {
 145                                                         },// states
 146                                                         false,// writable
 147                                                         ignoreDecoder,// decoder
 148                                                         nullptr,// encoder
 149                                                         false,// received
 150                                                         std::make_pair<bool, int>(false, 0),// multiplex
 151                                                         0,// is_big_endian
 152                                                         0,// is_signed
 153                                                         ""// unit
 154                                                 })}
 155                                         } // end signals vector
 156                                 })} // end message_definition entry
 157
 158                 }, // end message_definition vector
 159                         { // beginning diagnostic_messages_ vector
 160                                 {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 161                                         12,
 162                                         "",
 163                                         0,
 164                                         0,
 165                                         UNIT::INVALID,
 166                                         1.00000f,
 167                                         handleObd2Pid,
 168                                         nullptr,
 169                                         true,
 170                                         false
 171                                 })}
 172 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 173                                         12,
 174                                         "",
 175                                         0,
 176                                         0,
 177                                         UNIT::INVALID,
 178                                         1.00000f,
 179                                         nullptr,
 180                                         nullptr,
 181                                         true,
 182                                         false
 183                                 })}
 184 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 185                                         6,
 186                                         "",
 187                                         0,
 188                                         0,
 189                                         UNIT::INVALID,
 190                                         1.00000f,
 191                                         handleMyDiagRequest,
 192                                         nullptr,
 193                                         true,
 194                                         false
 195                                 })}
 196
 197                         } // end diagnostic_messages_ vector
 198                 })} // end message_set entry
 199         } // end message_set vector
 200 {
 201         for(std::shared_ptr<message_set_t> cms: message_set_)
 202         {
 203                 vect_ptr_msg_def_t messages_definition = cms->get_messages_definition();
 204                 for(std::shared_ptr<message_definition_t> cmd : messages_definition)
 205                 {
 206                         cmd->set_parent(cms);
 207                         std::vector<std::shared_ptr<signal_t>> signals = cmd->get_signals();
 208                         for(std::shared_ptr<signal_t> sig: signals)
 209                         {
 210                                 sig->set_parent(cmd);
 211                         }
 212                 }
 213
 214                 std::vector<std::shared_ptr<diagnostic_message_t>> diagnostic_messages = cms->get_diagnostic_messages();
 215                 for(std::shared_ptr<diagnostic_message_t> dm : diagnostic_messages)
 216                 {
 217                         dm->set_parent(cms);
 218                 }
 219         }
 220                 }
 221
 222 const std::string application_t::get_diagnostic_bus() const
 223 {
 224         return "hs";
 225 }
 226
 227