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 #ifdef ASSERT_IS_DEFINED
00020 #include <assert.h>
00021 #define ASSERT(_expr) assert(_expr)
00022 #else
00023 #define ASSERT(_expr) 
00024 #endif
00025 
00026 
00027 int32_t SenetPacket::
00028 PacketHeader::serialize(uint8_t *frame, int32_t len)
00029 {
00030     int32_t serializedLen = 0;
00031 
00032     if(len >= PacketHeader::HEADER_SIZE)
00033     {
00034         frame[0] = version;
00035         frame[1] = type;
00036         serializedLen = PacketHeader::HEADER_SIZE;
00037     }
00038 
00039     return serializedLen;
00040 }
00041 
00042 bool SenetPacket::
00043 PacketHeader::deserialize(uint8_t *frame, int32_t len)
00044 {
00045     if((frame != NULL) && (len >= PacketHeader::HEADER_SIZE))
00046     {
00047         version = frame[0];
00048         type    = frame[1];
00049         return true;
00050     }
00051     return false;
00052 }
00053 
00054 
00055 SenetPacket::SenetPacket(uint8_t senetPktType, uint8_t *_buffer, uint8_t _buflen)
00056 {
00057     header.type    = senetPktType;
00058     header.version = VERSION;
00059     pktLen         = 0;
00060 
00061     if(_buffer != NULL)
00062     {
00063         buffer     = _buffer;
00064         bufferLen  = _buflen;
00065         ownBuffer  = false;
00066     }
00067     else
00068     {
00069         if(_buflen != 0) 
00070             bufferLen = _buflen;
00071         else 
00072             bufferLen = MAX_FRAME_SIZE;
00073 
00074         buffer = new uint8_t[bufferLen];
00075         ASSERT(buffer != NULL);
00076         ownBuffer = true;
00077     }
00078     memset(buffer, 0, bufferLen);
00079 }
00080 
00081 
00082 SenetPacket::~SenetPacket()
00083 {
00084     if(ownBuffer == true)
00085         delete buffer;
00086 }
00087 
00088 
00089 int32_t SenetPacket::serialize()
00090 {
00091     pktLen = header.serialize(buffer, bufferLen);
00092     ASSERT(pktLen > 0);
00093 
00094     if(pktLen > 0)
00095     {
00096         int32_t payloadLen = serializePayload(buffer + pktLen, bufferLen - pktLen);
00097 
00098         ASSERT(payloadLen > 0);
00099 
00100         if(payloadLen > 0)
00101         {
00102             pktLen += payloadLen;
00103             return pktLen;
00104         }
00105     }
00106 
00107     return -1;
00108 }
00109 
00110 
00111 bool SensorPacket::addSensorValue(uint8_t position, uint8_t type, uint16_t value)
00112 {
00113     if (position < MAX_SENSOR_VALUES)
00114     {
00115         sensorValue[position].type  = type;
00116         sensorValue[position].value = value;
00117         sensorValue[position].isSet = true;
00118         return true;
00119     }
00120     else
00121         return false;
00122 }
00123 
00124 int32_t SensorPacket::serializePayload(uint8_t *buffer, int32_t len)
00125 {
00126     int32_t bytes   = 0;
00127     int32_t dataLen = 0;
00128 
00129     for(int32_t i = 0; i < MAX_SENSOR_VALUES; i++)
00130     {
00131         if(sensorValue[i].isSet == true)
00132         {
00133             dataLen = sensorValue[i].serialize(buffer+bytes, len - bytes);
00134             if(dataLen == -1)
00135                 return -1;
00136             bytes += dataLen;
00137         }
00138     }
00139     return bytes; 
00140 }
00141 
00142 bool SelfIdPacket::setDeviceType(uint32_t model, uint8_t revision)
00143 {
00144     if((model & 0x00FFFFFF) != model)
00145         return false;
00146 
00147     deviceType = (model<<8)|revision;
00148     return true;
00149 }
00150 
00151 bool SelfIdPacket::setSwVersion(uint8_t major, uint8_t minor, uint8_t point, uint16_t build, uint8_t developerId)
00152 {
00153  uint8_t  _major =  major & 0xf;
00154  uint8_t  _minor =  minor & 0xf;
00155  uint8_t  _point =  point & 0x3f;
00156  uint16_t _build =  build & 0x3ff;
00157  uint8_t  _devid =  developerId & 0xff;
00158 
00159  if((_major != major) || (_minor != minor) || (_point != point) || (_build != build) || (_devid != developerId))
00160      return false;
00161 
00162   swVersion = (_major << 28) | (_minor << 24) | (_point << 18) | (_build << 8) | _devid; 
00163   return true;
00164 }
00165 
00166 void SelfIdPacket::setBatteryFailState(bool failed)
00167 {
00168     if(failed == true)
00169         powerMask |= 1 << 3;
00170     else
00171         powerMask &= ~(1 << 3); 
00172 }
00173 
00174 bool SelfIdPacket::setBatteryLevel(uint8_t level)
00175 {
00176     uint8_t _level = level & 0x7;
00177 
00178     if(level != _level)
00179         return false;
00180 
00181     powerMask &= 0xf8;
00182     powerMask |= _level;
00183 
00184     return true;
00185 }
00186 
00187 bool SelfIdPacket::setExtPowerSupplyState(uint8_t id, bool isPresent)
00188 {
00189     bool retVal = false;
00190     if(id == EXT_POWER_SUPPLY_1)      
00191     {
00192         powerMask &= 0x7F; 
00193         if(isPresent)
00194             powerMask |= 0x80;
00195         retVal = true;
00196     }
00197     else if(id == EXT_POWER_SUPPLY_2)      
00198     {
00199         powerMask &= 0xBF; 
00200         if(isPresent)
00201             powerMask |= 0x40;
00202         retVal = true;
00203     }
00204     return retVal;
00205 }
00206 
00207 int32_t SelfIdPacket::serializePayload(uint8_t *frame, int32_t len)
00208 {
00209     int32_t out = -1;
00210 
00211     if(SELFID_PAYLOAD_LEN <= len)
00212     {
00213         frame[0] = (deviceType>>16) & 0xff;
00214         frame[1] = (deviceType>>8)  & 0xff;
00215         frame[2] = deviceType & 0xff;
00216 
00217         frame[3] = (swVersion >> 24) & 0xff;
00218         frame[4] = (swVersion >> 16) & 0xff;
00219         frame[5] = (swVersion >> 8)  & 0xff;
00220         frame[6] = swVersion & 0xff;
00221 
00222         frame[7] = powerMask;
00223 
00224         out = SELFID_PAYLOAD_LEN;
00225     }
00226 
00227     return out;
00228 }
00229 
00230 int32_t ConfigWordPacket::serializePayload(uint8_t *frame, int32_t len)
00231 {
00232     int32_t out = -1;
00233 
00234     if(CONTROL_PAYLOAD_LENGTH <= len)
00235     {
00236         frame[0] = (config>>24) & 0xff;
00237         frame[1] = (config>>16) & 0xff;
00238         frame[2] = (config>>8) & 0xff;
00239         frame[3] = config & 0xff;
00240 
00241         frame[4] = (mask>>24) & 0xff;
00242         frame[5] = (mask>>16) & 0xff;
00243         frame[6] = (mask>>8) & 0xff;
00244         frame[7] = mask & 0xff;
00245 
00246         frame[8] = authKey;
00247         out = CONTROL_PAYLOAD_LENGTH;
00248     }
00249 
00250     return out;
00251 
00252 }
00253 
00254 int32_t BootInfoPacket::serializePayload(uint8_t *frame, int32_t len) 
00255 {
00256     int32_t out = -1;
00257 
00258     if(BOOT_PAYLOAD_LENGTH <= len)
00259     {
00260         frame[0] = (bootCount<<8) & 0xff;
00261         frame[1] = bootCount & 0xff;
00262 
00263         frame[2] = (resetCount<<8) & 0xff;
00264         frame[3] = resetCount & 0xff;
00265 
00266         frame[4] = (lastBootReason<<24) & 0xff;
00267         frame[5] = (lastBootReason<<16)  & 0xff;
00268         frame[6] = (lastBootReason<<8)  & 0xff;
00269 
00270         out = BOOT_PAYLOAD_LENGTH;
00271     }
00272 
00273     return out;
00274 }
00275 
00276 bool GpsPacket::setCoordinates(uint32_t _latitude, uint32_t _longitude, uint16_t _elevation)
00277 {
00278 
00279     if(((_latitude & 0x00ffffff) != _latitude) || ((_longitude & 0x00ffffff) != _longitude))
00280         return false;
00281 
00282     latitude  = _latitude; 
00283     longitude = _longitude; 
00284     elevation = _elevation;
00285     
00286     return true;
00287 }
00288 
00289 int32_t GpsPacket::serializePayload(uint8_t *frame, int32_t len)
00290 {
00291     int32_t out = -1;
00292 
00293     if(GPS_PAYLOAD_LENGTH <= len)
00294     {
00295         frame[0] = (latitude>>16) & 0xff;
00296         frame[1] = (latitude>>8) & 0xff;
00297         frame[2] = latitude & 0xff;
00298 
00299         frame[3] = (longitude>>16) & 0xff;
00300         frame[4] = (longitude>>8) & 0xff;
00301         frame[5] = longitude & 0xff;
00302 
00303         frame[6] = (elevation>>8) & 0xff;
00304         frame[7] = elevation & 0xff;
00305 
00306         frame[8] = txPower;
00307 
00308         out = GPS_PAYLOAD_LENGTH;
00309     }
00310 
00311     return  out;
00312 }
00313 
00314 int32_t RFDataPacket::serializePayload(uint8_t *frame, int32_t len)
00315 {
00316     int32_t out = -1;
00317 
00318     if(RFDATA_PAYLOAD_LEN <= len)
00319     {
00320         frame[0] = channel;
00321         frame[1] = txpower;
00322         frame[2] = datarate;
00323         frame[3] = snr;
00324         frame[4] = rssi;
00325         frame[5] = (timestamp >> 16)& 0xff;
00326         frame[6] = (timestamp >> 8)& 0xff;
00327         frame[7] = timestamp & 0xff;
00328         out = RFDATA_PAYLOAD_LEN;
00329     }
00330     return out;
00331 }
00332 
00333 
00334 OctetStringPacket::OctetStringPacket(uint8_t size) : 
00335     SenetPacket(OCTET_STRING_PACKET, NULL, size + SenetPacket::PacketHeader::HEADER_SIZE)
00336 { 
00337     max   = size;
00338     oslen = 0;
00339 }
00340 
00341 bool OctetStringPacket::setOctetString(uint8_t *os, uint8_t len)
00342 {
00343     if(len > max)
00344         return false;
00345 
00346     oslen = len;
00347     memcpy(buffer+PacketHeader::HEADER_SIZE, os, oslen);
00348     return true;
00349 }
00350 
00351 int32_t OctetStringPacket::serializePayload(uint8_t *frame, int32_t len)
00352 {
00353     int32_t out = -1;
00354 
00355     if(oslen >= len)
00356     {
00357         memcpy(frame, buffer + PacketHeader::HEADER_SIZE, oslen);
00358         out = oslen;
00359     }
00360 
00361     return out;
00362 }
00363