From 091a6a89f3db62f7d5dedf298b37ec28085bee1b Mon Sep 17 00:00:00 2001 From: Wesley Kerfoot Date: Thu, 28 Jul 2022 04:20:34 -0400 Subject: [PATCH] initial commit --- .gitignore | 6 + CMakeLists.txt | 6 + README.md | 90 + components/cjson/CMakeLists.txt | 2 + components/cjson/cjson.c | 3119 +++++++++++++++++ components/cjson/component.mk | 4 + components/cjson/include/cjson.h | 300 ++ components/esp8266_wrapper/CMakeLists.txt | 3 + components/esp8266_wrapper/component.mk | 4 + components/esp8266_wrapper/esp8266_wrapper.c | 193 + .../esp8266_wrapper/include/esp8266_wrapper.h | 108 + components/sht3x/CMakeLists.txt | 3 + components/sht3x/component.mk | 4 + components/sht3x/include/sht3x.h | 280 ++ components/sht3x/include/sht3x_platform.h | 58 + components/sht3x/sht3x.c | 450 +++ example_test.py | 20 + main/CMakeLists.txt | 3 + main/plant_water.c | 731 ++++ main/plant_water.h | 61 + main/protocol_examples_common.h | 93 + 21 files changed, 5538 insertions(+) create mode 100644 .gitignore create mode 100644 CMakeLists.txt create mode 100644 README.md create mode 100644 components/cjson/CMakeLists.txt create mode 100644 components/cjson/cjson.c create mode 100644 components/cjson/component.mk create mode 100644 components/cjson/include/cjson.h create mode 100644 components/esp8266_wrapper/CMakeLists.txt create mode 100644 components/esp8266_wrapper/component.mk create mode 100644 components/esp8266_wrapper/esp8266_wrapper.c create mode 100644 components/esp8266_wrapper/include/esp8266_wrapper.h create mode 100644 components/sht3x/CMakeLists.txt create mode 100644 components/sht3x/component.mk create mode 100644 components/sht3x/include/sht3x.h create mode 100644 components/sht3x/include/sht3x_platform.h create mode 100644 components/sht3x/sht3x.c create mode 100644 example_test.py create mode 100644 main/CMakeLists.txt create mode 100644 main/plant_water.c create mode 100644 main/plant_water.h create mode 100644 main/protocol_examples_common.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..899e963 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +.cache +build +main/build +main/Kconfig.projbuild +sdkconfig +sdkconfig.old diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..beb6ac4 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,6 @@ +# The following lines of boilerplate have to be in your project's CMakeLists +# in this exact order for cmake to work correctly +cmake_minimum_required(VERSION 3.16) + +include($ENV{IDF_PATH}/tools/cmake/project.cmake) +project(plant_water) diff --git a/README.md b/README.md new file mode 100644 index 0000000..51b0959 --- /dev/null +++ b/README.md @@ -0,0 +1,90 @@ +# Example: GPIO + +(See the README.md file in the upper level 'examples' directory for more information about examples.) + +This test code shows how to configure GPIO and how to use it with interruption. + +## GPIO functions: + +| GPIO | Direction | Configuration | +| ---------------------------- | --------- | ------------------------------------------------------ | +| CONFIG_GPIO_OUTPUT_0 | output | | +| CONFIG_GPIO_OUTPUT_1 | output | | +| CONFIG_GPIO_INPUT_0 | input | pulled up, interrupt from rising edge and falling edge | +| CONFIG_GPIO_INPUT_1 | input | pulled up, interrupt from rising edge | + +## Test: + 1. Connect CONFIG_GPIO_OUTPUT_0 with CONFIG_GPIO_INPUT_0 + 2. Connect CONFIG_GPIO_OUTPUT_1 with CONFIG_GPIO_INPUT_1 + 3. Generate pulses on CONFIG_GPIO_OUTPUT_0/1, that triggers interrupt on CONFIG_GPIO_INPUT_0/1 + + **Note:** The following pin assignments are used by default, you can change them by `idf.py menuconfig` > `Example Configuration`. + +| | CONFIG_GPIO_OUTPUT_0 | CONFIG_GPIO_OUTPUT_1 | CONFIG_GPIO_INPUT_0 | CONFIG_GPIO_INPUT_1 | +| --------------- | -------------------- | -------------------- | ------------------- | ------------------- | +| ESP32-C2/ESP32H2| 8 | 9 | 4 | 5 | +| All other chips | 18 | 19 | 4 | 5 | + +## How to use example + +Before project configuration and build, be sure to set the correct chip target using `idf.py set-target `. + +### Hardware Required + +* A development board with any Espressif SoC (e.g., ESP32-DevKitC, ESP-WROVER-KIT, etc.) +* A USB cable for Power supply and programming +* Some jumper wires to connect GPIOs. + +### Configure the project + +### Build and Flash + +Build the project and flash it to the board, then run the monitor tool to view the serial output: + +Run `idf.py -p PORT flash monitor` to build, flash and monitor the project. + +(To exit the serial monitor, type ``Ctrl-]``.) + +See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html) for full steps to configure and use ESP-IDF to build projects. + +## Example Output + +As you run the example, you will see the following log: + +``` +I (317) gpio: GPIO[18]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 +I (327) gpio: GPIO[19]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 +I (337) gpio: GPIO[4]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:1 +I (347) gpio: GPIO[5]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:1 +Minimum free heap size: 289892 bytes +cnt: 0 +cnt: 1 +GPIO[4] intr, val: 1 +GPIO[5] intr, val: 1 +cnt: 2 +GPIO[4] intr, val: 0 +cnt: 3 +GPIO[4] intr, val: 1 +GPIO[5] intr, val: 1 +cnt: 4 +GPIO[4] intr, val: 0 +cnt: 5 +GPIO[4] intr, val: 1 +GPIO[5] intr, val: 1 +cnt: 6 +GPIO[4] intr, val: 0 +cnt: 7 +GPIO[4] intr, val: 1 +GPIO[5] intr, val: 1 +cnt: 8 +GPIO[4] intr, val: 0 +cnt: 9 +GPIO[4] intr, val: 1 +GPIO[5] intr, val: 1 +cnt: 10 +... +``` + +## Troubleshooting + +For any technical queries, please open an [issue](https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon. diff --git a/components/cjson/CMakeLists.txt b/components/cjson/CMakeLists.txt new file mode 100644 index 0000000..6609c6e --- /dev/null +++ b/components/cjson/CMakeLists.txt @@ -0,0 +1,2 @@ +idf_component_register(SRCS "cjson.c" + INCLUDE_DIRS "include") diff --git a/components/cjson/cjson.c b/components/cjson/cjson.c new file mode 100644 index 0000000..7b69b6e --- /dev/null +++ b/components/cjson/cjson.c @@ -0,0 +1,3119 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +/* cJSON */ +/* JSON parser in C. */ + +/* disable warnings about old C89 functions in MSVC */ +#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) +#define _CRT_SECURE_NO_DEPRECATE +#endif + +#ifdef __GNUC__ +#pragma GCC visibility push(default) +#endif +#if defined(_MSC_VER) +#pragma warning (push) +/* disable warning about single line comments in system headers */ +#pragma warning (disable : 4001) +#endif + +#include +#include +#include +#include +#include +#include +#include + +#ifdef ENABLE_LOCALES +#include +#endif + +#if defined(_MSC_VER) +#pragma warning (pop) +#endif +#ifdef __GNUC__ +#pragma GCC visibility pop +#endif + +#include "cjson.h" + +/* define our own boolean type */ +#ifdef true +#undef true +#endif +#define true ((cJSON_bool)1) + +#ifdef false +#undef false +#endif +#define false ((cJSON_bool)0) + +/* define isnan and isinf for ANSI C, if in C99 or above, isnan and isinf has been defined in math.h */ +#ifndef isinf +#define isinf(d) (isnan((d - d)) && !isnan(d)) +#endif +#ifndef isnan +#define isnan(d) (d != d) +#endif + +#ifndef NAN +#ifdef _WIN32 +#define NAN sqrt(-1.0) +#else +#define NAN 0.0/0.0 +#endif +#endif + +typedef struct { + const unsigned char *json; + size_t position; +} error; +static error global_error = { NULL, 0 }; + +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void) +{ + return (const char*) (global_error.json + global_error.position); +} + +CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item) +{ + if (!cJSON_IsString(item)) + { + return NULL; + } + + return item->valuestring; +} + +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item) +{ + if (!cJSON_IsNumber(item)) + { + return (double) NAN; + } + + return item->valuedouble; +} + +/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */ +#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 15) + #error cJSON.h and cJSON.c have different versions. Make sure that both have the same. +#endif + +CJSON_PUBLIC(const char*) cJSON_Version(void) +{ + static char version[15]; + sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH); + + return version; +} + +/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */ +static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2) +{ + if ((string1 == NULL) || (string2 == NULL)) + { + return 1; + } + + if (string1 == string2) + { + return 0; + } + + for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++) + { + if (*string1 == '\0') + { + return 0; + } + } + + return tolower(*string1) - tolower(*string2); +} + +typedef struct internal_hooks +{ + void *(CJSON_CDECL *allocate)(size_t size); + void (CJSON_CDECL *deallocate)(void *pointer); + void *(CJSON_CDECL *reallocate)(void *pointer, size_t size); +} internal_hooks; + +#if defined(_MSC_VER) +/* work around MSVC error C2322: '...' address of dllimport '...' is not static */ +static void * CJSON_CDECL internal_malloc(size_t size) +{ + return malloc(size); +} +static void CJSON_CDECL internal_free(void *pointer) +{ + free(pointer); +} +static void * CJSON_CDECL internal_realloc(void *pointer, size_t size) +{ + return realloc(pointer, size); +} +#else +#define internal_malloc malloc +#define internal_free free +#define internal_realloc realloc +#endif + +/* strlen of character literals resolved at compile time */ +#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) + +static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc }; + +static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks) +{ + size_t length = 0; + unsigned char *copy = NULL; + + if (string == NULL) + { + return NULL; + } + + length = strlen((const char*)string) + sizeof(""); + copy = (unsigned char*)hooks->allocate(length); + if (copy == NULL) + { + return NULL; + } + memcpy(copy, string, length); + + return copy; +} + +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks) +{ + if (hooks == NULL) + { + /* Reset hooks */ + global_hooks.allocate = malloc; + global_hooks.deallocate = free; + global_hooks.reallocate = realloc; + return; + } + + global_hooks.allocate = malloc; + if (hooks->malloc_fn != NULL) + { + global_hooks.allocate = hooks->malloc_fn; + } + + global_hooks.deallocate = free; + if (hooks->free_fn != NULL) + { + global_hooks.deallocate = hooks->free_fn; + } + + /* use realloc only if both free and malloc are used */ + global_hooks.reallocate = NULL; + if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free)) + { + global_hooks.reallocate = realloc; + } +} + +/* Internal constructor. */ +static cJSON *cJSON_New_Item(const internal_hooks * const hooks) +{ + cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); + if (node) + { + memset(node, '\0', sizeof(cJSON)); + } + + return node; +} + +/* Delete a cJSON structure. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item) +{ + cJSON *next = NULL; + while (item != NULL) + { + next = item->next; + if (!(item->type & cJSON_IsReference) && (item->child != NULL)) + { + cJSON_Delete(item->child); + } + if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) + { + global_hooks.deallocate(item->valuestring); + } + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + global_hooks.deallocate(item->string); + } + global_hooks.deallocate(item); + item = next; + } +} + +/* get the decimal point character of the current locale */ +static unsigned char get_decimal_point(void) +{ +#ifdef ENABLE_LOCALES + struct lconv *lconv = localeconv(); + return (unsigned char) lconv->decimal_point[0]; +#else + return '.'; +#endif +} + +typedef struct +{ + const unsigned char *content; + size_t length; + size_t offset; + size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */ + internal_hooks hooks; +} parse_buffer; + +/* check if the given size is left to read in a given parse buffer (starting with 1) */ +#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) +/* check if the buffer can be accessed at the given index (starting with 0) */ +#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) +#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) +/* get a pointer to the buffer at the position */ +#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) + +/* Parse the input text to generate a number, and populate the result into item. */ +static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer) +{ + double number = 0; + unsigned char *after_end = NULL; + unsigned char number_c_string[64]; + unsigned char decimal_point = get_decimal_point(); + size_t i = 0; + + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; + } + + /* copy the number into a temporary buffer and replace '.' with the decimal point + * of the current locale (for strtod) + * This also takes care of '\0' not necessarily being available for marking the end of the input */ + for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) + { + switch (buffer_at_offset(input_buffer)[i]) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '+': + case '-': + case 'e': + case 'E': + number_c_string[i] = buffer_at_offset(input_buffer)[i]; + break; + + case '.': + number_c_string[i] = decimal_point; + break; + + default: + goto loop_end; + } + } +loop_end: + number_c_string[i] = '\0'; + + number = strtod((const char*)number_c_string, (char**)&after_end); + if (number_c_string == after_end) + { + return false; /* parse_error */ + } + + item->valuedouble = number; + + /* use saturation in case of overflow */ + if (number >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (number <= (double)INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)number; + } + + item->type = cJSON_Number; + + input_buffer->offset += (size_t)(after_end - number_c_string); + return true; +} + +/* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number) +{ + if (number >= INT_MAX) + { + object->valueint = INT_MAX; + } + else if (number <= (double)INT_MIN) + { + object->valueint = INT_MIN; + } + else + { + object->valueint = (int)number; + } + + return object->valuedouble = number; +} + +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring) +{ + char *copy = NULL; + /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */ + if (!(object->type & cJSON_String) || (object->type & cJSON_IsReference)) + { + return NULL; + } + if (strlen(valuestring) <= strlen(object->valuestring)) + { + strcpy(object->valuestring, valuestring); + return object->valuestring; + } + copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks); + if (copy == NULL) + { + return NULL; + } + if (object->valuestring != NULL) + { + cJSON_free(object->valuestring); + } + object->valuestring = copy; + + return copy; +} + +typedef struct +{ + unsigned char *buffer; + size_t length; + size_t offset; + size_t depth; /* current nesting depth (for formatted printing) */ + cJSON_bool noalloc; + cJSON_bool format; /* is this print a formatted print */ + internal_hooks hooks; +} printbuffer; + +/* realloc printbuffer if necessary to have at least "needed" bytes more */ +static unsigned char* ensure(printbuffer * const p, size_t needed) +{ + unsigned char *newbuffer = NULL; + size_t newsize = 0; + + if ((p == NULL) || (p->buffer == NULL)) + { + return NULL; + } + + if ((p->length > 0) && (p->offset >= p->length)) + { + /* make sure that offset is valid */ + return NULL; + } + + if (needed > INT_MAX) + { + /* sizes bigger than INT_MAX are currently not supported */ + return NULL; + } + + needed += p->offset + 1; + if (needed <= p->length) + { + return p->buffer + p->offset; + } + + if (p->noalloc) { + return NULL; + } + + /* calculate new buffer size */ + if (needed > (INT_MAX / 2)) + { + /* overflow of int, use INT_MAX if possible */ + if (needed <= INT_MAX) + { + newsize = INT_MAX; + } + else + { + return NULL; + } + } + else + { + newsize = needed * 2; + } + + if (p->hooks.reallocate != NULL) + { + /* reallocate with realloc if available */ + newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); + if (newbuffer == NULL) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + } + else + { + /* otherwise reallocate manually */ + newbuffer = (unsigned char*)p->hooks.allocate(newsize); + if (!newbuffer) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + + memcpy(newbuffer, p->buffer, p->offset + 1); + p->hooks.deallocate(p->buffer); + } + p->length = newsize; + p->buffer = newbuffer; + + return newbuffer + p->offset; +} + +/* calculate the new length of the string in a printbuffer and update the offset */ +static void update_offset(printbuffer * const buffer) +{ + const unsigned char *buffer_pointer = NULL; + if ((buffer == NULL) || (buffer->buffer == NULL)) + { + return; + } + buffer_pointer = buffer->buffer + buffer->offset; + + buffer->offset += strlen((const char*)buffer_pointer); +} + +/* securely comparison of floating-point variables */ +static cJSON_bool compare_double(double a, double b) +{ + double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b); + return (fabs(a - b) <= maxVal * DBL_EPSILON); +} + +/* Render the number nicely from the given item into a string. */ +static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + double d = item->valuedouble; + int length = 0; + size_t i = 0; + unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */ + unsigned char decimal_point = get_decimal_point(); + double test = 0.0; + + if (output_buffer == NULL) + { + return false; + } + + /* This checks for NaN and Infinity */ + if (isnan(d) || isinf(d)) + { + length = sprintf((char*)number_buffer, "null"); + } + else if(d == (double)item->valueint) + { + length = sprintf((char*)number_buffer, "%d", item->valueint); + } + else + { + /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ + length = sprintf((char*)number_buffer, "%1.15g", d); + + /* Check whether the original double can be recovered */ + if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d)) + { + /* If not, print with 17 decimal places of precision */ + length = sprintf((char*)number_buffer, "%1.17g", d); + } + } + + /* sprintf failed or buffer overrun occurred */ + if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) + { + return false; + } + + /* reserve appropriate space in the output */ + output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); + if (output_pointer == NULL) + { + return false; + } + + /* copy the printed number to the output and replace locale + * dependent decimal point with '.' */ + for (i = 0; i < ((size_t)length); i++) + { + if (number_buffer[i] == decimal_point) + { + output_pointer[i] = '.'; + continue; + } + + output_pointer[i] = number_buffer[i]; + } + output_pointer[i] = '\0'; + + output_buffer->offset += (size_t)length; + + return true; +} + +/* parse 4 digit hexadecimal number */ +static unsigned parse_hex4(const unsigned char * const input) +{ + unsigned int h = 0; + size_t i = 0; + + for (i = 0; i < 4; i++) + { + /* parse digit */ + if ((input[i] >= '0') && (input[i] <= '9')) + { + h += (unsigned int) input[i] - '0'; + } + else if ((input[i] >= 'A') && (input[i] <= 'F')) + { + h += (unsigned int) 10 + input[i] - 'A'; + } + else if ((input[i] >= 'a') && (input[i] <= 'f')) + { + h += (unsigned int) 10 + input[i] - 'a'; + } + else /* invalid */ + { + return 0; + } + + if (i < 3) + { + /* shift left to make place for the next nibble */ + h = h << 4; + } + } + + return h; +} + +/* converts a UTF-16 literal to UTF-8 + * A literal can be one or two sequences of the form \uXXXX */ +static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer) +{ + long unsigned int codepoint = 0; + unsigned int first_code = 0; + const unsigned char *first_sequence = input_pointer; + unsigned char utf8_length = 0; + unsigned char utf8_position = 0; + unsigned char sequence_length = 0; + unsigned char first_byte_mark = 0; + + if ((input_end - first_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + /* get the first utf16 sequence */ + first_code = parse_hex4(first_sequence + 2); + + /* check that the code is valid */ + if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) + { + goto fail; + } + + /* UTF16 surrogate pair */ + if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) + { + const unsigned char *second_sequence = first_sequence + 6; + unsigned int second_code = 0; + sequence_length = 12; /* \uXXXX\uXXXX */ + + if ((input_end - second_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) + { + /* missing second half of the surrogate pair */ + goto fail; + } + + /* get the second utf16 sequence */ + second_code = parse_hex4(second_sequence + 2); + /* check that the code is valid */ + if ((second_code < 0xDC00) || (second_code > 0xDFFF)) + { + /* invalid second half of the surrogate pair */ + goto fail; + } + + + /* calculate the unicode codepoint from the surrogate pair */ + codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF)); + } + else + { + sequence_length = 6; /* \uXXXX */ + codepoint = first_code; + } + + /* encode as UTF-8 + * takes at maximum 4 bytes to encode: + * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ + if (codepoint < 0x80) + { + /* normal ascii, encoding 0xxxxxxx */ + utf8_length = 1; + } + else if (codepoint < 0x800) + { + /* two bytes, encoding 110xxxxx 10xxxxxx */ + utf8_length = 2; + first_byte_mark = 0xC0; /* 11000000 */ + } + else if (codepoint < 0x10000) + { + /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ + utf8_length = 3; + first_byte_mark = 0xE0; /* 11100000 */ + } + else if (codepoint <= 0x10FFFF) + { + /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ + utf8_length = 4; + first_byte_mark = 0xF0; /* 11110000 */ + } + else + { + /* invalid unicode codepoint */ + goto fail; + } + + /* encode as utf8 */ + for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) + { + /* 10xxxxxx */ + (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); + codepoint >>= 6; + } + /* encode first byte */ + if (utf8_length > 1) + { + (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); + } + else + { + (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); + } + + *output_pointer += utf8_length; + + return sequence_length; + +fail: + return 0; +} + +/* Parse the input text into an unescaped cinput, and populate item. */ +static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer) +{ + const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; + const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; + unsigned char *output_pointer = NULL; + unsigned char *output = NULL; + + /* not a string */ + if (buffer_at_offset(input_buffer)[0] != '\"') + { + goto fail; + } + + { + /* calculate approximate size of the output (overestimate) */ + size_t allocation_length = 0; + size_t skipped_bytes = 0; + while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) + { + /* is escape sequence */ + if (input_end[0] == '\\') + { + if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) + { + /* prevent buffer overflow when last input character is a backslash */ + goto fail; + } + skipped_bytes++; + input_end++; + } + input_end++; + } + if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) + { + goto fail; /* string ended unexpectedly */ + } + + /* This is at most how much we need for the output */ + allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; + output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); + if (output == NULL) + { + goto fail; /* allocation failure */ + } + } + + output_pointer = output; + /* loop through the string literal */ + while (input_pointer < input_end) + { + if (*input_pointer != '\\') + { + *output_pointer++ = *input_pointer++; + } + /* escape sequence */ + else + { + unsigned char sequence_length = 2; + if ((input_end - input_pointer) < 1) + { + goto fail; + } + + switch (input_pointer[1]) + { + case 'b': + *output_pointer++ = '\b'; + break; + case 'f': + *output_pointer++ = '\f'; + break; + case 'n': + *output_pointer++ = '\n'; + break; + case 'r': + *output_pointer++ = '\r'; + break; + case 't': + *output_pointer++ = '\t'; + break; + case '\"': + case '\\': + case '/': + *output_pointer++ = input_pointer[1]; + break; + + /* UTF-16 literal */ + case 'u': + sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer); + if (sequence_length == 0) + { + /* failed to convert UTF16-literal to UTF-8 */ + goto fail; + } + break; + + default: + goto fail; + } + input_pointer += sequence_length; + } + } + + /* zero terminate the output */ + *output_pointer = '\0'; + + item->type = cJSON_String; + item->valuestring = (char*)output; + + input_buffer->offset = (size_t) (input_end - input_buffer->content); + input_buffer->offset++; + + return true; + +fail: + if (output != NULL) + { + input_buffer->hooks.deallocate(output); + } + + if (input_pointer != NULL) + { + input_buffer->offset = (size_t)(input_pointer - input_buffer->content); + } + + return false; +} + +/* Render the cstring provided to an escaped version that can be printed. */ +static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer) +{ + const unsigned char *input_pointer = NULL; + unsigned char *output = NULL; + unsigned char *output_pointer = NULL; + size_t output_length = 0; + /* numbers of additional characters needed for escaping */ + size_t escape_characters = 0; + + if (output_buffer == NULL) + { + return false; + } + + /* empty string */ + if (input == NULL) + { + output = ensure(output_buffer, sizeof("\"\"")); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "\"\""); + + return true; + } + + /* set "flag" to 1 if something needs to be escaped */ + for (input_pointer = input; *input_pointer; input_pointer++) + { + switch (*input_pointer) + { + case '\"': + case '\\': + case '\b': + case '\f': + case '\n': + case '\r': + case '\t': + /* one character escape sequence */ + escape_characters++; + break; + default: + if (*input_pointer < 32) + { + /* UTF-16 escape sequence uXXXX */ + escape_characters += 5; + } + break; + } + } + output_length = (size_t)(input_pointer - input) + escape_characters; + + output = ensure(output_buffer, output_length + sizeof("\"\"")); + if (output == NULL) + { + return false; + } + + /* no characters have to be escaped */ + if (escape_characters == 0) + { + output[0] = '\"'; + memcpy(output + 1, input, output_length); + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; + + return true; + } + + output[0] = '\"'; + output_pointer = output + 1; + /* copy the string */ + for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) + { + if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) + { + /* normal character, copy */ + *output_pointer = *input_pointer; + } + else + { + /* character needs to be escaped */ + *output_pointer++ = '\\'; + switch (*input_pointer) + { + case '\\': + *output_pointer = '\\'; + break; + case '\"': + *output_pointer = '\"'; + break; + case '\b': + *output_pointer = 'b'; + break; + case '\f': + *output_pointer = 'f'; + break; + case '\n': + *output_pointer = 'n'; + break; + case '\r': + *output_pointer = 'r'; + break; + case '\t': + *output_pointer = 't'; + break; + default: + /* escape and print as unicode codepoint */ + sprintf((char*)output_pointer, "u%04x", *input_pointer); + output_pointer += 4; + break; + } + } + } + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; + + return true; +} + +/* Invoke print_string_ptr (which is useful) on an item. */ +static cJSON_bool print_string(const cJSON * const item, printbuffer * const p) +{ + return print_string_ptr((unsigned char*)item->valuestring, p); +} + +/* Predeclare these prototypes. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer); + +/* Utility to jump whitespace and cr/lf */ +static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL)) + { + return NULL; + } + + if (cannot_access_at_index(buffer, 0)) + { + return buffer; + } + + while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) + { + buffer->offset++; + } + + if (buffer->offset == buffer->length) + { + buffer->offset--; + } + + return buffer; +} + +/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */ +static parse_buffer *skip_utf8_bom(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) + { + return NULL; + } + + if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) + { + buffer->offset += 3; + } + + return buffer; +} + +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + size_t buffer_length; + + if (NULL == value) + { + return NULL; + } + + /* Adding null character size due to require_null_terminated. */ + buffer_length = strlen(value) + sizeof(""); + + return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated); +} + +/* Parse an object - create a new root, and populate. */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; + cJSON *item = NULL; + + /* reset error position */ + global_error.json = NULL; + global_error.position = 0; + + if (value == NULL || 0 == buffer_length) + { + goto fail; + } + + buffer.content = (const unsigned char*)value; + buffer.length = buffer_length; + buffer.offset = 0; + buffer.hooks = global_hooks; + + item = cJSON_New_Item(&global_hooks); + if (item == NULL) /* memory fail */ + { + goto fail; + } + + if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) + { + /* parse failure. ep is set. */ + goto fail; + } + + /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ + if (require_null_terminated) + { + buffer_skip_whitespace(&buffer); + if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') + { + goto fail; + } + } + if (return_parse_end) + { + *return_parse_end = (const char*)buffer_at_offset(&buffer); + } + + return item; + +fail: + if (item != NULL) + { + cJSON_Delete(item); + } + + if (value != NULL) + { + error local_error; + local_error.json = (const unsigned char*)value; + local_error.position = 0; + + if (buffer.offset < buffer.length) + { + local_error.position = buffer.offset; + } + else if (buffer.length > 0) + { + local_error.position = buffer.length - 1; + } + + if (return_parse_end != NULL) + { + *return_parse_end = (const char*)local_error.json + local_error.position; + } + + global_error = local_error; + } + + return NULL; +} + +/* Default options for cJSON_Parse */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value) +{ + return cJSON_ParseWithOpts(value, 0, 0); +} + +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length) +{ + return cJSON_ParseWithLengthOpts(value, buffer_length, 0, 0); +} + +#define cjson_min(a, b) (((a) < (b)) ? (a) : (b)) + +static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks) +{ + static const size_t default_buffer_size = 256; + printbuffer buffer[1]; + unsigned char *printed = NULL; + + memset(buffer, 0, sizeof(buffer)); + + /* create buffer */ + buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); + buffer->length = default_buffer_size; + buffer->format = format; + buffer->hooks = *hooks; + if (buffer->buffer == NULL) + { + goto fail; + } + + /* print the value */ + if (!print_value(item, buffer)) + { + goto fail; + } + update_offset(buffer); + + /* check if reallocate is available */ + if (hooks->reallocate != NULL) + { + printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); + if (printed == NULL) { + goto fail; + } + buffer->buffer = NULL; + } + else /* otherwise copy the JSON over to a new buffer */ + { + printed = (unsigned char*) hooks->allocate(buffer->offset + 1); + if (printed == NULL) + { + goto fail; + } + memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1)); + printed[buffer->offset] = '\0'; /* just to be sure */ + + /* free the buffer */ + hooks->deallocate(buffer->buffer); + } + + return printed; + +fail: + if (buffer->buffer != NULL) + { + hooks->deallocate(buffer->buffer); + } + + if (printed != NULL) + { + hooks->deallocate(printed); + } + + return NULL; +} + +/* Render a cJSON item/entity/structure to text. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item) +{ + return (char*)print(item, true, &global_hooks); +} + +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item) +{ + return (char*)print(item, false, &global_hooks); +} + +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if (prebuffer < 0) + { + return NULL; + } + + p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer); + if (!p.buffer) + { + return NULL; + } + + p.length = (size_t)prebuffer; + p.offset = 0; + p.noalloc = false; + p.format = fmt; + p.hooks = global_hooks; + + if (!print_value(item, &p)) + { + global_hooks.deallocate(p.buffer); + return NULL; + } + + return (char*)p.buffer; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if ((length < 0) || (buffer == NULL)) + { + return false; + } + + p.buffer = (unsigned char*)buffer; + p.length = (size_t)length; + p.offset = 0; + p.noalloc = true; + p.format = format; + p.hooks = global_hooks; + + return print_value(item, &p); +} + +/* Parser core - when encountering text, process appropriately. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer) +{ + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; /* no input */ + } + + /* parse the different types of values */ + /* null */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) + { + item->type = cJSON_NULL; + input_buffer->offset += 4; + return true; + } + /* false */ + if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) + { + item->type = cJSON_False; + input_buffer->offset += 5; + return true; + } + /* true */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) + { + item->type = cJSON_True; + item->valueint = 1; + input_buffer->offset += 4; + return true; + } + /* string */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) + { + return parse_string(item, input_buffer); + } + /* number */ + if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) + { + return parse_number(item, input_buffer); + } + /* array */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) + { + return parse_array(item, input_buffer); + } + /* object */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) + { + return parse_object(item, input_buffer); + } + + return false; +} + +/* Render a value to text. */ +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output = NULL; + + if ((item == NULL) || (output_buffer == NULL)) + { + return false; + } + + switch ((item->type) & 0xFF) + { + case cJSON_NULL: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "null"); + return true; + + case cJSON_False: + output = ensure(output_buffer, 6); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "false"); + return true; + + case cJSON_True: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "true"); + return true; + + case cJSON_Number: + return print_number(item, output_buffer); + + case cJSON_Raw: + { + size_t raw_length = 0; + if (item->valuestring == NULL) + { + return false; + } + + raw_length = strlen(item->valuestring) + sizeof(""); + output = ensure(output_buffer, raw_length); + if (output == NULL) + { + return false; + } + memcpy(output, item->valuestring, raw_length); + return true; + } + + case cJSON_String: + return print_string(item, output_buffer); + + case cJSON_Array: + return print_array(item, output_buffer); + + case cJSON_Object: + return print_object(item, output_buffer); + + default: + return false; + } +} + +/* Build an array from input text. */ +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* head of the linked list */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (buffer_at_offset(input_buffer)[0] != '[') + { + /* not an array */ + goto fail; + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) + { + /* empty array */ + goto success; + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + /* parse next value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') + { + goto fail; /* expected end of array */ + } + +success: + input_buffer->depth--; + + if (head != NULL) { + head->prev = current_item; + } + + item->type = cJSON_Array; + item->child = head; + + input_buffer->offset++; + + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an array to text */ +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_element = item->child; + + if (output_buffer == NULL) + { + return false; + } + + /* Compose the output array. */ + /* opening square bracket */ + output_pointer = ensure(output_buffer, 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer = '['; + output_buffer->offset++; + output_buffer->depth++; + + while (current_element != NULL) + { + if (!print_value(current_element, output_buffer)) + { + return false; + } + update_offset(output_buffer); + if (current_element->next) + { + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ','; + if(output_buffer->format) + { + *output_pointer++ = ' '; + } + *output_pointer = '\0'; + output_buffer->offset += length; + } + current_element = current_element->next; + } + + output_pointer = ensure(output_buffer, 2); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ']'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Build an object from the text. */ +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* linked list head */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) + { + goto fail; /* not an object */ + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) + { + goto success; /* empty object */ + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + /* parse the name of the child */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_string(current_item, input_buffer)) + { + goto fail; /* failed to parse name */ + } + buffer_skip_whitespace(input_buffer); + + /* swap valuestring and string, because we parsed the name */ + current_item->string = current_item->valuestring; + current_item->valuestring = NULL; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) + { + goto fail; /* invalid object */ + } + + /* parse the value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) + { + goto fail; /* expected end of object */ + } + +success: + input_buffer->depth--; + + if (head != NULL) { + head->prev = current_item; + } + + item->type = cJSON_Object; + item->child = head; + + input_buffer->offset++; + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an object to text. */ +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_item = item->child; + + if (output_buffer == NULL) + { + return false; + } + + /* Compose the output: */ + length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer++ = '{'; + output_buffer->depth++; + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + output_buffer->offset += length; + + while (current_item) + { + if (output_buffer->format) + { + size_t i; + output_pointer = ensure(output_buffer, output_buffer->depth); + if (output_pointer == NULL) + { + return false; + } + for (i = 0; i < output_buffer->depth; i++) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += output_buffer->depth; + } + + /* print key */ + if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ':'; + if (output_buffer->format) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += length; + + /* print value */ + if (!print_value(current_item, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + /* print comma if not last */ + length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0)); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + if (current_item->next) + { + *output_pointer++ = ','; + } + + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + *output_pointer = '\0'; + output_buffer->offset += length; + + current_item = current_item->next; + } + + output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); + if (output_pointer == NULL) + { + return false; + } + if (output_buffer->format) + { + size_t i; + for (i = 0; i < (output_buffer->depth - 1); i++) + { + *output_pointer++ = '\t'; + } + } + *output_pointer++ = '}'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Get Array size/item / object item. */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array) +{ + cJSON *child = NULL; + size_t size = 0; + + if (array == NULL) + { + return 0; + } + + child = array->child; + + while(child != NULL) + { + size++; + child = child->next; + } + + /* FIXME: Can overflow here. Cannot be fixed without breaking the API */ + + return (int)size; +} + +static cJSON* get_array_item(const cJSON *array, size_t index) +{ + cJSON *current_child = NULL; + + if (array == NULL) + { + return NULL; + } + + current_child = array->child; + while ((current_child != NULL) && (index > 0)) + { + index--; + current_child = current_child->next; + } + + return current_child; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index) +{ + if (index < 0) + { + return NULL; + } + + return get_array_item(array, (size_t)index); +} + +static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive) +{ + cJSON *current_element = NULL; + + if ((object == NULL) || (name == NULL)) + { + return NULL; + } + + current_element = object->child; + if (case_sensitive) + { + while ((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0)) + { + current_element = current_element->next; + } + } + else + { + while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0)) + { + current_element = current_element->next; + } + } + + if ((current_element == NULL) || (current_element->string == NULL)) { + return NULL; + } + + return current_element; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, false); +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string) +{ + return cJSON_GetObjectItem(object, string) ? 1 : 0; +} + +/* Utility for array list handling. */ +static void suffix_object(cJSON *prev, cJSON *item) +{ + prev->next = item; + item->prev = prev; +} + +/* Utility for handling references. */ +static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks) +{ + cJSON *reference = NULL; + if (item == NULL) + { + return NULL; + } + + reference = cJSON_New_Item(hooks); + if (reference == NULL) + { + return NULL; + } + + memcpy(reference, item, sizeof(cJSON)); + reference->string = NULL; + reference->type |= cJSON_IsReference; + reference->next = reference->prev = NULL; + return reference; +} + +static cJSON_bool add_item_to_array(cJSON *array, cJSON *item) +{ + cJSON *child = NULL; + + if ((item == NULL) || (array == NULL) || (array == item)) + { + return false; + } + + child = array->child; + /* + * To find the last item in array quickly, we use prev in array + */ + if (child == NULL) + { + /* list is empty, start new one */ + array->child = item; + item->prev = item; + item->next = NULL; + } + else + { + /* append to the end */ + if (child->prev) + { + suffix_object(child->prev, item); + array->child->prev = item; + } + } + + return true; +} + +/* Add item to array/object. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item) +{ + return add_item_to_array(array, item); +} + +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic push +#endif +#ifdef __GNUC__ +#pragma GCC diagnostic ignored "-Wcast-qual" +#endif +/* helper function to cast away const */ +static void* cast_away_const(const void* string) +{ + return (void*)string; +} +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic pop +#endif + + +static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key) +{ + char *new_key = NULL; + int new_type = cJSON_Invalid; + + if ((object == NULL) || (string == NULL) || (item == NULL) || (object == item)) + { + return false; + } + + if (constant_key) + { + new_key = (char*)cast_away_const(string); + new_type = item->type | cJSON_StringIsConst; + } + else + { + new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks); + if (new_key == NULL) + { + return false; + } + + new_type = item->type & ~cJSON_StringIsConst; + } + + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + hooks->deallocate(item->string); + } + + item->string = new_key; + item->type = new_type; + + return add_item_to_array(object, item); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) +{ + return add_item_to_object(object, string, item, &global_hooks, false); +} + +/* Add an item to an object with constant string as key */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) +{ + return add_item_to_object(object, string, item, &global_hooks, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) +{ + if (array == NULL) + { + return false; + } + + return add_item_to_array(array, create_reference(item, &global_hooks)); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) +{ + if ((object == NULL) || (string == NULL)) + { + return false; + } + + return add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false); +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name) +{ + cJSON *null = cJSON_CreateNull(); + if (add_item_to_object(object, name, null, &global_hooks, false)) + { + return null; + } + + cJSON_Delete(null); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name) +{ + cJSON *true_item = cJSON_CreateTrue(); + if (add_item_to_object(object, name, true_item, &global_hooks, false)) + { + return true_item; + } + + cJSON_Delete(true_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name) +{ + cJSON *false_item = cJSON_CreateFalse(); + if (add_item_to_object(object, name, false_item, &global_hooks, false)) + { + return false_item; + } + + cJSON_Delete(false_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean) +{ + cJSON *bool_item = cJSON_CreateBool(boolean); + if (add_item_to_object(object, name, bool_item, &global_hooks, false)) + { + return bool_item; + } + + cJSON_Delete(bool_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number) +{ + cJSON *number_item = cJSON_CreateNumber(number); + if (add_item_to_object(object, name, number_item, &global_hooks, false)) + { + return number_item; + } + + cJSON_Delete(number_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string) +{ + cJSON *string_item = cJSON_CreateString(string); + if (add_item_to_object(object, name, string_item, &global_hooks, false)) + { + return string_item; + } + + cJSON_Delete(string_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw) +{ + cJSON *raw_item = cJSON_CreateRaw(raw); + if (add_item_to_object(object, name, raw_item, &global_hooks, false)) + { + return raw_item; + } + + cJSON_Delete(raw_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name) +{ + cJSON *object_item = cJSON_CreateObject(); + if (add_item_to_object(object, name, object_item, &global_hooks, false)) + { + return object_item; + } + + cJSON_Delete(object_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name) +{ + cJSON *array = cJSON_CreateArray(); + if (add_item_to_object(object, name, array, &global_hooks, false)) + { + return array; + } + + cJSON_Delete(array); + return NULL; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item) +{ + if ((parent == NULL) || (item == NULL)) + { + return NULL; + } + + if (item != parent->child) + { + /* not the first element */ + item->prev->next = item->next; + } + if (item->next != NULL) + { + /* not the last element */ + item->next->prev = item->prev; + } + + if (item == parent->child) + { + /* first element */ + parent->child = item->next; + } + else if (item->next == NULL) + { + /* last element */ + parent->child->prev = item->prev; + } + + /* make sure the detached item doesn't point anywhere anymore */ + item->prev = NULL; + item->next = NULL; + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which) +{ + if (which < 0) + { + return NULL; + } + + return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which) +{ + cJSON_Delete(cJSON_DetachItemFromArray(array, which)); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItem(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObject(object, string)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string)); +} + +/* Replace array/object items with new ones. */ +CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) +{ + cJSON *after_inserted = NULL; + + if (which < 0) + { + return false; + } + + after_inserted = get_array_item(array, (size_t)which); + if (after_inserted == NULL) + { + return add_item_to_array(array, newitem); + } + + newitem->next = after_inserted; + newitem->prev = after_inserted->prev; + after_inserted->prev = newitem; + if (after_inserted == array->child) + { + array->child = newitem; + } + else + { + newitem->prev->next = newitem; + } + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement) +{ + if ((parent == NULL) || (replacement == NULL) || (item == NULL)) + { + return false; + } + + if (replacement == item) + { + return true; + } + + replacement->next = item->next; + replacement->prev = item->prev; + + if (replacement->next != NULL) + { + replacement->next->prev = replacement; + } + if (parent->child == item) + { + if (parent->child->prev == parent->child) + { + replacement->prev = replacement; + } + parent->child = replacement; + } + else + { /* + * To find the last item in array quickly, we use prev in array. + * We can't modify the last item's next pointer where this item was the parent's child + */ + if (replacement->prev != NULL) + { + replacement->prev->next = replacement; + } + if (replacement->next == NULL) + { + parent->child->prev = replacement; + } + } + + item->next = NULL; + item->prev = NULL; + cJSON_Delete(item); + + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) +{ + if (which < 0) + { + return false; + } + + return cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem); +} + +static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive) +{ + if ((replacement == NULL) || (string == NULL)) + { + return false; + } + + /* replace the name in the replacement */ + if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL)) + { + cJSON_free(replacement->string); + } + replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + if (replacement->string == NULL) + { + return false; + } + + replacement->type &= ~cJSON_StringIsConst; + + return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) +{ + return replace_item_in_object(object, string, newitem, false); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem) +{ + return replace_item_in_object(object, string, newitem, true); +} + +/* Create basic types: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_NULL; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_True; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = boolean ? cJSON_True : cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Number; + item->valuedouble = num; + + /* use saturation in case of overflow */ + if (num >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (num <= (double)INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)num; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_String; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) + { + item->type = cJSON_String | cJSON_IsReference; + item->valuestring = (char*)cast_away_const(string); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Object | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) { + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Array | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Raw; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type=cJSON_Array; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item) + { + item->type = cJSON_Object; + } + + return item; +} + +/* Create Arrays: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if (!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber((double)numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (strings == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for (i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateString(strings[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p,n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +/* Duplication */ +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) +{ + cJSON *newitem = NULL; + cJSON *child = NULL; + cJSON *next = NULL; + cJSON *newchild = NULL; + + /* Bail on bad ptr */ + if (!item) + { + goto fail; + } + /* Create new item */ + newitem = cJSON_New_Item(&global_hooks); + if (!newitem) + { + goto fail; + } + /* Copy over all vars */ + newitem->type = item->type & (~cJSON_IsReference); + newitem->valueint = item->valueint; + newitem->valuedouble = item->valuedouble; + if (item->valuestring) + { + newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks); + if (!newitem->valuestring) + { + goto fail; + } + } + if (item->string) + { + newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks); + if (!newitem->string) + { + goto fail; + } + } + /* If non-recursive, then we're done! */ + if (!recurse) + { + return newitem; + } + /* Walk the ->next chain for the child. */ + child = item->child; + while (child != NULL) + { + newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */ + if (!newchild) + { + goto fail; + } + if (next != NULL) + { + /* If newitem->child already set, then crosswire ->prev and ->next and move on */ + next->next = newchild; + newchild->prev = next; + next = newchild; + } + else + { + /* Set newitem->child and move to it */ + newitem->child = newchild; + next = newchild; + } + child = child->next; + } + if (newitem && newitem->child) + { + newitem->child->prev = newchild; + } + + return newitem; + +fail: + if (newitem != NULL) + { + cJSON_Delete(newitem); + } + + return NULL; +} + +static void skip_oneline_comment(char **input) +{ + *input += static_strlen("//"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if ((*input)[0] == '\n') { + *input += static_strlen("\n"); + return; + } + } +} + +static void skip_multiline_comment(char **input) +{ + *input += static_strlen("/*"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if (((*input)[0] == '*') && ((*input)[1] == '/')) + { + *input += static_strlen("*/"); + return; + } + } +} + +static void minify_string(char **input, char **output) { + (*output)[0] = (*input)[0]; + *input += static_strlen("\""); + *output += static_strlen("\""); + + + for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) { + (*output)[0] = (*input)[0]; + + if ((*input)[0] == '\"') { + (*output)[0] = '\"'; + *input += static_strlen("\""); + *output += static_strlen("\""); + return; + } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) { + (*output)[1] = (*input)[1]; + *input += static_strlen("\""); + *output += static_strlen("\""); + } + } +} + +CJSON_PUBLIC(void) cJSON_Minify(char *json) +{ + char *into = json; + + if (json == NULL) + { + return; + } + + while (json[0] != '\0') + { + switch (json[0]) + { + case ' ': + case '\t': + case '\r': + case '\n': + json++; + break; + + case '/': + if (json[1] == '/') + { + skip_oneline_comment(&json); + } + else if (json[1] == '*') + { + skip_multiline_comment(&json); + } else { + json++; + } + break; + + case '\"': + minify_string(&json, (char**)&into); + break; + + default: + into[0] = json[0]; + json++; + into++; + } + } + + /* and null-terminate. */ + *into = '\0'; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Invalid; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_False; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xff) == cJSON_True; +} + + +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & (cJSON_True | cJSON_False)) != 0; +} +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_NULL; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Number; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_String; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Array; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Object; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Raw; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive) +{ + if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF))) + { + return false; + } + + /* check if type is valid */ + switch (a->type & 0xFF) + { + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + case cJSON_Number: + case cJSON_String: + case cJSON_Raw: + case cJSON_Array: + case cJSON_Object: + break; + + default: + return false; + } + + /* identical objects are equal */ + if (a == b) + { + return true; + } + + switch (a->type & 0xFF) + { + /* in these cases and equal type is enough */ + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + return true; + + case cJSON_Number: + if (compare_double(a->valuedouble, b->valuedouble)) + { + return true; + } + return false; + + case cJSON_String: + case cJSON_Raw: + if ((a->valuestring == NULL) || (b->valuestring == NULL)) + { + return false; + } + if (strcmp(a->valuestring, b->valuestring) == 0) + { + return true; + } + + return false; + + case cJSON_Array: + { + cJSON *a_element = a->child; + cJSON *b_element = b->child; + + for (; (a_element != NULL) && (b_element != NULL);) + { + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + + a_element = a_element->next; + b_element = b_element->next; + } + + /* one of the arrays is longer than the other */ + if (a_element != b_element) { + return false; + } + + return true; + } + + case cJSON_Object: + { + cJSON *a_element = NULL; + cJSON *b_element = NULL; + cJSON_ArrayForEach(a_element, a) + { + /* TODO This has O(n^2) runtime, which is horrible! */ + b_element = get_object_item(b, a_element->string, case_sensitive); + if (b_element == NULL) + { + return false; + } + + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + } + + /* doing this twice, once on a and b to prevent true comparison if a subset of b + * TODO: Do this the proper way, this is just a fix for now */ + cJSON_ArrayForEach(b_element, b) + { + a_element = get_object_item(a, b_element->string, case_sensitive); + if (a_element == NULL) + { + return false; + } + + if (!cJSON_Compare(b_element, a_element, case_sensitive)) + { + return false; + } + } + + return true; + } + + default: + return false; + } +} + +CJSON_PUBLIC(void *) cJSON_malloc(size_t size) +{ + return global_hooks.allocate(size); +} + +CJSON_PUBLIC(void) cJSON_free(void *object) +{ + global_hooks.deallocate(object); +} diff --git a/components/cjson/component.mk b/components/cjson/component.mk new file mode 100644 index 0000000..8913aa1 --- /dev/null +++ b/components/cjson/component.mk @@ -0,0 +1,4 @@ +# +# Component makefile. +# +COMPONENT_ADD_INCLUDEDIRS := . diff --git a/components/cjson/include/cjson.h b/components/cjson/include/cjson.h new file mode 100644 index 0000000..95a9cf6 --- /dev/null +++ b/components/cjson/include/cjson.h @@ -0,0 +1,300 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +#ifndef cJSON__h +#define cJSON__h + +#ifdef __cplusplus +extern "C" +{ +#endif + +#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)) +#define __WINDOWS__ +#endif + +#ifdef __WINDOWS__ + +/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 3 define options: + +CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols +CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default) +CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol + +For *nix builds that support visibility attribute, you can define similar behavior by + +setting default visibility to hidden by adding +-fvisibility=hidden (for gcc) +or +-xldscope=hidden (for sun cc) +to CFLAGS + +then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does + +*/ + +#define CJSON_CDECL __cdecl +#define CJSON_STDCALL __stdcall + +/* export symbols by default, this is necessary for copy pasting the C and header file */ +#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_EXPORT_SYMBOLS +#endif + +#if defined(CJSON_HIDE_SYMBOLS) +#define CJSON_PUBLIC(type) type CJSON_STDCALL +#elif defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL +#elif defined(CJSON_IMPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL +#endif +#else /* !__WINDOWS__ */ +#define CJSON_CDECL +#define CJSON_STDCALL + +#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY) +#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type +#else +#define CJSON_PUBLIC(type) type +#endif +#endif + +/* project version */ +#define CJSON_VERSION_MAJOR 1 +#define CJSON_VERSION_MINOR 7 +#define CJSON_VERSION_PATCH 15 + +#include + +/* cJSON Types: */ +#define cJSON_Invalid (0) +#define cJSON_False (1 << 0) +#define cJSON_True (1 << 1) +#define cJSON_NULL (1 << 2) +#define cJSON_Number (1 << 3) +#define cJSON_String (1 << 4) +#define cJSON_Array (1 << 5) +#define cJSON_Object (1 << 6) +#define cJSON_Raw (1 << 7) /* raw json */ + +#define cJSON_IsReference 256 +#define cJSON_StringIsConst 512 + +/* The cJSON structure: */ +typedef struct cJSON +{ + /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ + struct cJSON *next; + struct cJSON *prev; + /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ + struct cJSON *child; + + /* The type of the item, as above. */ + int type; + + /* The item's string, if type==cJSON_String and type == cJSON_Raw */ + char *valuestring; + /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ + int valueint; + /* The item's number, if type==cJSON_Number */ + double valuedouble; + + /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ + char *string; +} cJSON; + +typedef struct cJSON_Hooks +{ + /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */ + void *(CJSON_CDECL *malloc_fn)(size_t sz); + void (CJSON_CDECL *free_fn)(void *ptr); +} cJSON_Hooks; + +typedef int cJSON_bool; + +/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them. + * This is to prevent stack overflows. */ +#ifndef CJSON_NESTING_LIMIT +#define CJSON_NESTING_LIMIT 1000 +#endif + +/* returns the version of cJSON as a string */ +CJSON_PUBLIC(const char*) cJSON_Version(void); + +/* Supply malloc, realloc and free functions to cJSON */ +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks); + +/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */ +/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length); +/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */ +/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated); + +/* Render a cJSON entity to text for transfer/storage. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item); +/* Render a cJSON entity to text for transfer/storage without any formatting. */ +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item); +/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */ +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt); +/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */ +/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */ +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format); +/* Delete a cJSON entity and all subentities. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item); + +/* Returns the number of items in an array (or object). */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array); +/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */ +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index); +/* Get item "string" from object. Case insensitive. */ +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string); +/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void); + +/* Check item type and return its value */ +CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item); +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item); + +/* These functions check the type of an item */ +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item); + +/* These calls create a cJSON item of the appropriate type. */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean); +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num); +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string); +/* raw json */ +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw); +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void); + +/* Create a string where valuestring references a string so + * it will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string); +/* Create an object/array that only references it's elements so + * they will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child); +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child); + +/* These utilities create an Array of count items. + * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count); + +/* Append item to the specified array/object. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item); +/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object. + * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before + * writing to `item->string` */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item); +/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item); + +/* Remove/Detach items from Arrays/Objects. */ +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string); + +/* Update array items. */ +CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */ +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem); + +/* Duplicate a cJSON item */ +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse); +/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will + * need to be released. With recurse!=0, it will duplicate any children connected to the item. + * The item->next and ->prev pointers are always zero on return from Duplicate. */ +/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal. + * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */ +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive); + +/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings. + * The input pointer json cannot point to a read-only address area, such as a string constant, + * but should point to a readable and writable address area. */ +CJSON_PUBLIC(void) cJSON_Minify(char *json); + +/* Helper functions for creating and adding items to an object at the same time. + * They return the added item or NULL on failure. */ +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean); +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number); +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string); +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw); +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name); + +/* When assigning an integer value, it needs to be propagated to valuedouble too. */ +#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number)) +/* helper for the cJSON_SetNumberValue macro */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number); +#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number)) +/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */ +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring); + +/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/ +#define cJSON_SetBoolValue(object, boolValue) ( \ + (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \ + (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \ + cJSON_Invalid\ +) + +/* Macro for iterating over an array or object */ +#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next) + +/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */ +CJSON_PUBLIC(void *) cJSON_malloc(size_t size); +CJSON_PUBLIC(void) cJSON_free(void *object); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/components/esp8266_wrapper/CMakeLists.txt b/components/esp8266_wrapper/CMakeLists.txt new file mode 100644 index 0000000..c263147 --- /dev/null +++ b/components/esp8266_wrapper/CMakeLists.txt @@ -0,0 +1,3 @@ +idf_component_register(SRCS "esp8266_wrapper.c" + INCLUDE_DIRS "include" + REQUIRES "driver") diff --git a/components/esp8266_wrapper/component.mk b/components/esp8266_wrapper/component.mk new file mode 100644 index 0000000..8913aa1 --- /dev/null +++ b/components/esp8266_wrapper/component.mk @@ -0,0 +1,4 @@ +# +# Component makefile. +# +COMPONENT_ADD_INCLUDEDIRS := . diff --git a/components/esp8266_wrapper/esp8266_wrapper.c b/components/esp8266_wrapper/esp8266_wrapper.c new file mode 100644 index 0000000..bddd82c --- /dev/null +++ b/components/esp8266_wrapper/esp8266_wrapper.c @@ -0,0 +1,193 @@ +/** + * Wrapper module for source code compatibility with esp-open-rtos. + */ + +#ifdef ESP_PLATFORM // ESP32 (ESP-IDF) + +#include +#include + +#include "driver/spi_master.h" +#include "driver/spi_common.h" + +#include "driver/i2c.h" +#include "driver/gpio.h" + +#include "esp8266_wrapper.h" + +// esp-open-rtos SDK function wrapper + +uint32_t sdk_system_get_time () { + struct timeval time; + gettimeofday(&time,0); + return (uint32_t) (time.tv_sec*(long int)1e6 + time.tv_usec); +} + +bool gpio_isr_service_installed = false; +bool auto_pull_up = false; +bool auto_pull_down = true; + +esp_err_t gpio_set_interrupt(gpio_num_t gpio, + gpio_int_type_t type, + gpio_interrupt_handler_t handler) +{ + if (!gpio_isr_service_installed) + gpio_isr_service_installed = (gpio_install_isr_service(0) == ESP_OK); + + gpio_config_t gpio_cfg = { + .pin_bit_mask = ((uint64_t)(((uint64_t)1)<< gpio)), + .mode = GPIO_MODE_INPUT, + .pull_up_en = auto_pull_up, + .pull_down_en = auto_pull_down, + .intr_type = type + }; + gpio_config(&gpio_cfg); + + // set interrupt handler + gpio_isr_handler_add(gpio, (gpio_isr_t)handler, (void*)gpio); + + return ESP_OK; +} + +void gpio_enable (gpio_num_t gpio, const gpio_mode_t mode) +{ + gpio_config_t gpio_cfg = { + .pin_bit_mask = ((uint64_t)(((uint64_t)1)<< gpio)), + .mode = mode, + .pull_up_en = auto_pull_up, + .pull_down_en = auto_pull_down, + }; + gpio_config(&gpio_cfg); +} + +// esp-open-rtos I2C interface wrapper + +#define I2C_ACK_VAL 0x0 +#define I2C_NACK_VAL 0x1 + +void i2c_init (int bus, gpio_num_t scl, gpio_num_t sda, uint32_t freq) +{ + i2c_config_t conf = {0}; + conf.mode = I2C_MODE_MASTER; + conf.sda_io_num = sda; + conf.scl_io_num = scl; + conf.sda_pullup_en = GPIO_PULLUP_ENABLE; + conf.scl_pullup_en = GPIO_PULLUP_ENABLE; + conf.master.clk_speed = freq; + conf.clk_flags = 0; + i2c_param_config(bus, &conf); + i2c_driver_install(bus, I2C_MODE_MASTER, 0, 0, 0); +} + +int i2c_slave_write (uint8_t bus, uint8_t addr, const uint8_t *reg, + uint8_t *data, uint32_t len) +{ + i2c_cmd_handle_t cmd = i2c_cmd_link_create(); + i2c_master_start(cmd); + i2c_master_write_byte(cmd, addr << 1 | I2C_MASTER_WRITE, true); + if (reg) + i2c_master_write_byte(cmd, *reg, true); + if (data) + i2c_master_write(cmd, data, len, true); + i2c_master_stop(cmd); + esp_err_t err = i2c_master_cmd_begin(bus, cmd, 1000 / portTICK_PERIOD_MS); + i2c_cmd_link_delete(cmd); + + return err; +} + +int i2c_slave_read (uint8_t bus, uint8_t addr, const uint8_t *reg, + uint8_t *data, uint32_t len) +{ + if (len == 0) return true; + + i2c_cmd_handle_t cmd = i2c_cmd_link_create(); + if (reg) + { + i2c_master_start(cmd); + i2c_master_write_byte(cmd, ( addr << 1 ) | I2C_MASTER_WRITE, true); + i2c_master_write_byte(cmd, *reg, true); + if (!data) + i2c_master_stop(cmd); + } + if (data) + { + i2c_master_start(cmd); + i2c_master_write_byte(cmd, ( addr << 1 ) | I2C_MASTER_READ, true); + if (len > 1) i2c_master_read(cmd, data, len-1, I2C_ACK_VAL); + i2c_master_read_byte(cmd, data + len-1, I2C_NACK_VAL); + i2c_master_stop(cmd); + } + esp_err_t err = i2c_master_cmd_begin(bus, cmd, 1000 / portTICK_PERIOD_MS); + i2c_cmd_link_delete(cmd); + + return err; +} + +// esp-open-rtos SPI interface wrapper + +#define SPI_MAX_BUS 3 // ESP32 features three SPIs (SPI_HOST, HSPI_HOST and VSPI_HOST) +#define SPI_MAX_CS 34 // GPIO 33 is the last port that can be used as output + +spi_device_handle_t spi_handles[SPI_MAX_CS] = { 0 }; + +bool spi_bus_init (spi_host_device_t host, uint8_t sclk , uint8_t miso, uint8_t mosi) +{ + spi_bus_config_t spi_bus_cfg = { + .miso_io_num=miso, + .mosi_io_num=mosi, + .sclk_io_num=sclk, + .quadwp_io_num=-1, + .quadhd_io_num=-1 + }; + return (spi_bus_initialize(host, &spi_bus_cfg, 1) == ESP_OK); +} + +bool spi_device_init (uint8_t bus, uint8_t cs) +{ + if (bus >= SPI_MAX_BUS || cs >= SPI_MAX_CS) + return false; + + if ((spi_handles[cs] = malloc (sizeof(spi_device_handle_t))) == 0) + return false; + + spi_device_interface_config_t dev_cfg = { + .clock_speed_hz = 1e6, // 1 MHz clock + .mode = 0, // SPI mode 0 + .spics_io_num = cs, // CS GPIO + .queue_size = 1, + .flags = 0, // no flags set + .command_bits = 0, // no command bits used + .address_bits = 0, // register address is first byte in MOSI + .dummy_bits = 0 // no dummy bits used + }; + + if (spi_bus_add_device(bus, &dev_cfg, &(spi_handles[cs])) != ESP_OK) + { + free (spi_handles[cs]); + return false; + } + + return true; +} + +size_t spi_transfer_pf (uint8_t bus, uint8_t cs, const uint8_t *mosi, uint8_t *miso, uint16_t len) +{ + spi_transaction_t spi_trans; + + if (cs >= SPI_MAX_CS) + return 0; + + memset(&spi_trans, 0, sizeof(spi_trans)); // zero out spi_trans; + spi_trans.tx_buffer = mosi; + spi_trans.rx_buffer = miso; + spi_trans.length=len*8; + + if (spi_device_transmit(spi_handles[cs], &spi_trans) != ESP_OK) + return 0; + + return len; +} + +#endif // ESP32 (ESP-IDF) + diff --git a/components/esp8266_wrapper/include/esp8266_wrapper.h b/components/esp8266_wrapper/include/esp8266_wrapper.h new file mode 100644 index 0000000..ad1164b --- /dev/null +++ b/components/esp8266_wrapper/include/esp8266_wrapper.h @@ -0,0 +1,108 @@ +/* + * Wrapper module for source code compatibility with esp-open-rtos. + */ + +#ifndef __ESP8266_WRAPPER_H__ +#define __ESP8266_WRAPPER_H__ + +#ifdef ESP_PLATFORM // ESP32 (ESP-IDF) + +#ifdef __cplusplus +extern "C" { +#endif + +#include "driver/gpio.h" +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "freertos/queue.h" + +#include "driver/uart.h" +#include "driver/spi_common.h" + +/* + * esp-open-rtos SDK function wrapper + */ + +uint32_t sdk_system_get_time (); + +#define uart_set_baud(p,r) uart_set_baudrate (p,r) + +#define IRAM IRAM_ATTR + +#define GPIO_INTTYPE_NONE GPIO_INTR_DISABLE +#define GPIO_INTTYPE_EDGE_POS GPIO_INTR_POSEDGE +#define GPIO_INTTYPE_EDGE_NEG GPIO_INTR_NEGEDGE +#define GPIO_INTTYPE_EDGE_ANY GPIO_INTR_ANYEDGE +#define GPIO_INTTYPE_LEVEL_LOW GPIO_INTR_LOW_LEVEL +#define GPIO_INTTYPE_LEVEL_HIGH GPIO_INTR_HIGH_LEVEL + +// Set it true, if isr_service is already installed anywhere else or should +// not be installed, otherwise, *gpio_set_interrupt* install it when it is +// called first time. +extern bool gpio_isr_service_installed; + +// pull-up, pull-down configuration used for next call of *gpio_set_interrupt* +extern bool auto_pull_up; // default false; +extern bool auto_pull_down; // default true; + +// ISR handler type compatible to the ESP8266 +typedef void (*gpio_interrupt_handler_t)(uint8_t gpio); + +// GPIO set interrupt function compatible to ESP8266 +esp_err_t gpio_set_interrupt(gpio_num_t gpio, + gpio_int_type_t type, + gpio_interrupt_handler_t handler); + +// GPIO enable function compatible to esp-open-rtos +#define GPIO_INPUT GPIO_MODE_INPUT +#define GPIO_OUTPUT GPIO_MODE_OUTPUT +#define GPIO_OUT_OPEN_DRAIN GPIO_MODE_OUTPUT_OD + +void gpio_enable (gpio_num_t gpio, const gpio_mode_t mode); + +/* + * esp-open-rtos I2C interface wrapper + */ + +#define I2C_FREQ_80K 80000 +#define I2C_FREQ_100K 100000 +#define I2C_FREQ_400K 400000 +#define I2C_FREQ_500K 500000 +#define I2C_FREQ_600K 600000 +#define I2C_FREQ_800K 800000 +#define I2C_FREQ_1000K 1000000 +#define I2C_FREQ_1300K 1300000 + +#define i2c_set_clock_stretch(bus,cs) // not needed on ESP32 + +void i2c_init (int bus, gpio_num_t scl, gpio_num_t sda, uint32_t freq); + +int i2c_slave_write (uint8_t bus, uint8_t addr, const uint8_t *reg, + uint8_t *data, uint32_t len); + +int i2c_slave_read (uint8_t bus, uint8_t addr, const uint8_t *reg, + uint8_t *data, uint32_t len); + +/* + * esp-open-rtos SPI interface wrapper + */ + +bool spi_bus_init (spi_host_device_t host, + uint8_t sclk , uint8_t miso, uint8_t mosi); + +bool spi_device_init (uint8_t bus, uint8_t cs); + +size_t spi_transfer_pf(uint8_t bus, uint8_t cs, + const uint8_t *mosi, uint8_t *miso, uint16_t len); + +/* + * freertos api wrapper + */ + +#ifdef __cplusplus +} +#endif + +#endif // ESP_PLATFORM + +#endif // __ESP8266_WRAPPER_H__ diff --git a/components/sht3x/CMakeLists.txt b/components/sht3x/CMakeLists.txt new file mode 100644 index 0000000..4252bb9 --- /dev/null +++ b/components/sht3x/CMakeLists.txt @@ -0,0 +1,3 @@ +idf_component_register(SRCS "sht3x.c" + INCLUDE_DIRS "include" + REQUIRES "esp8266_wrapper") diff --git a/components/sht3x/component.mk b/components/sht3x/component.mk new file mode 100644 index 0000000..8913aa1 --- /dev/null +++ b/components/sht3x/component.mk @@ -0,0 +1,4 @@ +# +# Component makefile. +# +COMPONENT_ADD_INCLUDEDIRS := . diff --git a/components/sht3x/include/sht3x.h b/components/sht3x/include/sht3x.h new file mode 100644 index 0000000..bf602c5 --- /dev/null +++ b/components/sht3x/include/sht3x.h @@ -0,0 +1,280 @@ +/* + * Driver for Sensirion SHT3x digital temperature and humidity sensor + * connected to I2C + * + * This driver is for the usage with the ESP8266 and FreeRTOS (esp-open-rtos) + * [https://github.com/SuperHouse/esp-open-rtos]. It is also working with ESP32 + * and ESP-IDF [https://github.com/espressif/esp-idf.git] as well as Linux + * based systems using a wrapper library for ESP8266 functions. + * + * ---------------------------------------------------------------- + * + * The BSD License (3-clause license) + * + * Copyright (c) 2017 Gunar Schorcht (https://github.com/gschorcht) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __SHT3x_H__ +#define __SHT3x_H__ + +// Uncomment to enable debug output +// #define SHT3x_DEBUG_LEVEL_1 // only error messages +// #define SHT3x_DEBUG_LEVEL_2 // error and debug messages + +#include "stdint.h" +#include "stdbool.h" + +#include "sht3x_platform.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// definition of possible I2C slave addresses +#define SHT3x_ADDR_1 0x44 // ADDR pin connected to GND/VSS (default) +#define SHT3x_ADDR_2 0x45 // ADDR pin connected to VDD + +// definition of error codes +#define SHT3x_OK 0 +#define SHT3x_NOK -1 + +#define SHT3x_I2C_ERROR_MASK 0x000f +#define SHT3x_DRV_ERROR_MASK 0xfff0 + +// error codes for I2C interface ORed with SHT3x error codes +#define SHT3x_I2C_READ_FAILED 1 +#define SHT3x_I2C_SEND_CMD_FAILED 2 +#define SHT3x_I2C_BUSY 3 + +// SHT3x driver error codes OR ed with error codes for I2C interface +#define SHT3x_MEAS_NOT_STARTED (1 << 8) +#define SHT3x_MEAS_ALREADY_RUNNING (2 << 8) +#define SHT3x_MEAS_STILL_RUNNING (3 << 8) +#define SHT3x_READ_RAW_DATA_FAILED (4 << 8) + +#define SHT3x_SEND_MEAS_CMD_FAILED (5 << 8) +#define SHT3x_SEND_RESET_CMD_FAILED (6 << 8) +#define SHT3x_SEND_STATUS_CMD_FAILED (7 << 8) +#define SHT3x_SEND_FETCH_CMD_FAILED (8 << 8) + +#define SHT3x_WRONG_CRC_TEMPERATURE (9 << 8) +#define SHT3x_WRONG_CRC_HUMIDITY (10 << 8) + +#define SHT3x_RAW_DATA_SIZE 6 + +/** + * @brief raw data type + */ +typedef uint8_t sht3x_raw_data_t [SHT3x_RAW_DATA_SIZE]; + + +/** + * @brief possible measurement modes + */ +typedef enum { + sht3x_single_shot = 0, // one single measurement + sht3x_periodic_05mps, // periodic with 0.5 measurements per second (mps) + sht3x_periodic_1mps, // periodic with 1 measurements per second (mps) + sht3x_periodic_2mps, // periodic with 2 measurements per second (mps) + sht3x_periodic_4mps, // periodic with 4 measurements per second (mps) + sht3x_periodic_10mps // periodic with 10 measurements per second (mps) +} sht3x_mode_t; + + +/** + * @brief possible repeatability modes + */ +typedef enum { + sht3x_high = 0, + sht3x_medium, + sht3x_low +} sht3x_repeat_t; + +/** + * @brief SHT3x sensor device data structure type + */ +typedef struct { + + uint32_t error_code; // combined error codes + + uint8_t bus; // I2C bus at which sensor is connected + uint8_t addr; // I2C slave address of the sensor + + sht3x_mode_t mode; // used measurement mode + sht3x_repeat_t repeatability; // used repeatability + + bool meas_started; // indicates whether measurement started + uint32_t meas_start_time; // measurement start time in us + bool meas_first; // first measurement in periodic mode + +} sht3x_sensor_t; + + +/** + * @brief Initialize a SHT3x sensor + * + * The function creates a data structure describing the sensor and + * initializes the sensor device. + * + * @param bus I2C bus at which the sensor is connected + * @param addr I2C slave address of the sensor + * @return pointer to sensor data structure, or NULL on error + */ +sht3x_sensor_t* sht3x_init_sensor (uint8_t bus, uint8_t addr); + + +/** + * @brief High level measurement function + * + * For convenience this function comprises all three steps to perform + * one measurement in only one function: + * + * 1. Starts a measurement in single shot mode with high reliability + * 2. Waits using *vTaskDelay* until measurement results are available + * 3. Returns the results in kind of floating point sensor values + * + * This function is the easiest way to use the sensor. It is most suitable + * for users that don't want to have the control on sensor details. + * + * Please note: The function delays the calling task up to 30 ms to wait for + * the the measurement results. This might lead to problems when the function + * is called from a software timer callback function. + * + * @param dev pointer to sensor device data structure + * @param temperature returns temperature in degree Celsius + * @param humidity returns humidity in percent + * @return true on success, false on error + */ +bool sht3x_measure (sht3x_sensor_t* dev, float* temperature, float* humidity); + + +/** + * @brief Start the measurement in single shot or periodic mode + * + * The function starts the measurement either in *single shot mode* + * (exactly one measurement) or *periodic mode* (periodic measurements) + * with given repeatabilty. + * + * In the *single shot mode*, this function has to be called for each + * measurement. The measurement duration has to be waited every time + * before the results can be fetched. + * + * In the *periodic mode*, this function has to be called only once. Also + * the measurement duration has to be waited only once until the first + * results are available. After this first measurement, the sensor then + * automatically performs all subsequent measurements. The rate of periodic + * measurements can be 10, 4, 2, 1 or 0.5 measurements per second (mps). + * + * Please note: Due to inaccuracies in timing of the sensor, the user task + * should fetch the results at a lower rate. The rate of the periodic + * measurements is defined by the parameter *mode*. + * + * @param dev pointer to sensor device data structure + * @param mode measurement mode, see type *sht3x_mode_t* + * @param repeat repeatability, see type *sht3x_repeat_t* + * @return true on success, false on error + */ +bool sht3x_start_measurement (sht3x_sensor_t* dev, sht3x_mode_t mode, + sht3x_repeat_t repeat); + +/** + * @brief Get the duration of a measurement in RTOS ticks. + * + * The function returns the duration in RTOS ticks required by the sensor to + * perform a measurement for the given repeatability. Once a measurement is + * started with function *sht3x_start_measurement* the user task can use this + * duration in RTOS ticks directly to wait with function *vTaskDelay* until + * the measurement results can be fetched. + * + * Please note: The duration only depends on repeatability level. Therefore, + * it can be considered as constant for a repeatibility. + * + * @param repeat repeatability, see type *sht3x_repeat_t* + * @return measurement duration given in RTOS ticks + */ +uint8_t sht3x_get_measurement_duration (sht3x_repeat_t repeat); + + +/** + * @brief Read measurement results from sensor as raw data + * + * The function read measurement results from the sensor, checks the CRC + * checksum and stores them in the byte array as following. + * + * data[0] = Temperature MSB + * data[1] = Temperature LSB + * data[2] = Temperature CRC + * data[3] = Pressure MSB + * data[4] = Pressure LSB + * data[2] = Pressure CRC + * + * In case that there are no new data that can be read, the function fails. + * + * @param dev pointer to sensor device data structure + * @param raw_data byte array in which raw data are stored + * @return true on success, false on error + */ +bool sht3x_get_raw_data(sht3x_sensor_t* dev, sht3x_raw_data_t raw_data); + + +/** + * @brief Computes sensor values from raw data + * + * @param raw_data byte array that contains raw data + * @param temperature returns temperature in degree Celsius + * @param humidity returns humidity in percent + * @return true on success, false on error + */ +bool sht3x_compute_values (sht3x_raw_data_t raw_data, + float* temperature, float* humidity); + + +/** + * @brief Get measurement results in form of sensor values + * + * The function combines function *sht3x_read_raw_data* and function + * *sht3x_compute_values* to get the measurement results. + * + * In case that there are no results that can be read, the function fails. + * + * @param dev pointer to sensor device data structure + * @param temperature returns temperature in degree Celsius + * @param humidity returns humidity in percent + * @return true on success, false on error + */ +bool sht3x_get_results (sht3x_sensor_t* dev, + float* temperature, float* humidity); + + +#ifdef __cplusplus +} +#endif + +#endif /* __SHT3x_H__ */ diff --git a/components/sht3x/include/sht3x_platform.h b/components/sht3x/include/sht3x_platform.h new file mode 100644 index 0000000..da7c27f --- /dev/null +++ b/components/sht3x/include/sht3x_platform.h @@ -0,0 +1,58 @@ +/* + * Driver for AMS CCS811 digital gas sensor connected to I2C. + * + * This driver is for the usage with the ESP8266 and FreeRTOS (esp-open-rtos) + * [https://github.com/SuperHouse/esp-open-rtos]. It is also working with ESP32 + * and ESP-IDF [https://github.com/espressif/esp-idf.git] as well as Linux + * based systems using a wrapper library for ESP8266 functions. + * + * --------------------------------------------------------------------------- + * + * The BSD License (3-clause license) + * + * Copyright (c) 2017 Gunar Schorcht (https://github.com/gschorcht) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * Platform file: platform specific definitions, includes and functions + */ + +#ifndef __CCS811_PLATFORM_H__ +#define __CCS811_PLATFORM_H__ + +#ifdef ESP_PLATFORM // ESP32 (ESP-IDF) + +// platform specific includes +#include "esp8266_wrapper.h" +#include + +#endif // ESP_PLATFORM + +#endif // __CCS811_PLATFORM_H__ diff --git a/components/sht3x/sht3x.c b/components/sht3x/sht3x.c new file mode 100644 index 0000000..a85a541 --- /dev/null +++ b/components/sht3x/sht3x.c @@ -0,0 +1,450 @@ +/* + * Driver for Sensirion SHT3x digital temperature and humidity sensor + * connected to I2C + * + * This driver is for the usage with the ESP8266 and FreeRTOS (esp-open-rtos) + * [https://github.com/SuperHouse/esp-open-rtos]. It is also working with ESP32 + * and ESP-IDF [https://github.com/espressif/esp-idf.git] as well as Linux + * based systems using a wrapper library for ESP8266 functions. + * + * ---------------------------------------------------------------- + * + * The BSD License (3-clause license) + * + * Copyright (c) 2017 Gunar Schorcht (https://github.com/gschorcht) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include + +#include "sht3x.h" + +#define SHT3x_STATUS_CMD 0xF32D +#define SHT3x_CLEAR_STATUS_CMD 0x3041 +#define SHT3x_RESET_CMD 0x30A2 +#define SHT3x_FETCH_DATA_CMD 0xE000 +#define SHT3x_HEATER_OFF_CMD 0x3066 + +const uint16_t SHT3x_MEASURE_CMD[6][3] = { + {0x2400,0x240b,0x2416}, // [SINGLE_SHOT][H,M,L] without clock stretching + {0x2032,0x2024,0x202f}, // [PERIODIC_05][H,M,L] + {0x2130,0x2126,0x212d}, // [PERIODIC_1 ][H,M,L] + {0x2236,0x2220,0x222b}, // [PERIODIC_2 ][H,M,L] + {0x2234,0x2322,0x2329}, // [PERIODIC_4 ][H,M,L] + {0x2737,0x2721,0x272a} }; // [PERIODIC_10][H,M,L] + +// due to the fact that ticks can be smaller than portTICK_PERIOD_MS, one and +// a half tick period added to the duration to be sure that waiting time for +// the results is long enough +#define TIME_TO_TICKS(ms) (1 + ((ms) + (portTICK_PERIOD_MS-1) + portTICK_PERIOD_MS/2 ) / portTICK_PERIOD_MS) + +#define SHT3x_MEAS_DURATION_REP_HIGH 15 +#define SHT3x_MEAS_DURATION_REP_MEDIUM 6 +#define SHT3x_MEAS_DURATION_REP_LOW 4 + +// measurement durations in us +const uint16_t SHT3x_MEAS_DURATION_US[3] = { SHT3x_MEAS_DURATION_REP_HIGH * 1000, + SHT3x_MEAS_DURATION_REP_MEDIUM * 1000, + SHT3x_MEAS_DURATION_REP_LOW * 1000 }; + +// measurement durations in RTOS ticks +const uint8_t SHT3x_MEAS_DURATION_TICKS[3] = { TIME_TO_TICKS(SHT3x_MEAS_DURATION_REP_HIGH), + TIME_TO_TICKS(SHT3x_MEAS_DURATION_REP_MEDIUM), + TIME_TO_TICKS(SHT3x_MEAS_DURATION_REP_LOW) }; + +#if defined(SHT3x_DEBUG_LEVEL_2) +#define debug(s, f, ...) printf("%s %s: " s "\n", "SHT3x", f, ## __VA_ARGS__) +#define debug_dev(s, f, d, ...) printf("%s %s: bus %d, addr %02x - " s "\n", "SHT3x", f, d->bus, d->addr, ## __VA_ARGS__) +#else +#define debug(s, f, ...) +#define debug_dev(s, f, d, ...) +#endif + +#if defined(SHT3x_DEBUG_LEVEL_1) || defined(SHT3x_DEBUG_LEVEL_2) +#define error(s, f, ...) printf("%s %s: " s "\n", "SHT3x", f, ## __VA_ARGS__) +#define error_dev(s, f, d, ...) printf("%s %s: bus %d, addr %02x - " s "\n", "SHT3x", f, d->bus, d->addr, ## __VA_ARGS__) +#else +#define error(s, f, ...) +#define error_dev(s, f, d, ...) +#endif + +/** Forward declaration of function for internal use */ + +static bool sht3x_is_measuring (sht3x_sensor_t*); +static bool sht3x_send_command (sht3x_sensor_t*, uint16_t); +static bool sht3x_read_data (sht3x_sensor_t*, uint8_t*, uint32_t); +static bool sht3x_get_status (sht3x_sensor_t*, uint16_t*); +static bool sht3x_reset (sht3x_sensor_t*); + +static uint8_t crc8 (uint8_t data[], int len); + +/** ------------------------------------------------ */ + +bool sht3x_init_driver() +{ + return true; +} + + +sht3x_sensor_t* sht3x_init_sensor(uint8_t bus, uint8_t addr) +{ + sht3x_sensor_t* dev; + + if ((dev = malloc (sizeof(sht3x_sensor_t))) == NULL) { + printf("Failed to allocate memory\n"); + return NULL; + } + + // inititalize sensor data structure + dev->bus = bus; + dev->addr = addr; + dev->mode = sht3x_single_shot; + dev->meas_start_time = 0; + dev->meas_started = false; + dev->meas_first = false; + + uint16_t status; + + // try to reset the sensor + if (!sht3x_reset(dev)) + { + printf("could not reset the sensor\n"); + } + + // check again the status after clear status command + if (!sht3x_get_status(dev, &status)) + { + printf("could not get sensor status\n"); + free(dev); + return NULL; + } + + printf("sensor initialized\n"); + return dev; +} + + +bool sht3x_measure (sht3x_sensor_t* dev, float* temperature, float* humidity) +{ + if (!dev || (!temperature && !humidity)) return false; + + if (!sht3x_start_measurement (dev, sht3x_single_shot, sht3x_high)) { + printf("Could not start measurement\n"); + return false; + } + + vTaskDelay (SHT3x_MEAS_DURATION_TICKS[sht3x_high]); + + sht3x_raw_data_t raw_data; + + if (!sht3x_get_raw_data (dev, raw_data)) { + printf("Could not get raw data\n"); + return false; + } + + return sht3x_compute_values (raw_data, temperature, humidity); +} + + +bool sht3x_start_measurement (sht3x_sensor_t* dev, sht3x_mode_t mode, sht3x_repeat_t repeat) +{ + if (!dev) return false; + + dev->error_code = SHT3x_OK; + dev->mode = mode; + dev->repeatability = repeat; + + // start measurement according to selected mode and return an duration estimate + if (!sht3x_send_command(dev, SHT3x_MEASURE_CMD[mode][repeat])) + { + error_dev ("could not send start measurment command", __FUNCTION__, dev); + dev->error_code |= SHT3x_SEND_MEAS_CMD_FAILED; + return false; + } + + dev->meas_start_time = sdk_system_get_time (); + printf("start time = %d\n", dev->meas_start_time); + dev->meas_started = true; + dev->meas_first = true; + + return true; +} + + +uint8_t sht3x_get_measurement_duration (sht3x_repeat_t repeat) +{ + return SHT3x_MEAS_DURATION_TICKS[repeat]; // in RTOS ticks +} + + +bool sht3x_get_raw_data(sht3x_sensor_t* dev, sht3x_raw_data_t raw_data) +{ + if (!dev || !raw_data) { + printf("dev = %p, raw_data = %p\n", dev, raw_data); + return false; + } + + dev->error_code = SHT3x_OK; + + if (!dev->meas_started) + { + printf ("measurement is not started\n"); + dev->error_code = SHT3x_MEAS_NOT_STARTED; + return sht3x_is_measuring (dev); + } + + if (sht3x_is_measuring(dev)) + { + printf("measurement is still running\n"); + dev->error_code = SHT3x_MEAS_STILL_RUNNING; + return false; + } + + // send fetch command in any periodic mode (mode > 0) before read raw data + if (dev->mode && !sht3x_send_command(dev, SHT3x_FETCH_DATA_CMD)) + { + printf ("send fetch command failed\n"); + dev->error_code |= SHT3x_SEND_FETCH_CMD_FAILED; + return false; + } + + // read raw data + if (!sht3x_read_data(dev, raw_data, sizeof(sht3x_raw_data_t))) + { + printf("read raw data failed\n"); + dev->error_code |= SHT3x_READ_RAW_DATA_FAILED; + return false; + } + + // reset first measurement flag + dev->meas_first = false; + + // reset measurement started flag in single shot mode + if (dev->mode == sht3x_single_shot) + dev->meas_started = false; + + // check temperature crc + if (crc8(raw_data,2) != raw_data[2]) + { + printf("CRC check for temperature data failed\n"); + dev->error_code |= SHT3x_WRONG_CRC_TEMPERATURE; + return false; + } + + // check humidity crc + if (crc8(raw_data+3,2) != raw_data[5]) + { + printf ("CRC check for humidity data failed\n"); + dev->error_code |= SHT3x_WRONG_CRC_HUMIDITY; + return false; + } + + return true; +} + + +bool sht3x_compute_values (sht3x_raw_data_t raw_data, float* temperature, float* humidity) +{ + if (!raw_data) { + printf("raw_data was falsey\n"); + return false; + } + + if (temperature) + *temperature = ((((raw_data[0] * 256.0) + raw_data[1]) * 175) / 65535.0) - 45; + + if (humidity) + *humidity = ((((raw_data[3] * 256.0) + raw_data[4]) * 100) / 65535.0); + + return true; +} + + +bool sht3x_get_results (sht3x_sensor_t* dev, float* temperature, float* humidity) +{ + if (!dev || (!temperature && !humidity)) return false; + + sht3x_raw_data_t raw_data; + + if (!sht3x_get_raw_data (dev, raw_data)) + return false; + + return sht3x_compute_values (raw_data, temperature, humidity); +} + +/* Functions for internal use only */ + +static bool sht3x_is_measuring (sht3x_sensor_t* dev) +{ + if (!dev) return false; + + dev->error_code = SHT3x_OK; + + // not running if measurement is not started at all or + // it is not the first measurement in periodic mode + if (!dev->meas_started || !dev->meas_first) + return false; + + // not running if time elapsed is greater than duration + printf("start time = %d\n", dev->meas_start_time); + printf("current time = %d\n", sdk_system_get_time()); + printf("difference = %d\n", sdk_system_get_time() - dev->meas_start_time); + uint32_t elapsed = sdk_system_get_time() - dev->meas_start_time; + + return elapsed < SHT3x_MEAS_DURATION_US[dev->repeatability]; +} + + +static bool sht3x_send_command(sht3x_sensor_t* dev, uint16_t cmd) +{ + if (!dev) { + printf("dev was falsey in sht3x_send_command\n"); + return false; + } + + uint8_t data[2] = { cmd >> 8, cmd & 0xff }; + + printf("send command MSB=%02x LSB=%02x\n", data[0], data[1]); + + int err = i2c_slave_write(dev->bus, dev->addr, 0, data, 2); + + if (err) + { + dev->error_code |= (err == -EBUSY) ? SHT3x_I2C_BUSY : SHT3x_I2C_SEND_CMD_FAILED; + printf ("i2c error %d on write command %02x\n", err, cmd); + printf("err = %d\n", err); + printf("busy = %d\n", -EBUSY); + return false; + } + + return true; +} + +static bool sht3x_read_data(sht3x_sensor_t* dev, uint8_t *data, uint32_t len) +{ + if (!dev) return false; + int err = i2c_slave_read(dev->bus, dev->addr, 0, data, len); + + if (err) + { + dev->error_code |= (err == -EBUSY) ? SHT3x_I2C_BUSY : SHT3x_I2C_READ_FAILED; + error_dev ("error %d on read %d byte", __FUNCTION__, dev, err, len); + return false; + } + +# ifdef SHT3x_DEBUG_LEVEL_2 + printf("SHT3x %s: bus %d, addr %02x - read following bytes: ", + __FUNCTION__, dev->bus, dev->addr); + for (int i=0; i < len; i++) + printf("%02x ", data[i]); + printf("\n"); +# endif // ifdef SHT3x_DEBUG_LEVEL_2 + + return true; +} + + +static bool sht3x_reset (sht3x_sensor_t* dev) +{ + if (!dev) { + printf("dev was falsey\n"); + return false; + } + + printf("soft-reset triggered\n"); + + dev->error_code = SHT3x_OK; + + // send reset command + if (!sht3x_send_command(dev, SHT3x_RESET_CMD)) + { + printf("Got error code from sht3x_send_command\n"); + dev->error_code |= SHT3x_SEND_RESET_CMD_FAILED; + return false; + } + // wait for small amount of time needed (according to datasheet 0.5ms) + vTaskDelay (100 / portTICK_PERIOD_MS); + + uint16_t status; + + // check the status after reset + if (!sht3x_get_status(dev, &status)) { + printf("Failed to get status from sensor\n"); + return false; + } + + return true; +} + + +static bool sht3x_get_status (sht3x_sensor_t* dev, uint16_t* status) +{ + if (!dev || !status) return false; + + dev->error_code = SHT3x_OK; + + uint8_t data[3]; + + if (!sht3x_send_command(dev, SHT3x_STATUS_CMD) || !sht3x_read_data(dev, data, 3)) + { + dev->error_code |= SHT3x_SEND_STATUS_CMD_FAILED; + return false; + } + + *status = data[0] << 8 | data[1]; + debug_dev ("status=%02x", __FUNCTION__, dev, *status); + return true; +} + + +const uint8_t g_polynom = 0x31; + +static uint8_t crc8 (uint8_t data[], int len) +{ + // initialization value + uint8_t crc = 0xff; + + // iterate over all bytes + for (int i=0; i < len; i++) + { + crc ^= data[i]; + + for (int i = 0; i < 8; i++) + { + bool xor = crc & 0x80; + crc = crc << 1; + crc = xor ? crc ^ g_polynom : crc; + } + } + + return crc; +} + + diff --git a/example_test.py b/example_test.py new file mode 100644 index 0000000..aec3c22 --- /dev/null +++ b/example_test.py @@ -0,0 +1,20 @@ +#!/usr/bin/env python + +from __future__ import division, print_function, unicode_literals + +import ttfw_idf + + +@ttfw_idf.idf_example_test(env_tag='Example_TWAI1', target=['esp32', 'esp32s2'], ci_target=['esp32']) +def test_examples_gpio(env, extra_data): + app_name = 'gpio' + dut = env.get_dut(app_name, 'examples/peripherals/gpio/generic_gpio') + dut.start_app() + res = dut.expect(ttfw_idf.MINIMUM_FREE_HEAP_SIZE_RE) + if not res: + raise ValueError('Maximum heap size info not found') + ttfw_idf.print_heap_size(app_name, dut.app.config_name, dut.TARGET, res[0]) + + +if __name__ == '__main__': + test_examples_gpio() diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt new file mode 100644 index 0000000..2e86d46 --- /dev/null +++ b/main/CMakeLists.txt @@ -0,0 +1,3 @@ +idf_component_register(SRCS "plant_water.c" + INCLUDE_DIRS "." + REQUIRES "esp_http_server" "nvs_flash" "esp_http_client" "esp_eth" "driver" "esp8266_wrapper" "sht3x" "cjson") diff --git a/main/plant_water.c b/main/plant_water.c new file mode 100644 index 0000000..834a5fc --- /dev/null +++ b/main/plant_water.c @@ -0,0 +1,731 @@ +#include "./plant_water.h" +#include "sht3x.h" +#include "cjson.h" + +#define I2C_BUS 0 +#define I2C_SCL_PIN 22 +#define I2C_SDA_PIN 21 + +#define HTTPD_RESP_SIZE 100 +#define MAX_CRON_SPECS 5 + +static const char *TAG = "pump"; +static sht3x_sensor_t* sensor; + +static void set_pump(int pump_num, int state) { + // Set duty to 100% + ESP_ERROR_CHECK(ledc_set_duty(LEDC_MODE, pump_num, state == 1 ? LEDC_DUTY: 0)); + // Update duty to apply the new value + ESP_ERROR_CHECK(ledc_update_duty(LEDC_MODE, pump_num)); +} + +static void +pump_one_on() { + set_pump(0, 1); + set_pump(1, 0); +} + +static void +pump_two_on() { + set_pump(0, 0); + set_pump(1, 1); +} + +static void +pumps_off() { + set_pump(0, 0); + set_pump(1, 0); +} + +typedef enum { + PUMP_ON = 1, + PUMP_OFF = 2, +} event_type; + +struct event_t { + event_type pump_1; + event_type pump_2; + int pump_delay; +}; + +struct cron_t { + int pump_num; + int state; + int pump_on_time; + int hour; + int minute; + int last_ran_day; // day of the month it last ran + int last_ran_minute; // minute it last ran + int last_ran_hour; // hour it last ran +}; + +static struct cron_t cron_specs[MAX_CRON_SPECS]; + +static TickType_t +make_delay(int seconds) { + return (1000*seconds) / portTICK_PERIOD_MS; +} + +// Timer type definitions +const TickType_t PUMP_TIMER_DELAY = (1000*60) / portTICK_PERIOD_MS; +const TickType_t PUMP_CB_PERIOD = (1000*10) / portTICK_PERIOD_MS; + +TimerHandle_t pumpTimer = 0; // Timer for toggling the pumps on/off +StaticTimer_t pumpTimerBuffer; // Memory backing for the timer, allocated statically + +// Queue type definitions +uint8_t queueStorage[PUMP_EV_NUM*sizeof (struct event_t)]; // byte array for queue memory +static StaticQueue_t pumpEvents; +QueueHandle_t pumpEventsHandle; + +uint8_t timerQueueStorage[PUMP_EV_NUM*sizeof (struct cron_t)]; // byte array for queue memory +static StaticQueue_t timerEvents; +QueueHandle_t timerEventsHandle; + +// Task type definitions + +StaticTask_t xTaskBuffer; +StackType_t xStack[TASK_STACK_SIZE]; + +void +pumpRunnerTaskFunction(void *params) { + struct event_t pumpMessage; + + printf("Task started\n"); + + configASSERT( ( uint32_t ) params == 1UL ); + + while (1) { + vTaskDelay(2000 / portTICK_PERIOD_MS); + + if (pumpEventsHandle != NULL) { + // The queue exists and is created + if (xQueueReceive(pumpEventsHandle, &pumpMessage, (TickType_t)PUMP_TIMER_DELAY) == pdPASS) { + printf("got a message, pump_1 = %u, pump_2 = %u, PUMP_ON = %u, PUMP_OFF = %u\n", pumpMessage.pump_1, pumpMessage.pump_2, PUMP_ON, PUMP_OFF); + if (pumpMessage.pump_1 == PUMP_ON) { + pump_one_on(); + } + if (pumpMessage.pump_2 == PUMP_ON) { + pump_two_on(); + } + vTaskDelay(pumpMessage.pump_delay); + pumps_off(); + } + } + } +} + +static void +createPumpRunnerTask(void) { + xTaskCreateStatic(pumpRunnerTaskFunction, + "pumpt", + TASK_STACK_SIZE, + (void*)1, + tskIDLE_PRIORITY + 2, + xStack, + &xTaskBuffer); +} + + +void +runPumps(int delay1, int delay2) { + struct event_t message; + message.pump_1 = PUMP_ON; + message.pump_2 = PUMP_OFF; + message.pump_delay = make_delay(delay1); + + xQueueSend(pumpEventsHandle, (void*)&message, (TickType_t)0); + + message.pump_2 = PUMP_ON; + message.pump_1 = PUMP_OFF; + message.pump_delay = make_delay(delay2); + + xQueueSend(pumpEventsHandle, (void*)&message, (TickType_t)0); +} + +void +pumpTimerCb(TimerHandle_t pumpTimer) { + time_t now; + struct tm timeinfo; + time(&now); + localtime_r(&now, &timeinfo); + struct cron_t pump_timer_config; + static int next_cron_spec = 0; + + if (timerEventsHandle != NULL) { + if (xQueueReceive(timerEventsHandle, &pump_timer_config, (TickType_t)0) == pdPASS) { + printf("Got a new cron spec\n"); + cron_specs[next_cron_spec] = pump_timer_config; + next_cron_spec = (next_cron_spec + 1) % MAX_CRON_SPECS; + printf("new: hour = %d, minute = %d\n", pump_timer_config.hour, pump_timer_config.minute); + } + } + + // check current number of cron specs, remove oldest one and replace if none left + // loop over them and check time and execute commands + for (int i = 0; i < MAX_CRON_SPECS; i++) { + //printf("to match: hour = %d, minute = %d\n", cron_specs[i].hour, cron_specs[i].minute); + //printf("current: hour = %d, minute = %d\n", timeinfo.tm_hour, timeinfo.tm_min); + if (timeinfo.tm_hour == cron_specs[i].hour && (timeinfo.tm_min == cron_specs[i].minute)) { + if (cron_specs[i].last_ran_day == timeinfo.tm_mday) { + // it already ran today, skip it + continue; + } + printf("running, hour = %d, minute = %d\n", cron_specs[i].hour, cron_specs[i].minute); + // refactor this bit... + struct event_t message = {0}; + switch (cron_specs[i].pump_num) { + case 0: + message.pump_1 = PUMP_ON; + message.pump_2 = PUMP_OFF; + break; + case 1: + message.pump_2 = PUMP_ON; + message.pump_1 = PUMP_OFF; + break; + } + message.pump_delay = make_delay(cron_specs[i].pump_on_time); + xQueueSend(pumpEventsHandle, (void*)&message, (TickType_t)0); + + cron_specs[i].last_ran_day = timeinfo.tm_mday; + cron_specs[i].last_ran_hour = timeinfo.tm_hour; + cron_specs[i].last_ran_minute = timeinfo.tm_min; + } + } +} + +esp_err_t +get_sensor_data(httpd_req_t *req) { + time_t now; + struct tm timeinfo; + time(&now); + localtime_r(&now, &timeinfo); + + float temperature; + float humidity; + + char resp[HTTPD_RESP_SIZE] = {0}; + + cJSON *resp_object_j = cJSON_CreateObject(); + + if (sht3x_measure(sensor, &temperature, &humidity)) { + cJSON_AddNumberToObject(resp_object_j, "temperature", (double)temperature); + cJSON_AddNumberToObject(resp_object_j, "humidity", (double)humidity); + } + + cJSON_AddNumberToObject(resp_object_j, "hour", (double)timeinfo.tm_hour); + cJSON_AddNumberToObject(resp_object_j, "minute", (double)timeinfo.tm_min); + + cJSON_PrintPreallocated(resp_object_j, resp, HTTPD_RESP_SIZE, false); + + if (resp_object_j != NULL) { cJSON_Delete(resp_object_j); } + + httpd_resp_set_type(req, "application/json"); + httpd_resp_set_status(req, HTTPD_200); + httpd_resp_send(req, resp, HTTPD_RESP_USE_STRLEN); + + return ESP_OK; +} + +esp_err_t +pumps_on_handler(httpd_req_t *req) { + printf("pumps_on_handler executed\n"); + // TODO stream + char req_body[HTTPD_RESP_SIZE+1] = {0}; + char resp[HTTPD_RESP_SIZE] = {0}; + + size_t body_size = MIN(req->content_len, (sizeof(req_body)-1)); + + // Receive body and do error handling + int ret = httpd_req_recv(req, req_body, body_size); + + // if ret == 0 then no data + if (ret < 0) { + if (ret == HTTPD_SOCK_ERR_TIMEOUT) { + httpd_resp_send_408(req); + } + return ESP_FAIL; + } + + cJSON *json = cJSON_ParseWithLength(req_body, HTTPD_RESP_SIZE); + + cJSON *pump_one_time_j = NULL; + cJSON *pump_two_time_j = NULL; + + if (json != NULL) { + printf("%s\n", cJSON_Print(json)); + if (cJSON_IsObject(json)) { + pump_one_time_j = cJSON_GetObjectItemCaseSensitive(json, "pump_1"); + pump_two_time_j = cJSON_GetObjectItemCaseSensitive(json, "pump_2"); + if (cJSON_IsNumber(pump_one_time_j) && cJSON_IsNumber(pump_two_time_j)) { + if (pump_one_time_j->valueint > 0 && pump_two_time_j->valueint > 0) { + printf("Running pumps: p1 = %d, p2 = %d\n", pump_one_time_j->valueint, pump_two_time_j->valueint); + runPumps(pump_one_time_j->valueint, pump_two_time_j->valueint); + } + } + } + } + + httpd_resp_send(req, resp, HTTPD_RESP_USE_STRLEN); + + if (json != NULL) { cJSON_Delete(json); } + return ESP_OK; +} + +/* URI handler structure for GET /uri */ +httpd_uri_t uri_get = { + .uri = "/sensor", + .method = HTTP_GET, + .handler = get_sensor_data, + .user_ctx = NULL +}; + + +/* URI handler structure for POST /pumps_on */ +httpd_uri_t pumps_on = { + .uri = "/pumps_on", + .method = HTTP_POST, + .handler = pumps_on_handler, + .user_ctx = NULL +}; + +esp_err_t +add_cron_handler(httpd_req_t *req) { + printf("add_cron_handler executed\n"); + // TODO stream + char req_body[HTTPD_RESP_SIZE+1] = {0}; + char resp[HTTPD_RESP_SIZE] = {0}; + + size_t body_size = MIN(req->content_len, (sizeof(req_body)-1)); + + // Receive body and do error handling + int ret = httpd_req_recv(req, req_body, body_size); + + // if ret == 0 then no data + if (ret < 0) { + if (ret == HTTPD_SOCK_ERR_TIMEOUT) { + httpd_resp_send_408(req); + } + return ESP_FAIL; + } + + cJSON *json = cJSON_ParseWithLength(req_body, HTTPD_RESP_SIZE); + + cJSON *pump_num; + cJSON *state; + cJSON *pump_on_time; // time it will be on for + cJSON *hour; // hour to trigger in + cJSON *minute; // minute on the hour to trigger on + + struct cron_t cron_spec = {0}; + + if (json != NULL) { + printf("%s\n", cJSON_Print(json)); + if (cJSON_IsObject(json)) { + pump_num = cJSON_GetObjectItemCaseSensitive(json, "pump_num"); + state = cJSON_GetObjectItemCaseSensitive(json, "state"); + pump_on_time = cJSON_GetObjectItemCaseSensitive(json, "pump_on_time"); + hour = cJSON_GetObjectItemCaseSensitive(json, "hour"); + minute = cJSON_GetObjectItemCaseSensitive(json, "minute"); + + if (cJSON_IsNumber(pump_num) && + cJSON_IsNumber(state) && + cJSON_IsNumber(pump_on_time) && + cJSON_IsNumber(hour) && + cJSON_IsNumber(minute)) { + printf("Creating cron spec\n"); + cron_spec.pump_num = pump_num->valueint; + cron_spec.state = state->valueint; + cron_spec.pump_on_time = pump_on_time->valueint; + cron_spec.hour = hour->valueint; + cron_spec.minute = minute->valueint; + cron_spec.last_ran_day = -1; + cron_spec.last_ran_hour = -1; + cron_spec.last_ran_minute = -1; + printf("Parsed: hour = %d, minute = %d\n", cron_spec.hour, cron_spec.minute); + xQueueSend(timerEventsHandle, (void*)&cron_spec, (TickType_t)0); + } + } + } + + httpd_resp_send(req, resp, HTTPD_RESP_USE_STRLEN); + + if (json != NULL) { cJSON_Delete(json); } + return ESP_OK; +} + +/* URI handler structure for POST /add_cron */ +httpd_uri_t add_cron = { + .uri = "/add_cron", + .method = HTTP_POST, + .handler = add_cron_handler, + .user_ctx = NULL +}; + +/* Function for starting the webserver */ +httpd_handle_t +start_webserver(void) { + /* Generate default configuration */ + httpd_config_t config = HTTPD_DEFAULT_CONFIG(); + + /* Empty handle to esp_http_server */ + httpd_handle_t server = NULL; + + /* Start the httpd server */ + if (httpd_start(&server, &config) == ESP_OK) { + /* Register URI handlers */ + httpd_register_uri_handler(server, &uri_get); + httpd_register_uri_handler(server, &pumps_on); + httpd_register_uri_handler(server, &add_cron); + } + /* If server failed to start, handle will be NULL */ + ESP_LOGI(TAG, "webserver started"); + return server; +} + +static SemaphoreHandle_t s_semph_get_ip_addrs; + +/* tear down connection, release resources */ +static void +stop(void) { +#if CONFIG_EXAMPLE_CONNECT_WIFI + wifi_stop(); + s_active_interfaces--; +#endif +} + +esp_err_t +wifi_disconnect(void) { + if (s_semph_get_ip_addrs == NULL) { + return ESP_ERR_INVALID_STATE; + } + vSemaphoreDelete(s_semph_get_ip_addrs); + s_semph_get_ip_addrs = NULL; + stop(); + ESP_ERROR_CHECK(esp_unregister_shutdown_handler(&stop)); + return ESP_OK; +} +#ifndef INET6_ADDRSTRLEN +#define INET6_ADDRSTRLEN 48 +#endif + +/* Variable holding number of times ESP32 restarted since first boot. + * It is placed into RTC memory using RTC_DATA_ATTR and + * maintains its value when ESP32 wakes from deep sleep. + */ +RTC_DATA_ATTR static int boot_count = 0; + +static void obtain_time(void); +static void initialize_sntp(void); + +void wifi_init_sta(void); + +void +time_sync_notification_cb(struct timeval *tv) { + ESP_LOGI(TAG, "Notification of a time synchronization event"); +} + +static void +obtain_time(void) { + /** + * NTP server address could be aquired via DHCP, + * see following menuconfig options: + * 'LWIP_DHCP_GET_NTP_SRV' - enable STNP over DHCP + * 'LWIP_SNTP_DEBUG' - enable debugging messages + * + */ + + wifi_init_sta(); + initialize_sntp(); + + // wait for time to be set + time_t now = 0; + struct tm timeinfo = { 0 }; + int retry = 0; + const int retry_count = 15; + while (sntp_get_sync_status() == SNTP_SYNC_STATUS_RESET && ++retry < retry_count) { + ESP_LOGI(TAG, "Waiting for system time to be set... (%d/%d)", retry, retry_count); + vTaskDelay(2000 / portTICK_PERIOD_MS); + } + time(&now); + localtime_r(&now, &timeinfo);\ +} + +static void +initialize_sntp(void) { + ESP_LOGI(TAG, "Initializing SNTP"); + sntp_setoperatingmode(SNTP_OPMODE_POLL); + +/* + * If 'NTP over DHCP' is enabled, we set dynamic pool address + * as a 'secondary' server. It will act as a fallback server in case that address + * provided via NTP over DHCP is not accessible + */ +#if LWIP_DHCP_GET_NTP_SRV && SNTP_MAX_SERVERS > 1 + sntp_setservername(1, "pool.ntp.org"); + +#if LWIP_IPV6 && SNTP_MAX_SERVERS > 2 // statically assigned IPv6 address is also possible + ip_addr_t ip6; + if (ipaddr_aton("2a01:3f7::1", &ip6)) { // ipv6 ntp source "ntp.netnod.se" + sntp_setserver(2, &ip6); + } +#endif /* LWIP_IPV6 */ + +#else /* LWIP_DHCP_GET_NTP_SRV && (SNTP_MAX_SERVERS > 1) */ + // otherwise, use DNS address from a pool + sntp_setservername(0, "pool.ntp.org"); +#endif + + sntp_set_time_sync_notification_cb(time_sync_notification_cb); + + sntp_init(); + + ESP_LOGI(TAG, "List of configured NTP servers:"); + + for (uint8_t i = 0; i < SNTP_MAX_SERVERS; ++i){ + if (sntp_getservername(i)){ + ESP_LOGI(TAG, "server %d: %s", i, sntp_getservername(i)); + } else { + // we have either IPv4 or IPv6 address, let's print it + char buff[INET6_ADDRSTRLEN]; + ip_addr_t const *ip = sntp_getserver(i); + if (ipaddr_ntoa_r(ip, buff, INET6_ADDRSTRLEN) != NULL) + ESP_LOGI(TAG, "server %d: %s", i, buff); + } + } +} + +/* FreeRTOS event group to signal when we are connected*/ +static EventGroupHandle_t s_wifi_event_group; +static int s_retry_num = 0; + +static void +event_handler(void *arg, + esp_event_base_t event_base, + int32_t event_id, + void *event_data) { + + if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) { + esp_wifi_connect(); + } + else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) { + if (s_retry_num < EXAMPLE_ESP_MAXIMUM_RETRY) { + esp_wifi_connect(); + s_retry_num++; + ESP_LOGI(TAG, "retry to connect to the AP"); + } + else { + xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT); + } + ESP_LOGI(TAG,"connect to the AP fail"); + } + else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) { + ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data; + ESP_LOGI(TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip)); + s_retry_num = 0; + xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT); + } +} + +void +wifi_init_sta(void) { + s_wifi_event_group = xEventGroupCreate(); + + ESP_ERROR_CHECK(nvs_flash_init()); + ESP_ERROR_CHECK(esp_netif_init()); + ESP_ERROR_CHECK(esp_event_loop_create_default()); + +#ifdef LWIP_DHCP_GET_NTP_SRV + sntp_servermode_dhcp(1); // accept NTP offers from DHCP server, if any +#endif + + esp_netif_create_default_wifi_sta(); + + wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); + ESP_ERROR_CHECK(esp_wifi_init(&cfg)); + + esp_event_handler_instance_t instance_any_id; + esp_event_handler_instance_t instance_got_ip; + ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, + ESP_EVENT_ANY_ID, + &event_handler, + NULL, + &instance_any_id)); + ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, + IP_EVENT_STA_GOT_IP, + &event_handler, + NULL, + &instance_got_ip)); + + wifi_config_t wifi_config = { + .sta = { + .ssid = EXAMPLE_ESP_WIFI_SSID, + .password = EXAMPLE_ESP_WIFI_PASS, + /* Setting a password implies station will connect to all security modes including WEP/WPA. + * However these modes are deprecated and not advisable to be used. Incase your Access point + * doesn't support WPA2, these mode can be enabled by commenting below line */ + .threshold.authmode = ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD, + }, + }; + ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) ); + ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config) ); + ESP_ERROR_CHECK(esp_wifi_start() ); + + ESP_LOGI(TAG, "wifi_init_sta finished."); + + /* Waiting until either the connection is established (WIFI_CONNECTED_BIT) or connection failed for the maximum + * number of re-tries (WIFI_FAIL_BIT). The bits are set by event_handler() (see above) */ + EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, + WIFI_CONNECTED_BIT | WIFI_FAIL_BIT, + pdFALSE, + pdFALSE, + portMAX_DELAY); + + /* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually + * happened. */ + if (bits & WIFI_CONNECTED_BIT) { + ESP_LOGI(TAG, "connected to ap SSID:%s password:%s", + EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS); + + httpd_handle_t server; + printf("Trying to start webserver\n"); + server = start_webserver(); + + } + else if (bits & WIFI_FAIL_BIT) { + ESP_LOGI(TAG, "Failed to connect to SSID:%s, password:%s", + EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS); + } + else { + ESP_LOGE(TAG, "UNEXPECTED EVENT"); + } +} + +static void +ledc_init(int gpio_num, + int ledc_channel_num, + int ledc_timer_num) { + // Prepare and then apply the LEDC PWM timer configuration + ledc_timer_config_t ledc_timer = { + .speed_mode = LEDC_MODE, + .timer_num = ledc_timer_num, + .duty_resolution = LEDC_DUTY_RES, + .freq_hz = LEDC_FREQUENCY, // Set output frequency at 5 kHz + .clk_cfg = LEDC_AUTO_CLK + }; + ESP_ERROR_CHECK(ledc_timer_config(&ledc_timer)); + + // Prepare and then apply the LEDC PWM channel configuration + ledc_channel_config_t ledc_channel = { + .speed_mode = LEDC_MODE, + .channel = ledc_channel_num, + .timer_sel = ledc_timer_num, + .intr_type = LEDC_INTR_DISABLE, + .gpio_num = gpio_num, + .duty = 0, // Set duty to 0% + .hpoint = 0 + }; + ESP_ERROR_CHECK(ledc_channel_config(&ledc_channel)); +} + +void user_task (void *pvParameters) +{ + float temperature; + float humidity; + + TickType_t last_wakeup = xTaskGetTickCount(); + + while (1) + { + // perform one measurement and do something with the results + if (sht3x_measure (sensor, &temperature, &humidity)) + printf("%.3f SHT3x Sensor: %.2f °C, %.2f %%\n", + (double)sdk_system_get_time()*1e-3, temperature, humidity); + + // wait until 5 seconds are over + vTaskDelayUntil(&last_wakeup, 5000 / portTICK_PERIOD_MS); + } +} + +/* -- main program ------------------------------------------------- */ + +void user_init(void) +{ + // Set UART Parameter. + uart_set_baud(0, 115200); + // Give the UART some time to settle + vTaskDelay(1); + + // Init I2C bus interfaces at which SHT3x sensors are connected + // (different busses are possible). + i2c_init(I2C_BUS, I2C_SCL_PIN, I2C_SDA_PIN, I2C_FREQ_100K); + + // Create the sensors, multiple sensors are possible. + if ((sensor = sht3x_init_sensor (I2C_BUS, SHT3x_ADDR_1))) + { + // Create a user task that uses the sensors. + xTaskCreate(user_task, "user_task", TASK_STACK_SIZE, NULL, 2, 0); + } + + // That's it. +} + +void +app_main(void) { + ++boot_count; + ESP_LOGI(TAG, "Boot count: %d", boot_count); + + time_t now; + struct tm timeinfo; + time(&now); + localtime_r(&now, &timeinfo); + + // Is time set? If not, tm_year will be (1970 - 1900). + if (timeinfo.tm_year < (2016 - 1900)) { + ESP_LOGI(TAG, "Time is not set yet. Connecting to WiFi and getting time over NTP."); + obtain_time(); + // update 'now' variable with current time + time(&now); + } + + char strftime_buf[64]; + + // Set timezone to Eastern Standard Time and print local time + setenv("TZ", "EST5EDT,M3.2.0/2,M11.1.0", 1); + tzset(); + localtime_r(&now, &timeinfo); + strftime(strftime_buf, sizeof(strftime_buf), "%c", &timeinfo); + ESP_LOGI(TAG, "The current date/time in New York is: %s", strftime_buf); + + if (sntp_get_sync_mode() == SNTP_SYNC_MODE_SMOOTH) { + struct timeval outdelta; + while (sntp_get_sync_status() == SNTP_SYNC_STATUS_IN_PROGRESS) { + adjtime(NULL, &outdelta); + ESP_LOGI(TAG, "Waiting for adjusting time ... outdelta = %jd sec: %li ms: %li us", + (intmax_t)outdelta.tv_sec, + outdelta.tv_usec/1000, + outdelta.tv_usec%1000); + vTaskDelay(2000 / portTICK_PERIOD_MS); + } + } + pumpEventsHandle = xQueueCreateStatic(PUMP_EV_NUM, sizeof (struct event_t), queueStorage, &pumpEvents); + timerEventsHandle = xQueueCreateStatic(PUMP_EV_NUM, sizeof (struct cron_t), timerQueueStorage, &timerEvents); + + configASSERT(pumpEventsHandle); + configASSERT(timerEventsHandle); + + pumpTimer = xTimerCreateStatic("pump timer", PUMP_CB_PERIOD, pdTRUE, (void*)0, pumpTimerCb, &pumpTimerBuffer); + xTimerStart(pumpTimer, 0); + + // Pump stuff + // Set the LEDC peripheral configuration + ledc_init(18, 0, 0); + ledc_init(19, 1, 1); + + i2c_init(I2C_BUS, I2C_SCL_PIN, I2C_SDA_PIN, I2C_FREQ_100K); + + // Create the sensors, multiple sensors are possible. + sensor = sht3x_init_sensor(I2C_BUS, SHT3x_ADDR_1); + + createPumpRunnerTask(); +} diff --git a/main/plant_water.h b/main/plant_water.h new file mode 100644 index 0000000..dbc1413 --- /dev/null +++ b/main/plant_water.h @@ -0,0 +1,61 @@ +#include "driver/ledc.h" +#include "esp_attr.h" +#include "esp_err.h" +#include "esp_eth.h" +#include "esp_event.h" +#include "esp_http_client.h" +#include "esp_log.h" +#include "esp_netif.h" +#include "esp_sleep.h" +#include "esp_sntp.h" +#include "esp_system.h" +#include "esp_wifi.h" +#include "freertos/FreeRTOS.h" +#include "freertos/FreeRTOSConfig.h" +#include "freertos/event_groups.h" +#include "freertos/task.h" +#include "freertos/timers.h" +#include "freertos/queue.h" +#include "nvs_flash.h" +#include "protocol_examples_common.h" +#include "sdkconfig.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "driver/spi_common.h" +#include "driver/uart.h" + +#define LEDC_TIMER_0 0 +#define LEDC_TIMER_1 1 +#define LEDC_MODE LEDC_LOW_SPEED_MODE +#define LEDC_OUTPUT_IO_1 (18) // Define the output GPIO +#define LEDC_OUTPUT_IO_2 (19) // Define the output GPIO +#define LEDC_CHANNEL_1 0 +#define LEDC_CHANNEL_2 1 +#define LEDC_DUTY_RES LEDC_TIMER_13_BIT // Set duty resolution to 13 bits +#define LEDC_DUTY (8191) // Set duty to 100%. ((2 ** 13) - 1) * 50% = 4095 +#define LEDC_FREQUENCY (5000) // Frequency in Hertz. Set frequency at 5 kHz + +#define EXAMPLE_ESP_WIFI_SSID CONFIG_SSID +#define EXAMPLE_ESP_WIFI_PASS CONFIG_PASSWORD +#define EXAMPLE_ESP_MAXIMUM_RETRY 10 + +#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA2_PSK + +#define PUMP_EV_NUM 5 + +/* The event group allows multiple bits for each event, but we only care about two events: + * - we are connected to the AP with an IP + * - we failed to connect after the maximum amount of retries */ +#define WIFI_CONNECTED_BIT BIT0 +#define WIFI_FAIL_BIT BIT1 + +#define TASK_STACK_SIZE 4000 diff --git a/main/protocol_examples_common.h b/main/protocol_examples_common.h new file mode 100644 index 0000000..d43e94e --- /dev/null +++ b/main/protocol_examples_common.h @@ -0,0 +1,93 @@ +/* Common functions for protocol examples, to establish Wi-Fi or Ethernet connection. + + This example code is in the Public Domain (or CC0 licensed, at your option.) + + Unless required by applicable law or agreed to in writing, this + software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + CONDITIONS OF ANY KIND, either express or implied. + */ + +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "esp_err.h" +#include "esp_netif.h" +#include "esp_eth.h" + +#ifdef CONFIG_EXAMPLE_CONNECT_ETHERNET +#define EXAMPLE_INTERFACE get_example_netif() +#endif + +#ifdef CONFIG_EXAMPLE_CONNECT_WIFI +#define EXAMPLE_INTERFACE get_example_netif() +#endif + +#if !defined (CONFIG_EXAMPLE_CONNECT_ETHERNET) && !defined (CONFIG_EXAMPLE_CONNECT_WIFI) +// This is useful for some tests which do not need a network connection +#define EXAMPLE_INTERFACE NULL +#endif + +/** + * @brief Configure Wi-Fi or Ethernet, connect, wait for IP + * + * This all-in-one helper function is used in protocols examples to + * reduce the amount of boilerplate in the example. + * + * It is not intended to be used in real world applications. + * See examples under examples/wifi/getting_started/ and examples/ethernet/ + * for more complete Wi-Fi or Ethernet initialization code. + * + * Read "Establishing Wi-Fi or Ethernet Connection" section in + * examples/protocols/README.md for more information about this function. + * + * @return ESP_OK on successful connection + */ +esp_err_t example_connect(void); + +/** + * Counterpart to example_connect, de-initializes Wi-Fi or Ethernet + */ +esp_err_t example_disconnect(void); + +/** + * @brief Configure stdin and stdout to use blocking I/O + * + * This helper function is used in ASIO examples. It wraps installing the + * UART driver and configuring VFS layer to use UART driver for console I/O. + */ +esp_err_t example_configure_stdin_stdout(void); + +/** + * @brief Returns esp-netif pointer created by example_connect() + * + * @note If multiple interfaces active at once, this API return NULL + * In that case the get_example_netif_from_desc() should be used + * to get esp-netif pointer based on interface description + */ +esp_netif_t *get_example_netif(void); + +/** + * @brief Returns esp-netif pointer created by example_connect() described by + * the supplied desc field + * + * @param desc Textual interface of created network interface, for example "sta" + * indicate default WiFi station, "eth" default Ethernet interface. + * + */ +esp_netif_t *get_example_netif_from_desc(const char *desc); + +#ifdef CONFIG_EXAMPLE_CONNECT_ETHERNET +/** + * @brief Get the example Ethernet driver handle + * + * @return esp_eth_handle_t + */ +esp_eth_handle_t get_example_eth_handle(void); +#endif // CONFIG_EXAMPLE_CONNECT_ETHERNET + +#ifdef __cplusplus +} +#endif