L14-Click 1.0
STM32WLE5CC LoRaWAN Sensor Platform
Loading...
Searching...
No Matches
CayenneLpp.c
Go to the documentation of this file.
1/*!
2 * @file CayenneLpp.c
3 *
4 * @brief Implements the Cayenne Low Power Protocol
5 *
6 * \copyright Revised BSD License, see section \ref LICENSE.
7 *
8 * \code
9 * ______ _
10 * / _____) _ | |
11 * ( (____ _____ ____ _| |_ _____ ____| |__
12 * \____ \| ___ | (_ _) ___ |/ ___) _ \
13 * _____) ) ____| | | || |_| ____( (___| | | |
14 * (______/|_____)_|_|_| \__)_____)\____)_| |_|
15 * (C)2013-2018 Semtech
16 *
17 * \endcode
18 *
19 * \author Miguel Luis ( Semtech )
20 */
21/* Includes ------------------------------------------------------------------*/
22#include "stm32_mem.h"
23#include "CayenneLpp.h"
24/* USER CODE BEGIN Includes */
25#include "utilities.h"
26/* USER CODE END Includes */
27
28/* External variables ---------------------------------------------------------*/
29/* USER CODE BEGIN EV */
30
31/* USER CODE END EV */
32
33/* Private typedef -----------------------------------------------------------*/
34/* USER CODE BEGIN PTD */
35
36/* USER CODE END PTD */
37
38/* Private define ------------------------------------------------------------*/
39#define CAYENNE_LPP_MAXBUFFER_SIZE 242
40#define LPP_DIGITAL_INPUT 0 /* 1 byte */
41#define LPP_DIGITAL_OUTPUT 1 /* 1 byte */
42#define LPP_ANALOG_INPUT 2 /* 2 bytes, 0.01 signed */
43#define LPP_ANALOG_OUTPUT 3 /* 2 bytes, 0.01 signed */
44#define LPP_LUMINOSITY 101 /* 2 bytes, 1 lux unsigned */
45#define LPP_PRESENCE 102 /* 1 byte, 1 */
46#define LPP_TEMPERATURE 103 /* 2 bytes, 0.1 Celsius degrees signed */
47#define LPP_RELATIVE_HUMIDITY 104 /* 1 byte, 0.5% unsigned */
48#define LPP_ACCELEROMETER 113 /* 2 bytes per axis, 0.001G */
49#define LPP_BAROMETRIC_PRESSURE 115 /* 2 bytes 0.1 hPa Unsigned */
50#define LPP_GYROMETER 134 /* 2 bytes per axis, 0.01 degrees/s */
51#define LPP_GPS 136 /* 3 byte lon/lat 0.0001 degrees, 3 bytes alt 0.01m */
52
53/* Data ID + Data Type + Data Size */
54#define LPP_DIGITAL_INPUT_SIZE 3
55#define LPP_DIGITAL_OUTPUT_SIZE 3
56#define LPP_ANALOG_INPUT_SIZE 4
57#define LPP_ANALOG_OUTPUT_SIZE 4
58#define LPP_LUMINOSITY_SIZE 4
59#define LPP_PRESENCE_SIZE 3
60#define LPP_TEMPERATURE_SIZE 4
61#define LPP_RELATIVE_HUMIDITY_SIZE 3
62#define LPP_ACCELEROMETER_SIZE 8
63#define LPP_BAROMETRIC_PRESSURE_SIZE 4
64#define LPP_GYROMETER_SIZE 8
65#define LPP_GPS_SIZE 11
66
67/* USER CODE BEGIN PD */
68/* Additional sensor types for missing sensors */
69#define LPP_CONCENTRATION 125 /* 2 bytes, 1 ppm unsigned (CO2) */
70#define LPP_VOLTAGE 116 /* 2 bytes, 0.01V unsigned */
71#define LPP_BATTERY_PERC 117 /* 1 byte, percent of battery, unsigned, values of 0-100 */
72#define LPP_PARTICULATE_MATTER_1_0 138 /* 2 bytes, 1 μg/m3 of 1mm unsigned */
73#define LPP_PARTICULATE_MATTER_2_5 139 /* 2 bytes, 1 μg/m3 of 2.5mm unsigned */
74#define LPP_UNIX_TIME 133 /* 4 bytes data, unsigned Unix timestamp */
75#define LPP_MIN8_TIME 145 /* 1 byte data, unsigned char - max 255 minutes - 4.25h*/
76#define LPP_MIN16_TIME 146 /* 2 bytes data, unsigned int - max 65535 minutes 45.5days*/
77
78
79/* Data sizes for new sensor types */
80#define LPP_CONCENTRATION_SIZE 4
81#define LPP_VOLTAGE_SIZE 4
82#define LPP_BATTERY_PERC_SIZE (2+1)
83#define LPP_PARTICULATE_MATTER_SIZE 4
84#define LPP_UNIX_TIME_SIZE (2+4)
85#define LPP_MIN8_TIME_SIZE (2+1)
86#define LPP_MIN16_TIME_SIZE (2+2)
87/* USER CODE END PD */
88
89/* Private macro -------------------------------------------------------------*/
90/* USER CODE BEGIN PM */
91
92/* USER CODE END PM */
93
94/* Private variables ---------------------------------------------------------*/
95static uint8_t CayenneLppBuffer[CAYENNE_LPP_MAXBUFFER_SIZE];
96static uint8_t CayenneLppCursor = 0;
97/* USER CODE BEGIN PV */
98
99/* USER CODE END PV */
100
101/* Private function prototypes -----------------------------------------------*/
102
103/* USER CODE BEGIN PFP */
104
105/* USER CODE END PFP */
106
107/* Exported functions --------------------------------------------------------*/
108void CayenneLppInit(void)
109{
110 CayenneLppCursor = 0;
111 /* USER CODE BEGIN CayenneLppCursor */
112
113 /* USER CODE END CayenneLppCursor */
114}
115
116void CayenneLppReset(void)
117{
118 CayenneLppCursor = 0;
119 /* USER CODE BEGIN CayenneLppReset */
120
121 /* USER CODE END CayenneLppReset */
122}
123
124uint8_t CayenneLppGetSize(void)
125{
126 /* USER CODE BEGIN CayenneLppGetSize */
127
128 /* USER CODE END CayenneLppGetSize */
129 return CayenneLppCursor;
130}
131
132uint8_t *CayenneLppGetBuffer(void)
133{
134 /* USER CODE BEGIN CayenneLppGetBuffer */
135
136 /* USER CODE END CayenneLppGetBuffer */
137 return CayenneLppBuffer;
138}
139
140uint8_t CayenneLppCopy(uint8_t *dst)
141{
142 /* USER CODE BEGIN CayenneLppCopy_1 */
143
144 /* USER CODE END CayenneLppCopy_1 */
145 UTIL_MEM_cpy_8(dst, CayenneLppBuffer, CayenneLppCursor);
146 /* USER CODE BEGIN CayenneLppCopy_2 */
147
148 /* USER CODE END CayenneLppCopy_2 */
149 return CayenneLppCursor;
150}
151
152uint8_t CayenneLppAddDigitalInput(uint8_t channel, uint8_t value)
153{
154 /* USER CODE BEGIN CayenneLppAddDigitalInput_1 */
155
156 /* USER CODE END CayenneLppAddDigitalInput_1 */
157 if ((CayenneLppCursor + LPP_DIGITAL_INPUT_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
158 {
159 return 0;
160 }
161 CayenneLppBuffer[CayenneLppCursor++] = channel;
162 CayenneLppBuffer[CayenneLppCursor++] = LPP_DIGITAL_INPUT;
163 CayenneLppBuffer[CayenneLppCursor++] = value;
164 /* USER CODE BEGIN CayenneLppAddDigitalInput_2 */
165
166 /* USER CODE END CayenneLppAddDigitalInput_2 */
167 return CayenneLppCursor;
168}
169
170uint8_t CayenneLppAddDigitalOutput(uint8_t channel, uint8_t value)
171{
172 /* USER CODE BEGIN CayenneLppAddDigitalOutput_1 */
173
174 /* USER CODE END CayenneLppAddDigitalOutput_1 */
175 if ((CayenneLppCursor + LPP_DIGITAL_OUTPUT_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
176 {
177 return 0;
178 }
179 CayenneLppBuffer[CayenneLppCursor++] = channel;
180 CayenneLppBuffer[CayenneLppCursor++] = LPP_DIGITAL_OUTPUT;
181 CayenneLppBuffer[CayenneLppCursor++] = value;
182 /* USER CODE BEGIN CayenneLppAddDigitalOutput_2 */
183
184 /* USER CODE END CayenneLppAddDigitalOutput_2 */
185 return CayenneLppCursor;
186}
187
188uint8_t CayenneLppAddAnalogInput(uint8_t channel, float value)
189{
190 /* USER CODE BEGIN CayenneLppAddAnalogInput_1 */
191
192 /* USER CODE END CayenneLppAddAnalogInput_1 */
193 if ((CayenneLppCursor + LPP_ANALOG_INPUT_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
194 {
195 return 0;
196 }
197
198 int16_t val = (int16_t)(value * 100);
199 CayenneLppBuffer[CayenneLppCursor++] = channel;
200 CayenneLppBuffer[CayenneLppCursor++] = LPP_ANALOG_INPUT;
201 CayenneLppBuffer[CayenneLppCursor++] = val >> 8;
202 CayenneLppBuffer[CayenneLppCursor++] = val;
203 /* USER CODE BEGIN CayenneLppAddAnalogInput_2 */
204
205 /* USER CODE END CayenneLppAddAnalogInput_2 */
206 return CayenneLppCursor;
207}
208
209uint8_t CayenneLppAddAnalogOutput(uint8_t channel, float value)
210{
211 /* USER CODE BEGIN CayenneLppAddAnalogOutput_1 */
212
213 /* USER CODE END CayenneLppAddAnalogOutput_1 */
214 if ((CayenneLppCursor + LPP_ANALOG_OUTPUT_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
215 {
216 return 0;
217 }
218 int16_t val = (int16_t)(value * 100);
219 CayenneLppBuffer[CayenneLppCursor++] = channel;
220 CayenneLppBuffer[CayenneLppCursor++] = LPP_ANALOG_OUTPUT;
221 CayenneLppBuffer[CayenneLppCursor++] = val >> 8;
222 CayenneLppBuffer[CayenneLppCursor++] = val;
223 /* USER CODE BEGIN CayenneLppAddAnalogOutput_2 */
224
225 /* USER CODE END CayenneLppAddAnalogOutput_2 */
226 return CayenneLppCursor;
227}
228
229uint8_t CayenneLppAddLuminosity(uint8_t channel, uint16_t lux)
230{
231 /* USER CODE BEGIN CayenneLppAddLuminosity_1 */
232
233 /* USER CODE END CayenneLppAddLuminosity_1 */
234 if ((CayenneLppCursor + LPP_LUMINOSITY_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
235 {
236 return 0;
237 }
238 CayenneLppBuffer[CayenneLppCursor++] = channel;
239 CayenneLppBuffer[CayenneLppCursor++] = LPP_LUMINOSITY;
240 CayenneLppBuffer[CayenneLppCursor++] = lux >> 8;
241 CayenneLppBuffer[CayenneLppCursor++] = lux;
242 /* USER CODE BEGIN CayenneLppAddLuminosity_2 */
243
244 /* USER CODE END CayenneLppAddLuminosity_2 */
245 return CayenneLppCursor;
246}
247
248uint8_t CayenneLppAddPresence(uint8_t channel, uint8_t value)
249{
250 /* USER CODE BEGIN CayenneLppAddPresence_1 */
251
252 /* USER CODE END CayenneLppAddPresence_1 */
253 if ((CayenneLppCursor + LPP_PRESENCE_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
254 {
255 return 0;
256 }
257 CayenneLppBuffer[CayenneLppCursor++] = channel;
258 CayenneLppBuffer[CayenneLppCursor++] = LPP_PRESENCE;
259 CayenneLppBuffer[CayenneLppCursor++] = value;
260 /* USER CODE BEGIN CayenneLppAddPresence_2 */
261
262 /* USER CODE END CayenneLppAddPresence_2 */
263 return CayenneLppCursor;
264}
265
266uint8_t CayenneLppAddTemperature(uint8_t channel, float celsius)
267{
268 /* USER CODE BEGIN CayenneLppAddTemperature_1 */
269
270 /* USER CODE END CayenneLppAddTemperature_1 */
271 if ((CayenneLppCursor + LPP_TEMPERATURE_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
272 {
273 return 0;
274 }
275 int16_t val = (int16_t)(celsius * 10);
276 CayenneLppBuffer[CayenneLppCursor++] = channel;
277 CayenneLppBuffer[CayenneLppCursor++] = LPP_TEMPERATURE;
278 CayenneLppBuffer[CayenneLppCursor++] = val >> 8;
279 CayenneLppBuffer[CayenneLppCursor++] = val;
280 /* USER CODE BEGIN CayenneLppAddTemperature_2 */
281
282 /* USER CODE END CayenneLppAddTemperature_2 */
283 return CayenneLppCursor;
284}
285
286uint8_t CayenneLppAddRelativeHumidity(uint8_t channel, float rh)
287{
288 /* USER CODE BEGIN CayenneLppAddRelativeHumidity_1 */
289
290 /* USER CODE END CayenneLppAddRelativeHumidity_1 */
291 if ((CayenneLppCursor + LPP_RELATIVE_HUMIDITY_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
292 {
293 return 0;
294 }
295 CayenneLppBuffer[CayenneLppCursor++] = channel;
296 CayenneLppBuffer[CayenneLppCursor++] = LPP_RELATIVE_HUMIDITY;
297 CayenneLppBuffer[CayenneLppCursor++] = (uint8_t)(rh * 2);
298 /* USER CODE BEGIN CayenneLppAddRelativeHumidity_2 */
299
300 /* USER CODE END CayenneLppAddRelativeHumidity_2 */
301 return CayenneLppCursor;
302}
303
304uint8_t CayenneLppAddAccelerometer(uint8_t channel, float x, float y, float z)
305{
306 /* USER CODE BEGIN CayenneLppAddAccelerometer_1 */
307
308 /* USER CODE END CayenneLppAddAccelerometer_1 */
309 if ((CayenneLppCursor + LPP_ACCELEROMETER_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
310 {
311 return 0;
312 }
313 int16_t vx = (int16_t)(x * 1000);
314 int16_t vy = (int16_t)(y * 1000);
315 int16_t vz = (int16_t)(z * 1000);
316
317 CayenneLppBuffer[CayenneLppCursor++] = channel;
318 CayenneLppBuffer[CayenneLppCursor++] = LPP_ACCELEROMETER;
319 CayenneLppBuffer[CayenneLppCursor++] = vx >> 8;
320 CayenneLppBuffer[CayenneLppCursor++] = vx;
321 CayenneLppBuffer[CayenneLppCursor++] = vy >> 8;
322 CayenneLppBuffer[CayenneLppCursor++] = vy;
323 CayenneLppBuffer[CayenneLppCursor++] = vz >> 8;
324 CayenneLppBuffer[CayenneLppCursor++] = vz;
325 /* USER CODE BEGIN CayenneLppAddAccelerometer_2 */
326
327 /* USER CODE END CayenneLppAddAccelerometer_2 */
328 return CayenneLppCursor;
329}
330
331uint8_t CayenneLppAddBarometricPressure(uint8_t channel, float hpa)
332{
333 /* USER CODE BEGIN CayenneLppAddBarometricPressure_1 */
334
335 /* USER CODE END CayenneLppAddBarometricPressure_1 */
336 if ((CayenneLppCursor + LPP_BAROMETRIC_PRESSURE_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
337 {
338 return 0;
339 }
340 int16_t val = (int16_t)(hpa * 10);
341
342 CayenneLppBuffer[CayenneLppCursor++] = channel;
343 CayenneLppBuffer[CayenneLppCursor++] = LPP_BAROMETRIC_PRESSURE;
344 CayenneLppBuffer[CayenneLppCursor++] = val >> 8;
345 CayenneLppBuffer[CayenneLppCursor++] = val;
346 /* USER CODE BEGIN CayenneLppAddBarometricPressure_2 */
347
348 /* USER CODE END CayenneLppAddBarometricPressure_2 */
349 return CayenneLppCursor;
350}
351
352uint8_t CayenneLppAddGyrometer(uint8_t channel, float x, float y, float z)
353{
354 /* USER CODE BEGIN CayenneLppAddGyrometer_1 */
355
356 /* USER CODE END CayenneLppAddGyrometer_1 */
357 if ((CayenneLppCursor + LPP_GYROMETER_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
358 {
359 return 0;
360 }
361 int16_t vx = (int16_t)(x * 100);
362 int16_t vy = (int16_t)(y * 100);
363 int16_t vz = (int16_t)(z * 100);
364
365 CayenneLppBuffer[CayenneLppCursor++] = channel;
366 CayenneLppBuffer[CayenneLppCursor++] = LPP_GYROMETER;
367 CayenneLppBuffer[CayenneLppCursor++] = vx >> 8;
368 CayenneLppBuffer[CayenneLppCursor++] = vx;
369 CayenneLppBuffer[CayenneLppCursor++] = vy >> 8;
370 CayenneLppBuffer[CayenneLppCursor++] = vy;
371 CayenneLppBuffer[CayenneLppCursor++] = vz >> 8;
372 CayenneLppBuffer[CayenneLppCursor++] = vz;
373 /* USER CODE BEGIN CayenneLppAddGyrometer_2 */
374
375 /* USER CODE END CayenneLppAddGyrometer_2 */
376 return CayenneLppCursor;
377}
378
379uint8_t CayenneLppAddGps(uint8_t channel, float latitude, float longitude, float meters)
380{
381 /* USER CODE BEGIN CayenneLppAddGps_1 */
382
383 /* USER CODE END CayenneLppAddGps_1 */
384 if ((CayenneLppCursor + LPP_GPS_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
385 {
386 return 0;
387 }
388 int32_t lat = (int32_t)(latitude * 10000);
389 int32_t lon = (int32_t)(longitude * 10000);
390 int32_t alt = (int32_t)(meters * 100);
391
392 CayenneLppBuffer[CayenneLppCursor++] = channel;
393 CayenneLppBuffer[CayenneLppCursor++] = LPP_GPS;
394
395 CayenneLppBuffer[CayenneLppCursor++] = lat >> 16;
396 CayenneLppBuffer[CayenneLppCursor++] = lat >> 8;
397 CayenneLppBuffer[CayenneLppCursor++] = lat;
398 CayenneLppBuffer[CayenneLppCursor++] = lon >> 16;
399 CayenneLppBuffer[CayenneLppCursor++] = lon >> 8;
400 CayenneLppBuffer[CayenneLppCursor++] = lon;
401 CayenneLppBuffer[CayenneLppCursor++] = alt >> 16;
402 CayenneLppBuffer[CayenneLppCursor++] = alt >> 8;
403 CayenneLppBuffer[CayenneLppCursor++] = alt;
404 /* USER CODE BEGIN CayenneLppAddGps_2 */
405
406 /* USER CODE END CayenneLppAddGps_2 */
407 return CayenneLppCursor;
408}
409
410/* USER CODE BEGIN EF */
411
412uint8_t CayenneLppMaxBuffer()
413{
414 return CAYENNE_LPP_MAXBUFFER_SIZE;
415}
416
417/**
418 * @brief Add CO2 concentration data to the buffer
419 * @param channel Data channel
420 * @param ppm CO2 concentration in parts per million (ppm)
421 * @return Current buffer position
422 */
423uint8_t CayenneLppAddConcentration(uint8_t channel, uint16_t ppm)
424{
425 if ((CayenneLppCursor + LPP_CONCENTRATION_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
426 {
427 return 0;
428 }
429 CayenneLppBuffer[CayenneLppCursor++] = channel;
430 CayenneLppBuffer[CayenneLppCursor++] = LPP_CONCENTRATION;
431 CayenneLppBuffer[CayenneLppCursor++] = ppm >> 8;
432 CayenneLppBuffer[CayenneLppCursor++] = ppm;
433 return CayenneLppCursor;
434}
435
436/**
437 * @brief Add voltage data to the buffer
438 * @param channel Data channel
439 * @param voltage Voltage in volts
440 * @return Current buffer position
441 */
442uint8_t CayenneLppAddVoltage(uint8_t channel, float voltage)
443{
444 if ((CayenneLppCursor + LPP_VOLTAGE_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
445 {
446 return 0;
447 }
448 uint16_t val = (uint16_t) (voltage * 100);
449 CayenneLppBuffer[CayenneLppCursor++] = channel;
450 CayenneLppBuffer[CayenneLppCursor++] = LPP_VOLTAGE;
451 CayenneLppBuffer[CayenneLppCursor++] = val >> 8;
452 CayenneLppBuffer[CayenneLppCursor++] = val;
453 return CayenneLppCursor;
454}
455
456/**
457 * @brief Add particulate matter of 1mm concentration data to the buffer
458 * @param channel Data channel
459 * @param concentration_1_0 Particle concentration of 1mm in μg/m³
460 * @return Current buffer position
461 */
462uint8_t CayenneLppAddParticulateMatter_1_0(uint8_t channel, float concentration_1_0)
463{
464 if ((CayenneLppCursor + LPP_PARTICULATE_MATTER_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
465 {
466 return 0;
467 }
468 uint16_t val = (uint16_t) (concentration_1_0 * 100.0f);
469 CayenneLppBuffer[CayenneLppCursor++] = channel;
470 CayenneLppBuffer[CayenneLppCursor++] = LPP_PARTICULATE_MATTER_1_0;
471 CayenneLppBuffer[CayenneLppCursor++] = val >> 8;
472 CayenneLppBuffer[CayenneLppCursor++] = val;
473 return CayenneLppCursor;
474}
475
476/**
477 * @brief Add particulate matter 2.5mm concentration data to the buffer
478 * @param channel Data channel
479 * @param concentration_2_5 Particle concentration of 2.5mm in μg/m³
480 * @return Current buffer position
481 */
482uint8_t CayenneLppAddParticulateMatter_2_5(uint8_t channel, float concentration_2_5)
483{
484 if ((CayenneLppCursor + LPP_PARTICULATE_MATTER_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
485 {
486 return 0;
487 }
488 uint16_t val = (uint16_t) (concentration_2_5 * 100.0f);
489 CayenneLppBuffer[CayenneLppCursor++] = channel;
490 CayenneLppBuffer[CayenneLppCursor++] = LPP_PARTICULATE_MATTER_2_5;
491 CayenneLppBuffer[CayenneLppCursor++] = val >> 8;
492 CayenneLppBuffer[CayenneLppCursor++] = val;
493 return CayenneLppCursor;
494}
495
496
497/**
498 * @brief Add UTC time of measure to the buffer
499 * @param channel Data channel
500 * @param timeMeasure Time value in seconds (uint32_t) - Unix timestamp (seconds since epoch)
501 * @return Current buffer position
502 */
503uint8_t CayenneLppAddTimeMeasureABS(uint8_t channel, uint32_t timeMeasure)
504{
505 if ((CayenneLppCursor + LPP_UNIX_TIME_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
506 {
507 return 0;
508 }
509 CayenneLppBuffer[CayenneLppCursor++] = channel;
510 CayenneLppBuffer[CayenneLppCursor++] = LPP_UNIX_TIME;
511 CayenneLppBuffer[CayenneLppCursor++] = timeMeasure >> 24;
512 CayenneLppBuffer[CayenneLppCursor++] = timeMeasure >> 16;
513 CayenneLppBuffer[CayenneLppCursor++] = timeMeasure >> 8;
514 CayenneLppBuffer[CayenneLppCursor++] = timeMeasure;
515 return CayenneLppCursor;
516}
517
518
519uint8_t CayenneLppAddTimeMeasureMIN8(uint8_t channel, uint8_t timeOffsetMin8)
520{
521 if ((CayenneLppCursor + LPP_MIN8_TIME_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
522 {
523 return 0;
524 }
525 CayenneLppBuffer[CayenneLppCursor++] = channel;
526 CayenneLppBuffer[CayenneLppCursor++] = LPP_MIN8_TIME;
527 CayenneLppBuffer[CayenneLppCursor++] = timeOffsetMin8;
528 return CayenneLppCursor;
529}
530uint8_t CayenneLppAddTimeMeasureMIN16(uint8_t channel, uint16_t timeOffsetMin16)
531{
532 if ((CayenneLppCursor + LPP_MIN16_TIME_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
533 {
534 return 0;
535 }
536 CayenneLppBuffer[CayenneLppCursor++] = channel;
537 CayenneLppBuffer[CayenneLppCursor++] = LPP_MIN16_TIME;
538 CayenneLppBuffer[CayenneLppCursor++] = timeOffsetMin16 >> 8;
539 CayenneLppBuffer[CayenneLppCursor++] = timeOffsetMin16;
540 return CayenneLppCursor;
541}
542
543uint8_t CayenneLppAddBatteryPerc(uint8_t channel, uint8_t perc)
544{
545 if ((CayenneLppCursor + LPP_BATTERY_PERC_SIZE) > CAYENNE_LPP_MAXBUFFER_SIZE)
546 {
547 return 0;
548 }
549 CayenneLppBuffer[CayenneLppCursor++] = channel;
550 CayenneLppBuffer[CayenneLppCursor++] = LPP_BATTERY_PERC;
551 CayenneLppBuffer[CayenneLppCursor++] = perc;
552 return CayenneLppCursor;
553}
554/* USER CODE END EF */
555
556/* Private Functions Definition -----------------------------------------------*/
557/* USER CODE BEGIN PrFD */
558
559/* USER CODE END PrFD */
LPP_GYROMETER
#define LPP_GYROMETER
Definition CayenneLpp.c:50
CayenneLppAddTemperature
uint8_t CayenneLppAddTemperature(uint8_t channel, float celsius)
Definition CayenneLpp.c:266
LPP_RELATIVE_HUMIDITY
#define LPP_RELATIVE_HUMIDITY
Definition CayenneLpp.c:47
CayenneLppAddBatteryPerc
uint8_t CayenneLppAddBatteryPerc(uint8_t channel, uint8_t perc)
Add battery percent of voltage data to the buffer (1B).
Definition CayenneLpp.c:543
LPP_GYROMETER_SIZE
#define LPP_GYROMETER_SIZE
Definition CayenneLpp.c:64
CayenneLppGetBuffer
uint8_t * CayenneLppGetBuffer(void)
Definition CayenneLpp.c:132
LPP_BATTERY_PERC_SIZE
#define LPP_BATTERY_PERC_SIZE
Definition CayenneLpp.c:82
LPP_BAROMETRIC_PRESSURE
#define LPP_BAROMETRIC_PRESSURE
Definition CayenneLpp.c:49
LPP_GPS_SIZE
#define LPP_GPS_SIZE
Definition CayenneLpp.c:65
LPP_DIGITAL_OUTPUT
#define LPP_DIGITAL_OUTPUT
Definition CayenneLpp.c:41
LPP_DIGITAL_OUTPUT_SIZE
#define LPP_DIGITAL_OUTPUT_SIZE
Definition CayenneLpp.c:55
CayenneLppAddDigitalInput
uint8_t CayenneLppAddDigitalInput(uint8_t channel, uint8_t value)
Definition CayenneLpp.c:152
CayenneLppAddConcentration
uint8_t CayenneLppAddConcentration(uint8_t channel, uint16_t ppm)
Add CO2 concentration data to the buffer.
Definition CayenneLpp.c:423
CayenneLppInit
void CayenneLppInit(void)
Definition CayenneLpp.c:108
LPP_PARTICULATE_MATTER_SIZE
#define LPP_PARTICULATE_MATTER_SIZE
Definition CayenneLpp.c:83
CayenneLppCopy
uint8_t CayenneLppCopy(uint8_t *dst)
Definition CayenneLpp.c:140
CAYENNE_LPP_MAXBUFFER_SIZE
#define CAYENNE_LPP_MAXBUFFER_SIZE
Definition CayenneLpp.c:39
LPP_MIN16_TIME_SIZE
#define LPP_MIN16_TIME_SIZE
Definition CayenneLpp.c:86
CayenneLppAddLuminosity
uint8_t CayenneLppAddLuminosity(uint8_t channel, uint16_t lux)
Definition CayenneLpp.c:229
CayenneLppAddGps
uint8_t CayenneLppAddGps(uint8_t channel, float latitude, float longitude, float meters)
Definition CayenneLpp.c:379
LPP_VOLTAGE
#define LPP_VOLTAGE
Definition CayenneLpp.c:70
CayenneLppAddPresence
uint8_t CayenneLppAddPresence(uint8_t channel, uint8_t value)
Definition CayenneLpp.c:248
CayenneLppAddBarometricPressure
uint8_t CayenneLppAddBarometricPressure(uint8_t channel, float hpa)
Definition CayenneLpp.c:331
LPP_PRESENCE
#define LPP_PRESENCE
Definition CayenneLpp.c:45
CayenneLppAddVoltage
uint8_t CayenneLppAddVoltage(uint8_t channel, float voltage)
Add voltage data to the buffer.
Definition CayenneLpp.c:442
LPP_LUMINOSITY_SIZE
#define LPP_LUMINOSITY_SIZE
Definition CayenneLpp.c:58
LPP_CONCENTRATION_SIZE
#define LPP_CONCENTRATION_SIZE
Definition CayenneLpp.c:80
LPP_MIN16_TIME
#define LPP_MIN16_TIME
Definition CayenneLpp.c:76
CayenneLppAddTimeMeasureABS
uint8_t CayenneLppAddTimeMeasureABS(uint8_t channel, uint32_t timeMeasure)
Add UTC time of measure to the buffer.
Definition CayenneLpp.c:503
LPP_PARTICULATE_MATTER_2_5
#define LPP_PARTICULATE_MATTER_2_5
Definition CayenneLpp.c:73
LPP_LUMINOSITY
#define LPP_LUMINOSITY
Definition CayenneLpp.c:44
CayenneLppBuffer
static uint8_t CayenneLppBuffer[242]
Definition CayenneLpp.c:95
LPP_ACCELEROMETER
#define LPP_ACCELEROMETER
Definition CayenneLpp.c:48
LPP_TEMPERATURE
#define LPP_TEMPERATURE
Definition CayenneLpp.c:46
CayenneLppReset
void CayenneLppReset(void)
Definition CayenneLpp.c:116
CayenneLppMaxBuffer
uint8_t CayenneLppMaxBuffer()
Definition CayenneLpp.c:412
CayenneLppAddAnalogOutput
uint8_t CayenneLppAddAnalogOutput(uint8_t channel, float value)
Definition CayenneLpp.c:209
CayenneLppAddAnalogInput
uint8_t CayenneLppAddAnalogInput(uint8_t channel, float value)
Definition CayenneLpp.c:188
CayenneLppAddTimeMeasureMIN16
uint8_t CayenneLppAddTimeMeasureMIN16(uint8_t channel, uint16_t timeOffsetMin16)
Add the relative time of measuring - offset from previous measured data less than 65535 minutes (abou...
Definition CayenneLpp.c:530
CayenneLppAddParticulateMatter_1_0
uint8_t CayenneLppAddParticulateMatter_1_0(uint8_t channel, float concentration_1_0)
Add particulate matter of 1mm concentration data to the buffer.
Definition CayenneLpp.c:462
LPP_VOLTAGE_SIZE
#define LPP_VOLTAGE_SIZE
Definition CayenneLpp.c:81
LPP_PARTICULATE_MATTER_1_0
#define LPP_PARTICULATE_MATTER_1_0
Definition CayenneLpp.c:72
CayenneLppAddParticulateMatter_2_5
uint8_t CayenneLppAddParticulateMatter_2_5(uint8_t channel, float concentration_2_5)
Add particulate matter 2.5mm concentration data to the buffer.
Definition CayenneLpp.c:482
LPP_TEMPERATURE_SIZE
#define LPP_TEMPERATURE_SIZE
Definition CayenneLpp.c:60
CayenneLppAddRelativeHumidity
uint8_t CayenneLppAddRelativeHumidity(uint8_t channel, float rh)
Definition CayenneLpp.c:286
LPP_MIN8_TIME
#define LPP_MIN8_TIME
Definition CayenneLpp.c:75
LPP_BAROMETRIC_PRESSURE_SIZE
#define LPP_BAROMETRIC_PRESSURE_SIZE
Definition CayenneLpp.c:63
LPP_ANALOG_INPUT
#define LPP_ANALOG_INPUT
Definition CayenneLpp.c:42
CayenneLppGetSize
uint8_t CayenneLppGetSize(void)
Definition CayenneLpp.c:124
LPP_DIGITAL_INPUT_SIZE
#define LPP_DIGITAL_INPUT_SIZE
Definition CayenneLpp.c:54
LPP_UNIX_TIME_SIZE
#define LPP_UNIX_TIME_SIZE
Definition CayenneLpp.c:84
LPP_GPS
#define LPP_GPS
Definition CayenneLpp.c:51
LPP_MIN8_TIME_SIZE
#define LPP_MIN8_TIME_SIZE
Definition CayenneLpp.c:85
CayenneLppCursor
static uint8_t CayenneLppCursor
Definition CayenneLpp.c:96
LPP_PRESENCE_SIZE
#define LPP_PRESENCE_SIZE
Definition CayenneLpp.c:59
LPP_ACCELEROMETER_SIZE
#define LPP_ACCELEROMETER_SIZE
Definition CayenneLpp.c:62
LPP_ANALOG_OUTPUT
#define LPP_ANALOG_OUTPUT
Definition CayenneLpp.c:43
LPP_ANALOG_OUTPUT_SIZE
#define LPP_ANALOG_OUTPUT_SIZE
Definition CayenneLpp.c:57
CayenneLppAddGyrometer
uint8_t CayenneLppAddGyrometer(uint8_t channel, float x, float y, float z)
Definition CayenneLpp.c:352
CayenneLppAddAccelerometer
uint8_t CayenneLppAddAccelerometer(uint8_t channel, float x, float y, float z)
Definition CayenneLpp.c:304
LPP_CONCENTRATION
#define LPP_CONCENTRATION
Definition CayenneLpp.c:69
CayenneLppAddTimeMeasureMIN8
uint8_t CayenneLppAddTimeMeasureMIN8(uint8_t channel, uint8_t timeOffsetMin8)
Add the relative time of measuring - offset from previous measured data less than 255 minutes The tim...
Definition CayenneLpp.c:519
CayenneLppAddDigitalOutput
uint8_t CayenneLppAddDigitalOutput(uint8_t channel, uint8_t value)
Definition CayenneLpp.c:170
LPP_DIGITAL_INPUT
#define LPP_DIGITAL_INPUT
Definition CayenneLpp.c:40
LPP_UNIX_TIME
#define LPP_UNIX_TIME
Definition CayenneLpp.c:74
LPP_ANALOG_INPUT_SIZE
#define LPP_ANALOG_INPUT_SIZE
Definition CayenneLpp.c:56
LPP_RELATIVE_HUMIDITY_SIZE
#define LPP_RELATIVE_HUMIDITY_SIZE
Definition CayenneLpp.c:61
LPP_BATTERY_PERC
#define LPP_BATTERY_PERC
Definition CayenneLpp.c:71
CayenneLpp.h
Implements the Cayenne Low Power Protocol.