Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
IotMeterMsgCodec.cpp
00001 /* C027N/water-meter interface for Water Meter Demo 00002 * 00003 * Copyright (C) u-blox Melbourn Ltd 00004 * u-blox Melbourn Ltd, Melbourn, UK 00005 * 00006 * All rights reserved. 00007 * 00008 * This source file is the sole property of u-blox Melbourn Ltd. 00009 * Reproduction or utilization of this source in whole or part is 00010 * forbidden without the written consent of u-blox Melbourn Ltd. 00011 */ 00012 00013 /** 00014 * @file iot_meter_msg_handler.cpp 00015 * This file implements the API to the C027N/water-meter device 00016 * for the MWC demo 2015. 00017 */ 00018 00019 #include <stdint.h> 00020 #include <stdio.h> 00021 #include <stdarg.h> // for va_... 00022 #include <string.h> // for memcpy() 00023 #include <IotMeterApi.hpp> 00024 00025 #ifdef DEBUG 00026 #define MESSAGE_CODEC_LOGMSG(...) MessageCodec::logMsg(__VA_ARGS__) 00027 #else 00028 #define MESSAGE_CODEC_LOGMSG(...) 00029 #endif 00030 00031 // ---------------------------------------------------------------- 00032 // GENERAL COMPILE-TIME CONSTANTS 00033 // ---------------------------------------------------------------- 00034 00035 /// The max size of a debug message (including terminator) 00036 #define MAX_DEBUG_MESSAGE_LEN 128 00037 00038 // ---------------------------------------------------------------- 00039 // PRIVATE VARIABLES 00040 // ---------------------------------------------------------------- 00041 00042 void (*MessageCodec::mp_guiPrintToConsole) (const char*) = NULL; 00043 00044 // ---------------------------------------------------------------- 00045 // ON-AIR MESSAGE IDs 00046 // ---------------------------------------------------------------- 00047 00048 /// The message IDs in the downlink direction (i.e. to the 00049 // C027/water-meter device). Note that 'over the air' these 00050 // are cast into an uint8_t. 00051 typedef enum MsgIdDlTag_t 00052 { 00053 REBOOT_REQ_DL_MSG, //!< Reboot the C027N/water-meter 00054 //! device. 00055 SERIAL_NUMBER_GET_REQ_DL_MSG, //!< Get the serial number of the 00056 //! water-meter. 00057 READING_INTERVAL_SET_REQ_DL_MSG, //!< Set the rate at which readings 00058 //! are returned by the C027N/water-meter 00059 //! device. 00060 READING_INTERVAL_GET_REQ_DL_MSG, //!< Get the rate at which readings 00061 //! are returned by the C027N/water-meter 00062 //! device. 00063 GPIO_SET_REQ_DL_MSG, //!< Set the state of a GPIO on the 00064 //! C027N board. 00065 GPIO_GET_REQ_DL_MSG, //!< Get the state of a GPIO on the 00066 //! C027N board. 00067 LED_SET_REQ_DL_MSG, //!< Set the steady state of the red 00068 //! LED on the C027 board. 00069 LED_GET_REQ_DL_MSG, //!< Get the steady state of the red 00070 //! LED on the C027 board. 00071 FLASH_SET_REQ_DL_MSG, //!< Set the LED on the C027/water-meter 00072 //! device to flash when a reading is 00073 //! being sent (or not). 00074 FLASH_GET_REQ_DL_MSG, //!< Get whether the LED on the C027/ 00075 //! flashes when a mesage is 00076 //! being sent/received (or not). 00077 MAX_NUM_DL_MSGS //!< The maximum number of downlink 00078 //! messages. 00079 } MsgIdDl_t; 00080 00081 /// The message IDs in the uplink direction (i.e. from the 00082 // C027N/water-meter device). Note that 'over the air' these are 00083 // cast into an uint8_t. 00084 typedef enum MsgIdUlTag_t 00085 { 00086 INIT_IND_UL_MSG, //!< Power on of the C027N/water meter 00087 //! device has completed. 00088 SERIAL_NUMBER_IND_UL_MSG, //!< The serial number of the water meter. 00089 VOLUME_IND_UL_MSG, //!< The current water meter reading. 00090 RSSI_IND_UL_MSG, //!< The current RSSI reading from the 00091 //! radio module. 00092 SERIAL_NUMBER_GET_CNF_UL_MSG, //!< The serial number of the water-meter. 00093 READING_INTERVAL_SET_CNF_UL_MSG, //!< The rate at which readings are 00094 //! returned by the C027/water-meter device. 00095 READING_INTERVAL_GET_CNF_UL_MSG, //!< The rate at which readings are 00096 //! returned by the C027/water-meter device. 00097 GPIO_SET_CNF_UL_MSG, //!< The state of a GPIO on the C027 board. 00098 GPIO_GET_CNF_UL_MSG, //!< The state of a GPIO on the C027 board. 00099 LED_SET_CNF_UL_MSG, //!< The steady state of the red LED on 00100 //! the C027/water-meter device. 00101 LED_GET_CNF_UL_MSG, //!< The steady state of the red LED on 00102 //! the C027/water-meter device. 00103 FLASH_SET_CNF_UL_MSG, //!< Whether the LED on the C027/water 00104 //! meter device is set to flash when a 00105 //! message is being sent/received (or not). 00106 FLASH_GET_CNF_UL_MSG, //!< Whether the LED on the C027/water 00107 //! meter device is set to flash when a 00108 //! message is being sent/received (or not). 00109 MAX_NUM_UL_MSGS //!< The maximum number of uplink messages. 00110 } MsgIdUl_t; 00111 00112 // ---------------------------------------------------------------- 00113 // GENERIC PRIVATE FUNCTIONS 00114 // ---------------------------------------------------------------- 00115 00116 /// Encode a boolean value, noting that this is contained 00117 // in a 32 bytes coded value. 00118 uint32_t MessageCodec::encodeBool (char * pBuffer, bool value) 00119 { 00120 uint32_t numBytesEncoded = 4; 00121 00122 memset (pBuffer, 0, 4); 00123 pBuffer[3] = value; 00124 00125 return numBytesEncoded; 00126 } 00127 00128 /// Decode a boolean value, noting that this is contained 00129 // in a 32 bytes coded value. 00130 bool MessageCodec::decodeBool (const char ** ppBuffer) 00131 { 00132 uint32_t value = 0; 00133 bool boolValue = false; 00134 00135 value += ((**ppBuffer) & 0xFF) << 24; 00136 (*ppBuffer)++; 00137 value += ((**ppBuffer) & 0xFF) << 16; 00138 (*ppBuffer)++; 00139 value += ((**ppBuffer) & 0xFF) << 8; 00140 (*ppBuffer)++; 00141 value += ((**ppBuffer) & 0xFF) ; 00142 (*ppBuffer)++; 00143 00144 if (value) 00145 { 00146 boolValue = true; 00147 } 00148 00149 return boolValue; 00150 } 00151 00152 /// Encode an int32 00153 uint32_t MessageCodec::encodeUint32 (char * pBuffer, uint32_t value) 00154 { 00155 uint32_t numBytesEncoded = 4; 00156 00157 pBuffer[0] = 0xff & (value >> 24); 00158 pBuffer[1] = 0xff & (value >> 16); 00159 pBuffer[2] = 0xff & (value >> 8); 00160 pBuffer[3] = 0xff & value; 00161 00162 return numBytesEncoded; 00163 } 00164 00165 /// Decode an int32 00166 uint32_t MessageCodec::decodeUint32 (const char ** ppBuffer) 00167 { 00168 uint32_t value = 0; 00169 00170 value += ((**ppBuffer) & 0xFF) << 24; 00171 (*ppBuffer)++; 00172 value += ((**ppBuffer) & 0xFF) << 16; 00173 (*ppBuffer)++; 00174 value += ((**ppBuffer) & 0xFF) << 8; 00175 (*ppBuffer)++; 00176 value += ((**ppBuffer) & 0xFF); 00177 (*ppBuffer)++; 00178 00179 return value; 00180 } 00181 00182 /// Encode GpioState 00183 uint32_t MessageCodec::encodeGpioState (char * pBuffer, GpioState_t *pGpioState) 00184 00185 { 00186 uint32_t numBytesEncoded = 0; 00187 00188 pBuffer[numBytesEncoded] = 0; 00189 numBytesEncoded++; 00190 pBuffer[numBytesEncoded] = pGpioState->gpio; 00191 numBytesEncoded++; 00192 pBuffer[numBytesEncoded] = pGpioState->inputNotOutput; 00193 numBytesEncoded++; 00194 pBuffer[numBytesEncoded] = pGpioState->onNotOff; 00195 numBytesEncoded++; 00196 00197 return numBytesEncoded; 00198 } 00199 00200 00201 // Decode GpioState 00202 void MessageCodec::decodeGpioState (GpioState_t * pGpioState, const char ** ppBuffer) 00203 { 00204 // Ignore the first byte as it's empty 00205 (*ppBuffer)++; 00206 pGpioState->gpio = (uint8_t) ((**ppBuffer) & 0xFF); 00207 (*ppBuffer)++; 00208 pGpioState->inputNotOutput = (bool) ((**ppBuffer) & 0xFF); 00209 (*ppBuffer)++; 00210 pGpioState->onNotOff = (bool) ((**ppBuffer) & 0xFF); 00211 (*ppBuffer)++; 00212 } 00213 00214 // ---------------------------------------------------------------- 00215 // MESSAGE ENCODING FUNCTIONS 00216 // ---------------------------------------------------------------- 00217 00218 uint32_t MessageCodec::encodeInitIndUlMsg (char * pBuffer, 00219 InitIndUlMsg_t * pMsg) 00220 { 00221 uint32_t numBytesEncoded = 0; 00222 00223 MESSAGE_CODEC_LOGMSG ("Encoding InitIndUlMsg, ID 0x%.2x, ", INIT_IND_UL_MSG); 00224 pBuffer[numBytesEncoded] = INIT_IND_UL_MSG; 00225 numBytesEncoded++; 00226 numBytesEncoded += encodeUint32 (&(pBuffer[numBytesEncoded]), (uint32_t) pMsg->wakeUpCode); 00227 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00228 00229 return numBytesEncoded; 00230 } 00231 00232 uint32_t MessageCodec::encodeRebootReqDlMsg (char * pBuffer, 00233 RebootReqDlMsg_t *pMsg) 00234 { 00235 uint32_t numBytesEncoded = 0; 00236 00237 pBuffer[numBytesEncoded] = REBOOT_REQ_DL_MSG; 00238 numBytesEncoded++; 00239 numBytesEncoded += encodeBool (&(pBuffer[numBytesEncoded]), pMsg->devModeOnNotOff); 00240 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00241 00242 return numBytesEncoded; 00243 } 00244 00245 uint32_t MessageCodec::encodeSerialNumberIndUlMsg (char * pBuffer, 00246 SerialNumberIndUlMsg_t * pMsg) 00247 { 00248 uint32_t numBytesEncoded = 0; 00249 00250 MESSAGE_CODEC_LOGMSG ("Encoding SerialNumberIndUlMsg, ID 0x%.2x, ", SERIAL_NUMBER_IND_UL_MSG); 00251 pBuffer[numBytesEncoded] = SERIAL_NUMBER_IND_UL_MSG; 00252 numBytesEncoded++; 00253 numBytesEncoded += encodeUint32 (&(pBuffer[numBytesEncoded]), pMsg->serialNumber); 00254 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00255 00256 return numBytesEncoded; 00257 } 00258 00259 uint32_t MessageCodec::encodeVolumeIndUlMsg (char * pBuffer, 00260 VolumeIndUlMsg_t * pMsg) 00261 { 00262 uint32_t numBytesEncoded = 0; 00263 00264 MESSAGE_CODEC_LOGMSG ("Encoding VolumeIndUlMsg, ID 0x%.2x, ", VOLUME_IND_UL_MSG); 00265 pBuffer[numBytesEncoded] = VOLUME_IND_UL_MSG; 00266 numBytesEncoded++; 00267 numBytesEncoded += encodeUint32 (&(pBuffer[numBytesEncoded]), pMsg->volumeLitres); 00268 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00269 00270 return numBytesEncoded; 00271 } 00272 00273 uint32_t MessageCodec::encodeRssiIndUlMsg (char * pBuffer, 00274 RssiIndUlMsg_t * pMsg) 00275 { 00276 uint32_t numBytesEncoded = 0; 00277 00278 MESSAGE_CODEC_LOGMSG ("Encoding RssiIndUlMsg, ID 0x%.2x, ", RSSI_IND_UL_MSG); 00279 pBuffer[numBytesEncoded] = RSSI_IND_UL_MSG; 00280 numBytesEncoded++; 00281 numBytesEncoded += encodeUint32 (&(pBuffer[numBytesEncoded]), pMsg->rssi); 00282 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00283 00284 return numBytesEncoded; 00285 } 00286 00287 uint32_t MessageCodec::encodeSerialNumberGetReqDlMsg (char * pBuffer) 00288 { 00289 uint32_t numBytesEncoded = 0; 00290 00291 MESSAGE_CODEC_LOGMSG ("Encoding SerialNumberGetReqDlMsg, ID 0x%.2x, ", SERIAL_NUMBER_GET_REQ_DL_MSG); 00292 pBuffer[numBytesEncoded] = SERIAL_NUMBER_GET_REQ_DL_MSG; 00293 numBytesEncoded++; 00294 numBytesEncoded += encodeBool (&(pBuffer[numBytesEncoded]), 0); // Encode packing as all 00295 // messages must have a body 00296 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00297 00298 return numBytesEncoded; 00299 } 00300 00301 uint32_t MessageCodec::encodeSerialNumberGetCnfUlMsg (char * pBuffer, 00302 SerialNumberGetCnfUlMsg_t * pMsg) 00303 { 00304 uint32_t numBytesEncoded = 0; 00305 00306 MESSAGE_CODEC_LOGMSG ("Encoding SerialNumberGetCnfUlMsg, ID 0x%.2x, ", SERIAL_NUMBER_GET_CNF_UL_MSG); 00307 pBuffer[numBytesEncoded] = SERIAL_NUMBER_GET_CNF_UL_MSG; 00308 numBytesEncoded++; 00309 numBytesEncoded += encodeUint32 (&(pBuffer[numBytesEncoded]), pMsg->serialNumber); 00310 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00311 00312 return numBytesEncoded; 00313 } 00314 00315 uint32_t MessageCodec::encodeReadingIntervalSetReqDlMsg (char * pBuffer, 00316 ReadingIntervalSetReqDlMsg_t * pMsg) 00317 { 00318 uint32_t numBytesEncoded = 0; 00319 00320 MESSAGE_CODEC_LOGMSG ("Encoding ReadingIntervalSetReqDlMsg, ID 0x%.2x, ", READING_INTERVAL_SET_REQ_DL_MSG); 00321 pBuffer[numBytesEncoded] = READING_INTERVAL_SET_REQ_DL_MSG; 00322 numBytesEncoded++; 00323 numBytesEncoded += encodeUint32 (&(pBuffer[numBytesEncoded]), pMsg->readingIntervalSeconds); 00324 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00325 00326 return numBytesEncoded; 00327 } 00328 00329 uint32_t MessageCodec::encodeReadingIntervalSetCnfUlMsg (char * pBuffer, 00330 ReadingIntervalSetCnfUlMsg_t * pMsg) 00331 { 00332 uint32_t numBytesEncoded = 0; 00333 00334 MESSAGE_CODEC_LOGMSG ("Encoding ReadingIntervalSetCnfUlMsg, ID 0x%.2x, ", READING_INTERVAL_SET_CNF_UL_MSG); 00335 pBuffer[numBytesEncoded] = READING_INTERVAL_SET_CNF_UL_MSG; 00336 numBytesEncoded++; 00337 numBytesEncoded += encodeUint32 (&(pBuffer[numBytesEncoded]), pMsg->readingIntervalSeconds); 00338 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00339 00340 return numBytesEncoded; 00341 } 00342 00343 uint32_t MessageCodec::encodeReadingIntervalGetReqDlMsg (char * pBuffer) 00344 { 00345 uint32_t numBytesEncoded = 0; 00346 00347 MESSAGE_CODEC_LOGMSG ("Encoding ReadingIntervalGetReqDlMsg, ID 0x%.2x, ", READING_INTERVAL_GET_REQ_DL_MSG); 00348 pBuffer[numBytesEncoded] = READING_INTERVAL_GET_REQ_DL_MSG; 00349 numBytesEncoded++; 00350 numBytesEncoded += encodeBool (&(pBuffer[numBytesEncoded]), 0); // Encode packing as all 00351 // messages must have a body 00352 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00353 00354 return numBytesEncoded; 00355 } 00356 00357 uint32_t MessageCodec::encodeReadingIntervalGetCnfUlMsg (char * pBuffer, 00358 ReadingIntervalGetCnfUlMsg_t * pMsg) 00359 { 00360 uint32_t numBytesEncoded = 0; 00361 00362 MESSAGE_CODEC_LOGMSG ("Encoding ReadingIntervalGetCnfUlMsg, ID 0x%.2x, ", READING_INTERVAL_GET_CNF_UL_MSG); 00363 pBuffer[numBytesEncoded] = READING_INTERVAL_GET_CNF_UL_MSG; 00364 numBytesEncoded++; 00365 numBytesEncoded += encodeUint32 (&(pBuffer[numBytesEncoded]), pMsg->readingIntervalSeconds); 00366 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00367 00368 return numBytesEncoded; 00369 } 00370 00371 uint32_t MessageCodec::encodeGpioSetReqDlMsg (char * pBuffer, 00372 GpioSetReqDlMsg_t * pMsg) 00373 { 00374 uint32_t numBytesEncoded = 0; 00375 00376 MESSAGE_CODEC_LOGMSG ("Encoding GpioSetReqDlMsg, ID 0x%.2x, ", GPIO_SET_REQ_DL_MSG); 00377 pBuffer[numBytesEncoded] = GPIO_SET_REQ_DL_MSG; 00378 numBytesEncoded++; 00379 numBytesEncoded += encodeGpioState (&(pBuffer[numBytesEncoded]), &(pMsg->gpioState)); 00380 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00381 00382 return numBytesEncoded; 00383 } 00384 00385 uint32_t MessageCodec::encodeGpioSetCnfUlMsg (char * pBuffer, 00386 GpioSetCnfUlMsg_t * pMsg) 00387 { 00388 uint32_t numBytesEncoded = 0; 00389 00390 MESSAGE_CODEC_LOGMSG ("Encoding GpioSetCnfUlMsg, ID 0x%.2x, ", GPIO_SET_CNF_UL_MSG); 00391 pBuffer[numBytesEncoded] = GPIO_SET_CNF_UL_MSG; 00392 numBytesEncoded++; 00393 numBytesEncoded += encodeGpioState (&(pBuffer[numBytesEncoded]), &(pMsg->gpioState)); 00394 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00395 00396 return numBytesEncoded; 00397 } 00398 00399 uint32_t MessageCodec::encodeGpioGetReqDlMsg (char * pBuffer, 00400 GpioGetReqDlMsg_t * pMsg) 00401 { 00402 uint32_t numBytesEncoded = 0; 00403 00404 MESSAGE_CODEC_LOGMSG ("Encoding GpioGetReqDlMsg, ID 0x%.2x, ", LED_GET_REQ_DL_MSG); 00405 pBuffer[numBytesEncoded] = GPIO_GET_REQ_DL_MSG; 00406 numBytesEncoded++; 00407 numBytesEncoded += encodeUint32 (&(pBuffer[numBytesEncoded]), (uint32_t) pMsg->gpio); 00408 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00409 00410 return numBytesEncoded; 00411 } 00412 00413 uint32_t MessageCodec::encodeGpioGetCnfUlMsg (char * pBuffer, 00414 GpioGetCnfUlMsg_t * pMsg) 00415 { 00416 uint32_t numBytesEncoded = 0; 00417 00418 MESSAGE_CODEC_LOGMSG ("Encoding GpioGetCnfUlMsg, ID 0x%.2x, ", LED_GET_CNF_UL_MSG); 00419 pBuffer[numBytesEncoded] = GPIO_GET_CNF_UL_MSG; 00420 numBytesEncoded++; 00421 numBytesEncoded += encodeGpioState (&(pBuffer[numBytesEncoded]), &(pMsg->gpioState)); 00422 00423 return numBytesEncoded; 00424 } 00425 00426 uint32_t MessageCodec::encodeLedSetReqDlMsg (char * pBuffer, 00427 LedSetReqDlMsg_t * pMsg) 00428 { 00429 uint32_t numBytesEncoded = 0; 00430 00431 MESSAGE_CODEC_LOGMSG ("Encoding LedSetReqDlMsg, ID 0x%.2x, ", LED_SET_REQ_DL_MSG); 00432 pBuffer[numBytesEncoded] = LED_SET_REQ_DL_MSG; 00433 numBytesEncoded++; 00434 numBytesEncoded += encodeBool (&(pBuffer[numBytesEncoded]), pMsg->onNotOff); 00435 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00436 00437 return numBytesEncoded; 00438 } 00439 00440 uint32_t MessageCodec::encodeLedSetCnfUlMsg (char * pBuffer, 00441 LedSetCnfUlMsg_t * pMsg) 00442 { 00443 uint32_t numBytesEncoded = 0; 00444 00445 MESSAGE_CODEC_LOGMSG ("Encoding LedSetCnfUlMsg, ID 0x%.2x, ", LED_SET_CNF_UL_MSG); 00446 pBuffer[numBytesEncoded] = LED_SET_CNF_UL_MSG; 00447 numBytesEncoded++; 00448 numBytesEncoded += encodeBool (&(pBuffer[numBytesEncoded]), pMsg->onNotOff); 00449 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00450 00451 return numBytesEncoded; 00452 } 00453 00454 uint32_t MessageCodec::encodeLedGetReqDlMsg (char * pBuffer) 00455 { 00456 uint32_t numBytesEncoded = 0; 00457 00458 MESSAGE_CODEC_LOGMSG ("Encoding LedGetReqDlMsg, ID 0x%.2x, ", LED_GET_REQ_DL_MSG); 00459 pBuffer[numBytesEncoded] = LED_GET_REQ_DL_MSG; 00460 numBytesEncoded++; 00461 numBytesEncoded += encodeBool (&(pBuffer[numBytesEncoded]), 0); // Encode packing as all 00462 // messages must have a body 00463 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00464 00465 return numBytesEncoded; 00466 } 00467 00468 uint32_t MessageCodec::encodeLedGetCnfUlMsg (char * pBuffer, 00469 LedGetCnfUlMsg_t * pMsg) 00470 { 00471 uint32_t numBytesEncoded = 0; 00472 00473 MESSAGE_CODEC_LOGMSG ("Encoding LedGetCnfUlMsg, ID 0x%.2x, ", LED_GET_CNF_UL_MSG); 00474 pBuffer[numBytesEncoded] = LED_GET_CNF_UL_MSG; 00475 numBytesEncoded++; 00476 numBytesEncoded += encodeBool (&(pBuffer[numBytesEncoded]), pMsg->onNotOff); 00477 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00478 00479 return numBytesEncoded; 00480 } 00481 00482 uint32_t MessageCodec::encodeFlashSetReqDlMsg (char * pBuffer, 00483 FlashSetReqDlMsg_t * pMsg) 00484 { 00485 uint32_t numBytesEncoded = 0; 00486 00487 MESSAGE_CODEC_LOGMSG ("Encoding FlashSetReqDlMsg, ID 0x%.2x, ", FLASH_SET_REQ_DL_MSG); 00488 pBuffer[numBytesEncoded] = FLASH_SET_REQ_DL_MSG; 00489 numBytesEncoded++; 00490 numBytesEncoded += encodeBool (&(pBuffer[numBytesEncoded]), pMsg->onNotOff); 00491 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00492 00493 return numBytesEncoded; 00494 } 00495 00496 uint32_t MessageCodec::encodeFlashSetCnfUlMsg (char * pBuffer, 00497 FlashSetCnfUlMsg_t * pMsg) 00498 { 00499 uint32_t numBytesEncoded = 0; 00500 00501 MESSAGE_CODEC_LOGMSG ("Encoding FlashSetCnfUlMs, ID 0x%.2x, ", FLASH_SET_CNF_UL_MSG); 00502 pBuffer[numBytesEncoded] = FLASH_SET_CNF_UL_MSG; 00503 numBytesEncoded++; 00504 numBytesEncoded += encodeBool (&(pBuffer[numBytesEncoded]), pMsg->onNotOff); 00505 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00506 00507 return numBytesEncoded; 00508 } 00509 00510 uint32_t MessageCodec::encodeFlashGetReqDlMsg (char * pBuffer) 00511 { 00512 uint32_t numBytesEncoded = 0; 00513 00514 MESSAGE_CODEC_LOGMSG ("Encoding FlashGetReqDlMsg, ID 0x%.2x, ", FLASH_GET_REQ_DL_MSG); 00515 pBuffer[numBytesEncoded] = FLASH_GET_REQ_DL_MSG; 00516 numBytesEncoded++; 00517 numBytesEncoded += encodeBool (&(pBuffer[numBytesEncoded]), 0); // Encode packing as all 00518 // messages must have a body 00519 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00520 00521 return numBytesEncoded; 00522 } 00523 00524 uint32_t MessageCodec::encodeFlashGetCnfUlMsg (char * pBuffer, 00525 FlashGetCnfUlMsg_t * pMsg) 00526 { 00527 uint32_t numBytesEncoded = 0; 00528 00529 MESSAGE_CODEC_LOGMSG ("Encoding FlashGetCnfUlMs, ID 0x%.2x, ", FLASH_GET_CNF_UL_MSG); 00530 pBuffer[numBytesEncoded] = FLASH_GET_CNF_UL_MSG; 00531 numBytesEncoded++; 00532 numBytesEncoded += encodeBool (&(pBuffer[numBytesEncoded]), pMsg->onNotOff); 00533 MESSAGE_CODEC_LOGMSG ("%d bytes encoded.\n", numBytesEncoded); 00534 00535 return numBytesEncoded; 00536 } 00537 00538 // ---------------------------------------------------------------- 00539 // MESSAGE DECODING FUNCTIONS 00540 // ---------------------------------------------------------------- 00541 MessageCodec::DecodeResult_t MessageCodec::decodeDlMsg (const char ** ppInBuffer, 00542 uint32_t sizeInBuffer, 00543 DlMsgUnion_t * pOutBuffer) 00544 { 00545 MsgIdDl_t msgId; 00546 DecodeResult_t decodeResult = DECODE_RESULT_FAILURE; 00547 00548 if (sizeInBuffer < MAX_MESSAGE_SIZE) 00549 { 00550 decodeResult = DECODE_RESULT_INPUT_TOO_SHORT; 00551 } 00552 else 00553 { 00554 decodeResult = DECODE_RESULT_UNKNOWN_MSG_ID; 00555 // First byte should be a valid DL message ID 00556 msgId = (MsgIdDl_t) **ppInBuffer; 00557 (*ppInBuffer)++; 00558 if (msgId < MAX_NUM_DL_MSGS) 00559 { 00560 switch (msgId) 00561 { 00562 case REBOOT_REQ_DL_MSG: 00563 decodeResult = DECODE_RESULT_REBOOT_REQ_DL_MSG; 00564 pOutBuffer->rebootReqDlMsg.devModeOnNotOff = decodeBool (ppInBuffer); 00565 break; 00566 case SERIAL_NUMBER_GET_REQ_DL_MSG: 00567 decodeResult = DECODE_RESULT_SERIAL_NUMBER_GET_REQ_DL_MSG; 00568 decodeUint32 (ppInBuffer); // Must decode the rest of the dummy message; 00569 break; 00570 case READING_INTERVAL_SET_REQ_DL_MSG: 00571 decodeResult = DECODE_RESULT_READING_INTERVAL_SET_REQ_DL_MSG; 00572 pOutBuffer->readingIntervalSetReqDlMsg.readingIntervalSeconds = decodeUint32 (ppInBuffer); 00573 break; 00574 case READING_INTERVAL_GET_REQ_DL_MSG: 00575 decodeResult = DECODE_RESULT_READING_INTERVAL_GET_REQ_DL_MSG; 00576 decodeUint32 (ppInBuffer); // Must decode the rest of the dummy message; 00577 break; 00578 case GPIO_SET_REQ_DL_MSG: 00579 decodeResult = DECODE_RESULT_GPIO_SET_REQ_DL_MSG; 00580 decodeGpioState (&(pOutBuffer->gpioSetReqDlMsg.gpioState), ppInBuffer); 00581 break; 00582 case GPIO_GET_REQ_DL_MSG: 00583 decodeResult = DECODE_RESULT_GPIO_GET_REQ_DL_MSG; 00584 pOutBuffer->gpioGetReqDlMsg.gpio = (uint8_t) decodeUint32 (ppInBuffer); 00585 break; 00586 case LED_SET_REQ_DL_MSG: 00587 decodeResult = DECODE_RESULT_LED_SET_REQ_DL_MSG; 00588 pOutBuffer->ledSetReqDlMsg.onNotOff = decodeBool (ppInBuffer); 00589 break; 00590 case LED_GET_REQ_DL_MSG: 00591 decodeResult = DECODE_RESULT_LED_GET_REQ_DL_MSG; 00592 decodeUint32 (ppInBuffer); // Must decode the rest of the dummy message; 00593 break; 00594 case FLASH_SET_REQ_DL_MSG: 00595 decodeResult = DECODE_RESULT_FLASH_SET_REQ_DL_MSG; 00596 pOutBuffer->flashSetReqDlMsg.onNotOff = decodeBool (ppInBuffer); 00597 break; 00598 case FLASH_GET_REQ_DL_MSG: 00599 decodeResult = DECODE_RESULT_FLASH_GET_REQ_DL_MSG; 00600 decodeUint32 (ppInBuffer); // Must decode the rest of the dummy message; 00601 break; 00602 default: 00603 // The decodeResult will be left as Unknown message 00604 break; 00605 } 00606 } 00607 } 00608 00609 return decodeResult; 00610 } 00611 00612 MessageCodec::DecodeResult_t MessageCodec::decodeUlMsg (const char ** ppInBuffer, 00613 uint32_t sizeInBuffer, 00614 UlMsgUnion_t * pOutBuffer) 00615 { 00616 MsgIdUl_t msgId; 00617 DecodeResult_t decodeResult = DECODE_RESULT_FAILURE; 00618 00619 if (sizeInBuffer < MAX_MESSAGE_SIZE) 00620 { 00621 decodeResult = DECODE_RESULT_INPUT_TOO_SHORT; 00622 } 00623 else 00624 { 00625 decodeResult = DECODE_RESULT_UNKNOWN_MSG_ID; 00626 // First byte should be a valid UL message ID 00627 msgId = (MsgIdUl_t) **ppInBuffer; 00628 (*ppInBuffer)++; 00629 if (msgId < MAX_NUM_UL_MSGS) 00630 { 00631 switch (msgId) 00632 { 00633 case INIT_IND_UL_MSG: 00634 decodeResult = DECODE_RESULT_INIT_IND_UL_MSG; 00635 pOutBuffer->initIndUlMsg.wakeUpCode = (WakeUpCode_t) decodeUint32 (ppInBuffer); 00636 break; 00637 case SERIAL_NUMBER_IND_UL_MSG: 00638 decodeResult = DECODE_RESULT_SERIAL_NUMBER_IND_UL_MSG; 00639 pOutBuffer->serialNumberIndUlMsg.serialNumber = decodeUint32 (ppInBuffer); 00640 break; 00641 case VOLUME_IND_UL_MSG: 00642 decodeResult = DECODE_RESULT_VOLUME_IND_UL_MSG; 00643 pOutBuffer->volumeIndUlMsg.volumeLitres = decodeUint32 (ppInBuffer); 00644 break; 00645 case RSSI_IND_UL_MSG: 00646 decodeResult = DECODE_RESULT_RSSI_IND_UL_MSG; 00647 pOutBuffer->rssiIndUlMsg.rssi = decodeUint32 (ppInBuffer); 00648 break; 00649 case SERIAL_NUMBER_GET_CNF_UL_MSG: 00650 decodeResult = DECODE_RESULT_SERIAL_NUMBER_GET_CNF_UL_MSG; 00651 pOutBuffer->serialNumberCnfUlMsg.serialNumber = decodeUint32 (ppInBuffer); 00652 break; 00653 case READING_INTERVAL_SET_CNF_UL_MSG: 00654 decodeResult = DECODE_RESULT_READING_INTERVAL_SET_CNF_UL_MSG; 00655 pOutBuffer->readingIntervalSetCnfUlMsg.readingIntervalSeconds = decodeUint32 (ppInBuffer); 00656 break; 00657 case READING_INTERVAL_GET_CNF_UL_MSG: 00658 decodeResult = DECODE_RESULT_READING_INTERVAL_GET_CNF_UL_MSG; 00659 pOutBuffer->readingIntervalGetCnfUlMsg.readingIntervalSeconds = decodeUint32 (ppInBuffer); 00660 break; 00661 case GPIO_SET_CNF_UL_MSG: 00662 decodeResult = DECODE_RESULT_GPIO_SET_CNF_UL_MSG; 00663 pOutBuffer->gpioSetCnfUlMsg = decodeUint32 (ppInBuffer); // Decode as an int32 for later unpacking 00664 break; 00665 case GPIO_GET_CNF_UL_MSG: 00666 decodeResult = DECODE_RESULT_GPIO_GET_CNF_UL_MSG; 00667 pOutBuffer->gpioGetCnfUlMsg = decodeUint32 (ppInBuffer); // Decode as an int32 for later unpacking 00668 break; 00669 case LED_SET_CNF_UL_MSG: 00670 decodeResult = DECODE_RESULT_LED_SET_CNF_UL_MSG; 00671 pOutBuffer->ledSetCnfUlMsg.onNotOff = decodeBool (ppInBuffer); 00672 break; 00673 case LED_GET_CNF_UL_MSG: 00674 decodeResult = DECODE_RESULT_LED_GET_CNF_UL_MSG; 00675 pOutBuffer->ledGetCnfUlMsg.onNotOff = decodeBool (ppInBuffer); 00676 break; 00677 case FLASH_SET_CNF_UL_MSG: 00678 decodeResult = DECODE_RESULT_FLASH_SET_CNF_UL_MSG; 00679 pOutBuffer->flashSetCnfUlMsg.onNotOff = decodeBool (ppInBuffer); 00680 break; 00681 case FLASH_GET_CNF_UL_MSG: 00682 decodeResult = DECODE_RESULT_FLASH_GET_CNF_UL_MSG; 00683 pOutBuffer->flashGetCnfUlMsg.onNotOff = decodeBool (ppInBuffer); 00684 break; 00685 default: 00686 // The decodeResult will be left as Unknown message 00687 break; 00688 } 00689 } 00690 } 00691 00692 return decodeResult; 00693 } 00694 00695 // ---------------------------------------------------------------- 00696 // MISC FUNCTIONS 00697 // ---------------------------------------------------------------- 00698 00699 // Log debug messages 00700 void MessageCodec::logMsg (const char * pFormat, ...) 00701 { 00702 char buffer[MAX_DEBUG_MESSAGE_LEN]; 00703 00704 va_list args; 00705 va_start (args, pFormat); 00706 vsnprintf (buffer, sizeof (buffer), pFormat, args); 00707 va_end (args); 00708 #ifdef WIN32 00709 if (MessageCodec::mp_guiPrintToConsole) 00710 { 00711 (*MessageCodec::mp_guiPrintToConsole) (buffer); 00712 } 00713 #else 00714 // Must be on ARM 00715 printf (buffer); 00716 #endif 00717 } 00718 00719 void MessageCodec::initDll (void (*guiPrintToConsole) (const char *)) 00720 { 00721 #ifdef WIN32 00722 mp_guiPrintToConsole = guiPrintToConsole; 00723 // This is the signal to the GUI that we're done with initialisation 00724 logMsg ("MessageCodec::ready.\n"); 00725 #endif 00726 } 00727 00728 // End Of File
Generated on Sun Jul 17 2022 00:13:12 by
1.7.2