00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <interfaces/BatteryInterface.h>
00025
00026 #include <core/exceptions/software.h>
00027
00028 #include <cstring>
00029 #include <cstdlib>
00030
00031 namespace fawkes {
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044 BatteryInterface::BatteryInterface() : Interface()
00045 {
00046 data_size = sizeof(BatteryInterface_data_t);
00047 data_ptr = malloc(data_size);
00048 data = (BatteryInterface_data_t *)data_ptr;
00049 data_ts = (interface_data_ts_t *)data_ptr;
00050 memset(data_ptr, 0, data_size);
00051 add_fieldinfo(IFT_UINT32, "current", 1, &data->current);
00052 add_fieldinfo(IFT_UINT32, "voltage", 1, &data->voltage);
00053 add_fieldinfo(IFT_UINT32, "temperature", 1, &data->temperature);
00054 add_fieldinfo(IFT_FLOAT, "absolute_soc", 1, &data->absolute_soc);
00055 add_fieldinfo(IFT_FLOAT, "relative_soc", 1, &data->relative_soc);
00056 add_messageinfo("PushButtonMessage");
00057 add_messageinfo("SleepMessage");
00058 unsigned char tmp_hash[] = {0x28, 0xb6, 0xbe, 0xe7, 0xf1, 0x47, 0x2, 0x12, 0x1d, 0xe3, 0x7c, 0x14, 0xe9, 0x1f, 0x24, 0x4d};
00059 set_hash(tmp_hash);
00060 }
00061
00062
00063 BatteryInterface::~BatteryInterface()
00064 {
00065 free(data_ptr);
00066 }
00067
00068
00069
00070
00071
00072 uint32_t
00073 BatteryInterface::current() const
00074 {
00075 return data->current;
00076 }
00077
00078
00079
00080
00081
00082 size_t
00083 BatteryInterface::maxlenof_current() const
00084 {
00085 return 1;
00086 }
00087
00088
00089
00090
00091
00092 void
00093 BatteryInterface::set_current(const uint32_t new_current)
00094 {
00095 data->current = new_current;
00096 data_changed = true;
00097 }
00098
00099
00100
00101
00102
00103 uint32_t
00104 BatteryInterface::voltage() const
00105 {
00106 return data->voltage;
00107 }
00108
00109
00110
00111
00112
00113 size_t
00114 BatteryInterface::maxlenof_voltage() const
00115 {
00116 return 1;
00117 }
00118
00119
00120
00121
00122
00123 void
00124 BatteryInterface::set_voltage(const uint32_t new_voltage)
00125 {
00126 data->voltage = new_voltage;
00127 data_changed = true;
00128 }
00129
00130
00131
00132
00133
00134 uint32_t
00135 BatteryInterface::temperature() const
00136 {
00137 return data->temperature;
00138 }
00139
00140
00141
00142
00143
00144 size_t
00145 BatteryInterface::maxlenof_temperature() const
00146 {
00147 return 1;
00148 }
00149
00150
00151
00152
00153
00154 void
00155 BatteryInterface::set_temperature(const uint32_t new_temperature)
00156 {
00157 data->temperature = new_temperature;
00158 data_changed = true;
00159 }
00160
00161
00162
00163
00164
00165 float
00166 BatteryInterface::absolute_soc() const
00167 {
00168 return data->absolute_soc;
00169 }
00170
00171
00172
00173
00174
00175 size_t
00176 BatteryInterface::maxlenof_absolute_soc() const
00177 {
00178 return 1;
00179 }
00180
00181
00182
00183
00184
00185 void
00186 BatteryInterface::set_absolute_soc(const float new_absolute_soc)
00187 {
00188 data->absolute_soc = new_absolute_soc;
00189 data_changed = true;
00190 }
00191
00192
00193
00194
00195
00196 float
00197 BatteryInterface::relative_soc() const
00198 {
00199 return data->relative_soc;
00200 }
00201
00202
00203
00204
00205
00206 size_t
00207 BatteryInterface::maxlenof_relative_soc() const
00208 {
00209 return 1;
00210 }
00211
00212
00213
00214
00215
00216 void
00217 BatteryInterface::set_relative_soc(const float new_relative_soc)
00218 {
00219 data->relative_soc = new_relative_soc;
00220 data_changed = true;
00221 }
00222
00223
00224 Message *
00225 BatteryInterface::create_message(const char *type) const
00226 {
00227 if ( strncmp("PushButtonMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00228 return new PushButtonMessage();
00229 } else if ( strncmp("SleepMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00230 return new SleepMessage();
00231 } else {
00232 throw UnknownTypeException("The given type '%s' does not match any known "
00233 "message type for this interface type.", type);
00234 }
00235 }
00236
00237
00238
00239
00240
00241 void
00242 BatteryInterface::copy_values(const Interface *other)
00243 {
00244 const BatteryInterface *oi = dynamic_cast<const BatteryInterface *>(other);
00245 if (oi == NULL) {
00246 throw TypeMismatchException("Can only copy values from interface of same type (%s vs. %s)",
00247 type(), other->type());
00248 }
00249 memcpy(data, oi->data, sizeof(BatteryInterface_data_t));
00250 }
00251
00252 const char *
00253 BatteryInterface::enum_tostring(const char *enumtype, int val) const
00254 {
00255 throw UnknownTypeException("Unknown enum type %s", enumtype);
00256 }
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267 BatteryInterface::PushButtonMessage::PushButtonMessage() : Message("PushButtonMessage")
00268 {
00269 data_size = sizeof(PushButtonMessage_data_t);
00270 data_ptr = malloc(data_size);
00271 memset(data_ptr, 0, data_size);
00272 data = (PushButtonMessage_data_t *)data_ptr;
00273 data_ts = (message_data_ts_t *)data_ptr;
00274 }
00275
00276
00277 BatteryInterface::PushButtonMessage::~PushButtonMessage()
00278 {
00279 free(data_ptr);
00280 }
00281
00282
00283
00284
00285 BatteryInterface::PushButtonMessage::PushButtonMessage(const PushButtonMessage *m) : Message("PushButtonMessage")
00286 {
00287 data_size = m->data_size;
00288 data_ptr = malloc(data_size);
00289 memcpy(data_ptr, m->data_ptr, data_size);
00290 data = (PushButtonMessage_data_t *)data_ptr;
00291 data_ts = (message_data_ts_t *)data_ptr;
00292 }
00293
00294
00295
00296
00297
00298
00299
00300 Message *
00301 BatteryInterface::PushButtonMessage::clone() const
00302 {
00303 return new BatteryInterface::PushButtonMessage(this);
00304 }
00305
00306
00307
00308
00309
00310
00311
00312
00313 BatteryInterface::SleepMessage::SleepMessage() : Message("SleepMessage")
00314 {
00315 data_size = sizeof(SleepMessage_data_t);
00316 data_ptr = malloc(data_size);
00317 memset(data_ptr, 0, data_size);
00318 data = (SleepMessage_data_t *)data_ptr;
00319 data_ts = (message_data_ts_t *)data_ptr;
00320 }
00321
00322
00323 BatteryInterface::SleepMessage::~SleepMessage()
00324 {
00325 free(data_ptr);
00326 }
00327
00328
00329
00330
00331 BatteryInterface::SleepMessage::SleepMessage(const SleepMessage *m) : Message("SleepMessage")
00332 {
00333 data_size = m->data_size;
00334 data_ptr = malloc(data_size);
00335 memcpy(data_ptr, m->data_ptr, data_size);
00336 data = (SleepMessage_data_t *)data_ptr;
00337 data_ts = (message_data_ts_t *)data_ptr;
00338 }
00339
00340
00341
00342
00343
00344
00345
00346 Message *
00347 BatteryInterface::SleepMessage::clone() const
00348 {
00349 return new BatteryInterface::SleepMessage(this);
00350 }
00351
00352
00353
00354
00355 bool
00356 BatteryInterface::message_valid(const Message *message) const
00357 {
00358 const PushButtonMessage *m0 = dynamic_cast<const PushButtonMessage *>(message);
00359 if ( m0 != NULL ) {
00360 return true;
00361 }
00362 const SleepMessage *m1 = dynamic_cast<const SleepMessage *>(message);
00363 if ( m1 != NULL ) {
00364 return true;
00365 }
00366 return false;
00367 }
00368
00369
00370 EXPORT_INTERFACE(BatteryInterface)
00371
00372
00373
00374 }