senet_packet.cpp

00001 /*
00002  * =====================================================================================
00003  *
00004  *       Filename:  senet_packet.cpp
00005  *
00006  *    Description:  Senet Packet Types implementation file 
00007  *
00008  *        Version:  1.0
00009  *        Created:  03/05/2016 04:23:40 PM
00010  *
00011  *         Author:  S. Nelson  
00012  *        Company:  Senet, Inc
00013  *
00014  * =====================================================================================
00015  */
00016 #include "senet_packet.h"
00017 #include <stdio.h>
00018 
00019 #define ASSERT(_expr) 
00020 
00021 
00022 int32_t SenetPacket::
00023 PacketHeader::serialize(uint8_t *frame, int32_t len)
00024 {
00025     int32_t serializedLen = -1;
00026 
00027     if(len >= PacketHeader::HEADER_SIZE)
00028     {
00029         serializedLen = 0;
00030         frame[serializedLen++] = version;
00031         frame[serializedLen++] = type;
00032 
00033         ASSERT(serializedLen == PacketHeader::HEADER_SIZE);
00034     }
00035 
00036     return serializedLen;
00037 }
00038 
00039 int32_t SenetPacket::
00040 PacketHeader::deserialize(uint8_t *frame, int32_t len)
00041 {
00042     if((frame != NULL) && (len >= PacketHeader::HEADER_SIZE))
00043     {
00044         int32_t offset = 0;
00045         version = frame[offset++];
00046         type    = frame[offset++];
00047 
00048         ASSERT(offset == PacketHeader::HEADER_SIZE);
00049 
00050         return  PacketHeader::HEADER_SIZE;
00051     }
00052     return false;
00053 }
00054 
00055 
00056 SenetPacket::SenetPacket(uint8_t senetPktType, uint8_t *_buffer, uint8_t _buflen)
00057 {
00058     header.type    = senetPktType;
00059     header.version = VERSION;
00060     pktLen         = 0;
00061 
00062     if(_buffer != NULL)
00063     {
00064         buffer     = _buffer;
00065         bufferLen  = _buflen;
00066         ownBuffer  = false;
00067     }
00068     else
00069     {
00070         if(_buflen != 0) 
00071             bufferLen = _buflen;
00072         else 
00073             bufferLen = MAX_FRAME_SIZE;
00074 
00075         buffer = new uint8_t[bufferLen];
00076         ASSERT(buffer != NULL);
00077         ownBuffer = true;
00078     }
00079     memset(buffer, 0, bufferLen);
00080 }
00081 
00082 
00083 SenetPacket::~SenetPacket()
00084 {
00085     if(ownBuffer == true)
00086         delete buffer;
00087 }
00088 
00089 
00090 int32_t SenetPacket::serialize()
00091 {
00092     pktLen = header.serialize(buffer, bufferLen);
00093     ASSERT(pktLen > 0);
00094 
00095     if(pktLen > 0)
00096     {
00097         int32_t payloadLen = serializePayload(buffer + pktLen, bufferLen - pktLen);
00098 
00099         ASSERT(payloadLen > 0);
00100 
00101         if(payloadLen > 0)
00102         {
00103             pktLen += payloadLen;
00104             return pktLen;
00105         }
00106     }
00107 
00108     return -1;
00109 }
00110 
00111 int32_t SenetPacket::deserialize(uint8_t *frame, int32_t len)
00112 {
00113     int32_t bytes = 0;
00114 
00115     bytes = header.deserialize(frame, len);
00116     if(bytes > 0)
00117     {
00118         int32_t payloadLen = deserializePayload(frame, len - bytes);
00119         if(payloadLen > 0)
00120             bytes += payloadLen; 
00121         else
00122             bytes = payloadLen; 
00123 
00124     }
00125     return bytes;
00126 }
00127 
00128 
00129 bool SensorPacket::addSensorValue(uint8_t position, uint8_t type, uint16_t value)
00130 {
00131     if (position < MAX_SENSOR_VALUES)
00132     {
00133         sensorValue[position].type  = type;
00134         sensorValue[position].value = value;
00135         sensorValue[position].isSet = true;
00136         return true;
00137     }
00138     else
00139         return false;
00140 }
00141 
00142 int32_t SensorPacket::serializePayload(uint8_t *buffer, int32_t len)
00143 {
00144     int32_t bytes   = 0;
00145     int32_t dataLen = 0;
00146 
00147     for(int32_t i = 0; i < MAX_SENSOR_VALUES; i++)
00148     {
00149         if(sensorValue[i].isSet == true)
00150         {
00151             dataLen = sensorValue[i].serialize(buffer+bytes, len - bytes);
00152             if(dataLen == -1)
00153                 return -1;
00154             bytes += dataLen;
00155         }
00156     }
00157     return bytes; 
00158 }
00159 int32_t SensorPacket::deserializePayload(uint8_t *frame, int32_t len) 
00160 {
00161     int32_t num_sensors = 0;
00162     for(int i = 0;i < MAX_SENSOR_VALUES;i++)
00163     {
00164         if(len < 3)
00165             break;
00166         sensorValue[i].type = frame[i*3+0];
00167         sensorValue[i].value= (frame[i*3+1]<<8)|frame[i*3+2];
00168         sensorValue[i].isSet= true;
00169         len-=3;
00170         num_sensors++;
00171     }
00172     return(num_sensors);
00173 }
00174 bool SelfIdPacket::setDeviceType(uint32_t model, uint8_t revision)
00175 {
00176     if((model & 0x00FFFFFF) != model)
00177         return false;
00178 
00179     deviceType = (model<<8)|revision;
00180     return true;
00181 }
00182 
00183 bool SelfIdPacket::setSwVersion(uint8_t major, uint8_t minor, uint8_t point, uint16_t build, uint8_t developerId)
00184 {
00185  uint8_t  _major =  major & 0xf;
00186  uint8_t  _minor =  minor & 0xf;
00187  uint8_t  _point =  point & 0x3f;
00188  uint16_t _build =  build & 0x3ff;
00189  uint8_t  _devid =  developerId & 0xff;
00190 
00191  if((_major != major) || (_minor != minor) || (_point != point) || (_build != build) || (_devid != developerId))
00192      return false;
00193 
00194   swVersion = (_major << 28) | (_minor << 24) | (_point << 18) | (_build << 8) | _devid; 
00195   return true;
00196 }
00197 
00198 void SelfIdPacket::setBatteryFailState(bool failed)
00199 {
00200     if(failed == true)
00201         powerMask |= 1 << 3;
00202     else
00203         powerMask &= ~(1 << 3); 
00204 }
00205 
00206 bool SelfIdPacket::setBatteryLevel(uint8_t level)
00207 {
00208     uint8_t _level = level & 0x7;
00209 
00210     if(level != _level)
00211         return false;
00212 
00213     powerMask &= 0xf8;
00214     powerMask |= _level;
00215 
00216     return true;
00217 }
00218 
00219 bool SelfIdPacket::setExtPowerSupplyState(uint8_t id, bool isPresent)
00220 {
00221     bool retVal = false;
00222     if(id == EXT_POWER_SUPPLY_1)      
00223     {
00224         powerMask &= 0x7F; 
00225         if(isPresent)
00226             powerMask |= 0x80;
00227         retVal = true;
00228     }
00229     else if(id == EXT_POWER_SUPPLY_2)      
00230     {
00231         powerMask &= 0xBF; 
00232         if(isPresent)
00233             powerMask |= 0x40;
00234         retVal = true;
00235     }
00236     return retVal;
00237 }
00238 
00239 int32_t SelfIdPacket::serializePayload(uint8_t *frame, int32_t len)
00240 {
00241     int32_t out = -1;
00242 
00243     if(SELFID_PAYLOAD_LEN <= len)
00244     {
00245         frame[0] = (deviceType>>24) & 0xff;
00246         frame[1] = (deviceType>>16)  & 0xff;
00247         frame[2] = (deviceType>>8)  & 0xff;
00248         frame[3] = deviceType & 0xff;
00249 
00250         frame[4] = (swVersion >> 24) & 0xff;
00251         frame[5] = (swVersion >> 16) & 0xff;
00252         frame[6] = (swVersion >> 8)  & 0xff;
00253         frame[7] = swVersion & 0xff;
00254 
00255         frame[8] = powerMask;
00256 
00257         out = SELFID_PAYLOAD_LEN;
00258     }
00259 
00260     return out;
00261 }
00262 
00263 int32_t ConfigWordPacket::serializePayload(uint8_t *frame, int32_t len)
00264 {
00265     int32_t out = -1;
00266 
00267     if(CONTROL_PAYLOAD_LENGTH <= len)
00268     {
00269         frame[0] = (config>>24) & 0xff;
00270         frame[1] = (config>>16) & 0xff;
00271         frame[2] = (config>>8) & 0xff;
00272         frame[3] = config & 0xff;
00273 
00274         frame[4] = (mask>>24) & 0xff;
00275         frame[5] = (mask>>16) & 0xff;
00276         frame[6] = (mask>>8) & 0xff;
00277         frame[7] = mask & 0xff;
00278 
00279         frame[8] = authKey;
00280         out = CONTROL_PAYLOAD_LENGTH;
00281     }
00282 
00283     return out;
00284 
00285 }
00286 
00287 int32_t ConfigWordPacket::deserializePayload(uint8_t *frame, int32_t len) 
00288 {
00289     if(CONTROL_PAYLOAD_LENGTH <= len)
00290     {
00291         int32_t offset = 0;
00292 
00293         config  = frame[offset++]<<24; 
00294         config |= frame[offset++]<<16; 
00295         config |= frame[offset++]<<8; 
00296         config |= frame[offset++]; 
00297 
00298         mask  = frame[offset++]<<24; 
00299         mask |= frame[offset++]<<16; 
00300         mask |= frame[offset++]<<8; 
00301         mask |= frame[offset++]; 
00302 
00303         authKey = frame[offset++];
00304 
00305         return offset;
00306     }
00307     return -1;
00308 }
00309 
00310 
00311 int32_t BootInfoPacket::serializePayload(uint8_t *frame, int32_t len) 
00312 {
00313     int32_t out = -1;
00314 
00315     if(BOOT_PAYLOAD_LENGTH <= len)
00316     {
00317         frame[0] = (bootCount>>8) & 0xff;
00318         frame[1] = bootCount & 0xff;
00319 
00320         frame[2] = (resetCount>>8) & 0xff;
00321         frame[3] = resetCount & 0xff;
00322 
00323         frame[4] = (lastBootReason>>24) & 0xff;
00324         frame[5] = (lastBootReason>>16)  & 0xff;
00325         frame[6] = (lastBootReason>>8)  & 0xff;
00326         frame[7] = lastBootReason  & 0xff;
00327         frame[8] = authKey;
00328 
00329         out = BOOT_PAYLOAD_LENGTH;
00330     }
00331 
00332     return out;
00333 }
00334 
00335 
00336 int32_t BootInfoPacket::deserializePayload(uint8_t *frame, int32_t len) 
00337 {
00338     if(BOOT_PAYLOAD_LENGTH <= len)
00339     {
00340         int32_t offset = 0;
00341 
00342         bootCount  = frame[offset++]<<8; 
00343         bootCount |= frame[offset++]; 
00344 
00345         resetCount  = frame[offset++]<<8; 
00346         resetCount |= frame[offset++]; 
00347 
00348         lastBootReason  = frame[offset++] << 24;
00349         lastBootReason |= frame[offset++] << 16;
00350         lastBootReason |= frame[offset++] << 8;
00351         lastBootReason |= frame[offset++];
00352 
00353         authKey =  frame[offset++];
00354 
00355         return offset;
00356     }
00357     return -1;
00358 }
00359 
00360 bool GpsPacket::setCoordinates(int32_t _latitude, int32_t _longitude, uint16_t _elevation)
00361 {
00362     latitude  = _latitude; 
00363     longitude = _longitude; 
00364     elevation = _elevation;
00365     
00366     return true;
00367 }
00368 
00369 int32_t GpsPacket::serializePayload(uint8_t *frame, int32_t len)
00370 {
00371     int32_t out = -1;
00372 
00373     if(GPS_PAYLOAD_LENGTH <= len)
00374     {
00375         frame[0] = (latitude>>16) & 0xff;
00376         frame[1] = (latitude>>8) & 0xff;
00377         frame[2] = latitude & 0xff;
00378 
00379         frame[3] = (longitude>>16) & 0xff;
00380         frame[4] = (longitude>>8) & 0xff;
00381         frame[5] = longitude & 0xff;
00382 
00383         frame[6] = (elevation>>8) & 0xff;
00384         frame[7] = elevation & 0xff;
00385 
00386         frame[8] = txPower;
00387 
00388         out = GPS_PAYLOAD_LENGTH;
00389     }
00390 
00391     return  out;
00392 }
00393 
00394 int32_t RFDataPacket::serializePayload(uint8_t *frame, int32_t len)
00395 {
00396     int32_t out = -1;
00397 
00398     if(RFDATA_PAYLOAD_LEN <= len)
00399     {
00400         frame[0] = channel;
00401         frame[1] = txpower;
00402         frame[2] = datarate;
00403         frame[3] = snr;
00404         frame[4] = (rssi >>8) & 0xff;
00405         frame[5] = rssi & 0xff;
00406         frame[6] = (timestamp >> 16) & 0xff;
00407         frame[7] = (timestamp >> 8)  & 0xff;
00408         frame[8] = timestamp & 0xff;
00409         out = RFDATA_PAYLOAD_LEN;
00410     }
00411     return out;
00412 }
00413 
00414 
00415 OctetStringPacket::OctetStringPacket(uint8_t size) : 
00416     SenetPacket(OCTET_STRING_PACKET, NULL, size + SenetPacket::PacketHeader::HEADER_SIZE)
00417 { 
00418     max   = size;
00419     oslen = 0;
00420 }
00421 
00422 bool OctetStringPacket::setOctetString(uint8_t *os, uint8_t len)
00423 {
00424     if(len > max)
00425         return false;
00426 
00427     oslen = len;
00428     memcpy(buffer+PacketHeader::HEADER_SIZE, os, oslen);
00429     return true;
00430 }
00431 
00432 int32_t OctetStringPacket::serializePayload(uint8_t *frame, int32_t len)
00433 {
00434     int32_t out = -1;
00435 
00436     if(oslen >= len)
00437     {
00438         memcpy(frame, buffer + PacketHeader::HEADER_SIZE, oslen);
00439         out = oslen;
00440     }
00441 
00442     return out;
00443 }
00444