tests/signals-generated.cpp

   1 #include <binding/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 extern "C" {
  33 CTLP_CAPI_REGISTER("example");
  34
  35 std::shared_ptr<message_set_t> cms = 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{"can0",0x128,"ECM_z_5D2",8,0,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                                         static_cast<sign_t>(0),// signed
  58                                         -1,// bit_sign_position
  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                                         static_cast<sign_t>(0),// signed
  86                                         -1,// bit_sign_position
  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                                         decoder_t::gnedSteeringWheelAngle,// decoder
 104                                         nullptr,// encoder
 105                                         false,// received
 106                                         std::make_pair<bool, int>(false, 0),// multiplex
 107                                         static_cast<sign_t>(0),// signed
 108                                         -1,// bit_sign_position
 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                                         decoder_t::der,// decoder
 126                                         nullptr,// encoder
 127                                         false,// received
 128                                         std::make_pair<bool, int>(false, 0),// multiplex
 129                                         static_cast<sign_t>(0),// signed
 130                                         -1,// bit_sign_position
 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                                         decoder_t::der,// decoder
 148                                         nullptr,// encoder
 149                                         false,// received
 150                                         std::make_pair<bool, int>(false, 0),// multiplex
 151                                         static_cast<sign_t>(0),// signed
 152                                         -1,// bit_sign_position
 153                                         ""// unit
 154                                 })}
 155                         } // end signals vector
 156                 })} // end message_definition entry
 157 ,               {std::make_shared<message_definition_t>(message_definition_t{"can0",0x813,"ECM_z_5D2",8,0,frequency_clock_t(5.00000f),true,
 158                         { // beginning signals vector
 159                                 {std::make_shared<signal_t> (signal_t{
 160                                         "abc",// generic_name
 161                                         52,// bit_position
 162                                         12,// bit_size
 163                                         0.153920f,// 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::gnedSteeringWheelAngle,// decoder
 174                                         nullptr,// encoder
 175                                         false,// received
 176                                         std::make_pair<bool, int>(false, 0),// multiplex
 177                                         static_cast<sign_t>(0),// signed
 178                                         -1,// bit_sign_position
 179                                         ""// unit
 180                                 })},
 181                                 {std::make_shared<signal_t> (signal_t{
 182                                         "def",// generic_name
 183                                         52,// bit_position
 184                                         12,// bit_size
 185                                         1.00000f,// factor
 186                                         0.00000f,// offset
 187                                         0,// min_value
 188                                         0,// max_value
 189                                         frequency_clock_t(0.00000f),// frequency
 190                                         true,// send_same
 191                                         false,// force_send_changed
 192                                         {
 193                                         },// states
 194                                         false,// writable
 195                                         decoder_t::ignoreDecoder,// decoder
 196                                         nullptr,// encoder
 197                                         false,// received
 198                                         std::make_pair<bool, int>(false, 0),// multiplex
 199                                         static_cast<sign_t>(0),// signed
 200                                         -1,// bit_sign_position
 201                                         ""// unit
 202                                 })}
 203                         } // end signals vector
 204                 })} // end message_definition entry
 205         }, // end message_definition vector
 206         { // beginning diagnostic_messages_ vector
 207                 {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 208                         12,
 209                         "",
 210                         0,
 211                         0,
 212                         UNIT::INVALID,
 213                         1.00000f,
 214                         decoder_t::Pid,
 215                         nullptr,
 216                         true,
 217                         false
 218                 })}
 219 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 220                         12,
 221                         "",
 222                         0,
 223                         0,
 224                         UNIT::INVALID,
 225                         1.00000f,
 226                         nullptr,
 227                         nullptr,
 228                         true,
 229                         false
 230                 })}
 231 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 232                         6,
 233                         "",
 234                         0,
 235                         0,
 236                         UNIT::INVALID,
 237                         1.00000f,
 238                         decoder_t::agRequest,
 239                         nullptr,
 240                         true,
 241                         false
 242                 })}
 243
 244         } // end diagnostic_messages_ vector
 245 }); // end message_set entry
 246
 247 CTLP_ONLOAD(plugin, handle) {
 248         afb_api_t api = (afb_api_t) plugin->api;
 249         CtlConfigT* CtlConfig = (CtlConfigT*) afb_api_get_userdata(api);
 250         application_t* app = (application_t*) getExternalData(CtlConfig);
 251
 252         return app->add_message_set(cms);
 253 }
 254
 255
 256 }
 257