CayenneLPP.cpp

00001 #include "CayenneLPP.h"
00002 
00003 CayenneLPP::CayenneLPP(uint8_t size) : maxsize(size) {
00004     buffer = (uint8_t*) malloc(size);
00005     cursor = 0;
00006 }
00007 
00008 CayenneLPP::~CayenneLPP(void) {
00009     free(buffer);
00010 }
00011 
00012 void CayenneLPP::reset(void) {
00013     cursor = 0;
00014 }
00015 
00016 uint8_t CayenneLPP::getSize(void) {
00017     return cursor;
00018 }
00019 
00020 uint8_t* CayenneLPP::getBuffer(void) {
00021 //    uint8_t[cursor] result;
00022 //    memcpy(result, buffer, cursor);
00023 //    return result;
00024     return buffer;
00025 }
00026 
00027 uint8_t CayenneLPP::copy(uint8_t* dst) {
00028     memcpy(dst, buffer, cursor);
00029     return cursor;
00030 }
00031 
00032 uint8_t CayenneLPP::addDigitalInput(uint8_t channel, uint8_t value) {
00033     if ((cursor + LPP_DIGITAL_INPUT_SIZE) > maxsize) {
00034         return 0;
00035     }
00036     buffer[cursor++] = channel; 
00037     buffer[cursor++] = LPP_DIGITAL_INPUT; 
00038     buffer[cursor++] = value; 
00039 
00040     return cursor;
00041 }
00042 
00043 uint8_t CayenneLPP::addDigitalOutput(uint8_t channel, uint8_t value) {
00044     if ((cursor + LPP_DIGITAL_OUTPUT_SIZE) > maxsize) {
00045         return 0;
00046     }
00047     buffer[cursor++] = channel; 
00048     buffer[cursor++] = LPP_DIGITAL_OUTPUT; 
00049     buffer[cursor++] = value; 
00050 
00051     return cursor;
00052 }
00053 
00054 uint8_t CayenneLPP::addAnalogInput(uint8_t channel, float value) {
00055     if ((cursor + LPP_ANALOG_INPUT_SIZE) > maxsize) {
00056         return 0;
00057     }
00058     
00059     int16_t val = value * 100;
00060     buffer[cursor++] = channel; 
00061     buffer[cursor++] = LPP_ANALOG_INPUT; 
00062     buffer[cursor++] = val >> 8; 
00063     buffer[cursor++] = val; 
00064 
00065     return cursor;
00066 }
00067 
00068 uint8_t CayenneLPP::addAnalogOutput(uint8_t channel, float value) {
00069     if ((cursor + LPP_ANALOG_OUTPUT_SIZE) > maxsize) {
00070         return 0;
00071     }
00072     int16_t val = value * 100;
00073     buffer[cursor++] = channel; 
00074     buffer[cursor++] = LPP_ANALOG_OUTPUT;
00075     buffer[cursor++] = val >> 8; 
00076     buffer[cursor++] = val; 
00077     
00078     return cursor;
00079 }
00080 
00081 uint8_t CayenneLPP::addLuminosity(uint8_t channel, uint16_t lux) {
00082     if ((cursor + LPP_LUMINOSITY_SIZE) > maxsize) {
00083         return 0;
00084     }
00085     buffer[cursor++] = channel; 
00086     buffer[cursor++] = LPP_LUMINOSITY; 
00087     buffer[cursor++] = lux >> 8; 
00088     buffer[cursor++] = lux; 
00089 
00090     return cursor;
00091 }
00092 
00093 uint8_t CayenneLPP::addPresence(uint8_t channel, uint8_t value) {
00094     if ((cursor + LPP_PRESENCE_SIZE) > maxsize) {
00095         return 0;
00096     }
00097     buffer[cursor++] = channel; 
00098     buffer[cursor++] = LPP_PRESENCE; 
00099     buffer[cursor++] = value; 
00100 
00101     return cursor;
00102 }
00103 
00104 uint8_t CayenneLPP::addTemperature(uint8_t channel, float celsius) {
00105     if ((cursor + LPP_TEMPERATURE_SIZE) > maxsize) {
00106         return 0;
00107     }
00108     int16_t val = celsius * 10;
00109     buffer[cursor++] = channel; 
00110     buffer[cursor++] = LPP_TEMPERATURE; 
00111     buffer[cursor++] = val >> 8; 
00112     buffer[cursor++] = val; 
00113 
00114     return cursor;
00115 }
00116 
00117 uint8_t CayenneLPP::addRelativeHumidity(uint8_t channel, float rh) {
00118     if ((cursor + LPP_RELATIVE_HUMIDITY_SIZE) > maxsize) {
00119         return 0;
00120     }
00121     buffer[cursor++] = channel; 
00122     buffer[cursor++] = LPP_RELATIVE_HUMIDITY; 
00123     buffer[cursor++] = rh * 2; 
00124 
00125     return cursor;
00126 }
00127 
00128 uint8_t CayenneLPP::addAccelerometer(uint8_t channel, float x, float y, float z) {
00129     if ((cursor + LPP_ACCELEROMETER_SIZE) > maxsize) {
00130         return 0;
00131     }
00132     int16_t vx = x * 1000;
00133     int16_t vy = y * 1000;
00134     int16_t vz = z * 1000;
00135     
00136     buffer[cursor++] = channel; 
00137     buffer[cursor++] = LPP_ACCELEROMETER; 
00138     buffer[cursor++] = vx >> 8; 
00139     buffer[cursor++] = vx; 
00140     buffer[cursor++] = vy >> 8; 
00141     buffer[cursor++] = vy; 
00142     buffer[cursor++] = vz >> 8; 
00143     buffer[cursor++] = vz; 
00144 
00145     return cursor;
00146 }
00147 
00148 uint8_t CayenneLPP::addBarometricPressure(uint8_t channel, float hpa) {
00149     if ((cursor + LPP_BAROMETRIC_PRESSURE_SIZE) > maxsize) {
00150         return 0;
00151     }
00152     int16_t val = hpa * 10;
00153     
00154     buffer[cursor++] = channel; 
00155     buffer[cursor++] = LPP_BAROMETRIC_PRESSURE; 
00156     buffer[cursor++] = val >> 8; 
00157     buffer[cursor++] = val; 
00158 
00159     return cursor;
00160 }
00161 
00162 uint8_t CayenneLPP::addGyrometer(uint8_t channel, float x, float y, float z) {
00163     if ((cursor + LPP_GYROMETER_SIZE) > maxsize) {
00164         return 0;
00165     }
00166     int16_t vx = x * 100;
00167     int16_t vy = y * 100;
00168     int16_t vz = z * 100;
00169     
00170     buffer[cursor++] = channel; 
00171     buffer[cursor++] = LPP_GYROMETER; 
00172     buffer[cursor++] = vx >> 8; 
00173     buffer[cursor++] = vx; 
00174     buffer[cursor++] = vy >> 8; 
00175     buffer[cursor++] = vy; 
00176     buffer[cursor++] = vz >> 8; 
00177     buffer[cursor++] = vz; 
00178 
00179     return cursor;
00180 }
00181 
00182 uint8_t CayenneLPP::addGPS(uint8_t channel, float latitude, float longitude, float meters) {
00183     if ((cursor + LPP_GPS_SIZE) > maxsize) {
00184         return 0;
00185     }
00186     int32_t lat = latitude * 10000;
00187     int32_t lon = longitude * 10000;
00188     int32_t alt = meters * 100;
00189     
00190     buffer[cursor++] = channel; 
00191     buffer[cursor++] = LPP_GPS; 
00192 
00193     buffer[cursor++] = lat >> 16; 
00194     buffer[cursor++] = lat >> 8; 
00195     buffer[cursor++] = lat; 
00196     buffer[cursor++] = lon >> 16; 
00197     buffer[cursor++] = lon >> 8; 
00198     buffer[cursor++] = lon; 
00199     buffer[cursor++] = alt >> 16; 
00200     buffer[cursor++] = alt >> 8;
00201     buffer[cursor++] = alt;
00202 
00203     return cursor;
00204 }
00205