ble_payload.h

00001 /* mbed Microcontroller Library
00002 * Copyright (c) 2006-2013 ARM Limited
00003 *
00004 * Licensed under the Apache License, Version 2.0 (the "License");
00005 * you may not use this file except in compliance with the License.
00006 * You may obtain a copy of the License at
00007 *
00008 *     http://www.apache.org/licenses/LICENSE-2.0
00009 *
00010 * Unless required by applicable law or agreed to in writing, software
00011 * distributed under the License is distributed on an "AS IS" BASIS,
00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013 * See the License for the specific language governing permissions and
00014 * limitations under the License.
00015 */
00016 
00017 #ifdef YOTTA_CFG_MBED_OS
00018     #include "mbed-drivers/mbed.h"
00019 #else
00020     #include "mbed.h"
00021 #endif 
00022 #include "ble_debug.h"
00023 
00024 #ifndef __PAYLOAD_H__
00025 #define __PAYLOAD_H__
00026 
00027 class UnitPayload
00028 {
00029 public:
00030     uint8_t length;
00031     uint8_t id;    
00032     uint8_t *data;
00033     uint8_t *idptr;    
00034 
00035     
00036     
00037     void set_length(uint8_t l) {
00038         length=l;   
00039     }
00040 
00041     void set_id(uint8_t i) {
00042         id=i;
00043     }
00044 
00045     void set_data(uint8_t* data1) {
00046         for(int j=0;j<length;j++)
00047         {
00048             data[j]=data1[j];
00049         }   
00050     }
00051 
00052     uint8_t get_length()  {
00053         return length;      
00054     }
00055 
00056     uint8_t get_id()  {
00057         return id;      
00058     }
00059 
00060     uint8_t* get_data() {
00061         return data;        
00062     }
00063 
00064 };
00065 
00066 class Payload {
00067     UnitPayload *payload;
00068     int stringLength;
00069     int payloadUnitCount;
00070     
00071 public:
00072     Payload(const uint8_t *tokenString, uint8_t string_ength);
00073     Payload();
00074     ~Payload();
00075     uint8_t getPayloadUnitCount();
00076     
00077     uint8_t getIDAtIndex(int index);  
00078     uint8_t getLengthAtIndex(int index);   
00079     uint8_t* getDataAtIndex(int index);    
00080     int8_t getInt8AtIndex(int index);  
00081     uint16_t getUint16AtIndex(int index); 
00082     uint8_t* getSerializedAdDataAtIndex(int index);         
00083 };
00084 
00085 
00086 class PayloadUnit {
00087 private:        
00088     uint8_t* lenPtr;
00089     uint8_t* adTypePtr;
00090     uint8_t* dataPtr;
00091     
00092 public:
00093     PayloadUnit() {
00094         lenPtr = NULL;
00095         adTypePtr = NULL;
00096         dataPtr = NULL;
00097     }
00098     
00099     PayloadUnit(uint8_t *len, uint8_t *adType, uint8_t* data) {
00100         lenPtr = len;
00101         adTypePtr = adType;
00102         dataPtr = data;
00103     }    
00104     
00105     void setLenPtr(uint8_t *len)   {
00106         lenPtr = len;
00107     } 
00108     
00109     void setAdTypePtr(uint8_t *adType)   {
00110         adTypePtr = adType;
00111     }  
00112     
00113     void setDataPtr(uint8_t *data)   {
00114         dataPtr = data;
00115     }      
00116     
00117     uint8_t* getLenPtr()   {
00118         return lenPtr;
00119     } 
00120     
00121     uint8_t* getAdTypePtr()   {
00122         return adTypePtr;
00123     }  
00124     
00125     uint8_t* getDataPtr()   {
00126         return dataPtr;
00127     }   
00128     
00129     void printDataAsHex()   {
00130         int i = 0;
00131         PRINTF("AdData=");
00132         for(i=0; i<*lenPtr-1; i++) {
00133             PRINTF("0x%x ", dataPtr[i]);
00134         }
00135         PRINTF("\n");
00136     }     
00137     
00138     void printDataAsString()   {
00139         int i = 0;
00140         PRINTF("AdData=");
00141         for(i=0; i<*lenPtr-1; i++) {
00142             PRINTF("%c", dataPtr[i]);
00143         }
00144         PRINTF("\n");
00145     }                                                   
00146     
00147 };
00148 
00149 class PayloadPtr {
00150 private:
00151     PayloadUnit *unit;
00152     int payloadUnitCount;
00153 public:    
00154     PayloadPtr(const uint8_t *tokenString, uint8_t string_ength) {
00155         // initialize private data members
00156         int stringLength = string_ength;
00157         payloadUnitCount = 0;
00158         
00159         int index = 0;
00160         while(index!=stringLength) {
00161             int len=tokenString[index];
00162             index=index+1+len;
00163             payloadUnitCount++;               
00164         }
00165         
00166         // allocate memory to unit
00167         unit = new PayloadUnit[payloadUnitCount];
00168         int i = 0;
00169         int nextUnitOffset = 0;
00170         
00171         while(i<payloadUnitCount) {           
00172             unit[i].setLenPtr((uint8_t *)tokenString+nextUnitOffset);
00173             unit[i].setAdTypePtr((uint8_t *)tokenString+nextUnitOffset+1);
00174             unit[i].setDataPtr((uint8_t *)tokenString+nextUnitOffset+2);
00175             
00176             nextUnitOffset += *unit[i].getLenPtr()+1;
00177             i++;
00178 
00179         }
00180     }
00181     
00182     PayloadUnit getUnitAtIndex(int index) {
00183         return unit[index];
00184     }
00185     
00186     int getPayloadUnitCount() { return payloadUnitCount; }
00187     
00188     ~PayloadPtr() {
00189         if(unit) delete[] unit;
00190 
00191         unit = NULL;
00192     }
00193 };    
00194 
00195 #endif // __PAYLOAD_H__