tests/generated.cpp

   1 #include "application.hpp"
   2 #include "can/can-decoder.hpp"
   3
   4
   5 // >>>>> handlers.cpp >>>>>
   6 #include "can/canread.h"
   7
   8 using openxc::can::read::publishNumericalMessage;
   9
  10 void handleSteeringWheelMessage(CanMessage* message,
  11         CanSignal* signals, int signalCount, Pipeline* pipeline) {
  12     publishNumericalMessage("latitude", 42.0, pipeline);
  13 }
  14
  15 openxc_DynamicField handleInverted(CanSignal* signal, CanSignal* signals,
  16         int signalCount, float value, bool* send) {
  17     return openxc::payload::wrapNumber(value * -1);
  18 }
  19
  20 void initializeMyStuff() { }
  21
  22 void initializeOtherStuff() { }
  23
  24 void myLooper() {
  25     // this function will be called once each time through the main loop, after
  26     // all CAN message processing has been completed
  27 }
  28
  29 // <<<<< handlers.cpp <<<<<
  30
  31 application_t::application_t()
  32         : can_message_set_{0, "example", 2, 2, 7, 1, 3}
  33         , can_message_definition_
  34         {
  35                 {
  36                         can_message_definition_t(0, "can0", 0x128, can_message_format_t::STANDARD, frequency_clock_t(0.00000f), true),
  37                         can_message_definition_t(0, "can0", 0x813, can_message_format_t::STANDARD, frequency_clock_t(0.00000f), true)
  38                 }
  39         }
  40         , can_signals_
  41         {
  42                 {
  43                         {
  44                                 0,
  45                                 0,
  46                                 "engine_speed",
  47                                 12,
  48                                 8,
  49                                 1.00000,
  50                                 0,
  51                                 0,
  52                                 0,
  53                                 frequency_clock_t(15.0000f),
  54                                 true,
  55                                 false,
  56                                 {
  57                                 },
  58                                 false,
  59                                 nullptr,
  60                                 nullptr,
  61                                 false
  62                         },
  63                         {
  64                                 0,
  65                                 0,
  66                                 "GearshiftPosition",
  67                                 41,
  68                                 3,
  69                                 1.00000,
  70                                 0,
  71                                 0,
  72                                 0,
  73                                 frequency_clock_t(0.00000f),
  74                                 true,
  75                                 false,
  76                                 {
  77                                         {1, "FIRST"},
  78                                         {4, "FOURTH"},
  79                                         {6, "NEUTRAL"},
  80                                         {5, "REVERSE"},
  81                                         {2, "SECOND"},
  82                                         {3, "THIRD"}
  83                                 },
  84                                 false,
  85                                 nullptr,
  86                                 nullptr,
  87                                 false
  88                         },
  89                         {
  90                                 0,
  91                                 0,
  92                                 "SteeringWheelAngle",
  93                                 52,
  94                                 12,
  95                                 0.153920,
  96                                 0,
  97                                 0,
  98                                 0,
  99                                 frequency_clock_t(0.00000f),
 100                                 true,
 101                                 false,
 102                                 {
 103                                 },
 104                                 false,
 105                                 handleUnsignedSteeringWheelAngle,
 106                                 nullptr,
 107                                 false
 108                         },
 109                         {
 110                                 0,
 111                                 0,
 112                                 "steering_wheel_angle_error",
 113                                 44,
 114                                 12,
 115                                 1.00000,
 116                                 0,
 117                                 0,
 118                                 0,
 119                                 frequency_clock_t(0.00000f),
 120                                 true,
 121                                 false,
 122                                 {
 123                                 },
 124                                 false,
 125                                 ignoreDecoder,
 126                                 nullptr,
 127                                 false
 128                         },
 129                         {
 130                                 0,
 131                                 0,
 132                                 "steering_angle_sign",
 133                                 52,
 134                                 12,
 135                                 1.00000,
 136                                 0,
 137                                 0,
 138                                 0,
 139                                 frequency_clock_t(0.00000f),
 140                                 true,
 141                                 false,
 142                                 {
 143                                 },
 144                                 false,
 145                                 ignoreDecoder,
 146                                 nullptr,
 147                                 false
 148                         }
 149                 },
 150                 {
 151                         {
 152                                 0,
 153                                 1,
 154                                 "abc",
 155                                 52,
 156                                 12,
 157                                 0.153920,
 158                                 0,
 159                                 0,
 160                                 0,
 161                                 frequency_clock_t(0.00000f),
 162                                 true,
 163                                 false,
 164                                 {
 165                                 },
 166                                 false,
 167                                 handleUnsignedSteeringWheelAngle,
 168                                 nullptr,
 169                                 false
 170                         },
 171                         {
 172                                 0,
 173                                 1,
 174                                 "def",
 175                                 52,
 176                                 12,
 177                                 1.00000,
 178                                 0,
 179                                 0,
 180                                 0,
 181                                 frequency_clock_t(0.00000f),
 182                                 true,
 183                                 false,
 184                                 {
 185                                 },
 186                                 false,
 187                                 decoder_t::ignoreDecoder,
 188                                 nullptr,
 189                                 false
 190                         }
 191                 }
 192         }
 193         //, obd2_signals_{/*...*/}
 194 {
 195 }
 196
 197