From 397c0e44b02ca025ea57f6f77629be18177d9016 Mon Sep 17 00:00:00 2001 From: drjones Date: Wed, 20 May 2026 10:02:48 -0700 Subject: [PATCH] chore: import local project into Gitea --- ._.gitignore | Bin 0 -> 4096 bytes .../clangd/index/main.c.40ECD50192E77BED.idx | Bin 0 -> 28232 bytes .gitignore | 33 + CMakeLists.txt | 5 + README.md | 76 + components/cjson/CMakeLists.txt | 1 + components/cjson/cJSON.c | 3452 +++++++++++++++++ components/cjson/cJSON.h | 306 ++ main/CMakeLists.txt | 14 + main/Kconfig.projbuild | 85 + main/idf_component.yml | 16 + main/main.c | 598 +++ readme_ai.md | 46 + sdkconfig.defaults | 26 + 14 files changed, 4658 insertions(+) create mode 100644 ._.gitignore create mode 100644 .cache/clangd/index/main.c.40ECD50192E77BED.idx 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/cJSON.h create mode 100644 main/CMakeLists.txt create mode 100644 main/Kconfig.projbuild create mode 100644 main/idf_component.yml create mode 100644 main/main.c create mode 100644 readme_ai.md create mode 100644 sdkconfig.defaults diff --git a/._.gitignore b/._.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..613fad71b9d6b2b55b94845e22a7b8a71d9db82c GIT binary patch literal 4096 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 literal 0 HcmV?d00001 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d2f8775 --- /dev/null +++ b/.gitignore @@ -0,0 +1,33 @@ +# OS / tooling +.DS_Store +Thumbs.db + +# Editors +.cursor/ +.vscode/ + +# Secrets +.env +.env.* +!.env.example +!.env.template +sdkconfig +sdkconfig.old + +# Python +__pycache__/ +*.py[cod] +.venv/ +venv/ + +# Node / frontend +node_modules/ +dist/ + +# ESP-IDF / embedded build output +build/ +managed_components/ +dependencies.lock + +# Logs +*.log diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..600efc0 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,5 @@ +cmake_minimum_required(VERSION 3.16) + +include($ENV{IDF_PATH}/tools/cmake/project.cmake) +project(gemini_gadget) + diff --git a/README.md b/README.md new file mode 100644 index 0000000..2110a7a --- /dev/null +++ b/README.md @@ -0,0 +1,76 @@ +# Gemini Chat Gadget for ESP32-C6-LCD-1.69 + +This project builds a minimal ESP-IDF application that turns an ESP32-C6-LCD-1.69 board into a Gemini chat gadget. It features on-screen state indicators, speaker beeps, Wi-Fi connectivity, and integration with the Gemini API. + +## Hardware + +* **MCU/Board:** ESP32-C6 DevKitC-1 +* **Display:** 1.69" ST7789V2, 240x280 resolution, SPI interface +* **Default Pins (configurable via Kconfig):** + * MOSI: GPIO7 + * SCLK: GPIO6 + * CS: GPIO5 + * DC: GPIO2 + * RST: GPIO4 + * BL (Backlight): GPIO15 + * BUTTON: GPIO0 + * LED: GPIO8 + * SPEAKER: GPIO25 + * BAT_EN (Battery Enable): GPIO15 (drive HIGH on battery) + +## Features + +* **Display Auto-Probe:** Automatically detects and configures the ST7789V2 display by trying common rotations, offsets, and SPI clock frequencies. +* **UI State Machine:** Visual feedback on the LCD for different states: BOOT, CONNECTING, READY, LISTENING, THINKING, SPEAKING, and ERROR. +* **Wi-Fi Connectivity:** Connects to a specified Wi-Fi network in STA mode. +* **Gemini API Integration:** Communicates with the Google Gemini API (gemini-1.5-flash model) to generate text responses. +* **Audio Feedback:** Uses LEDC to generate tones for listening and speaking states, and a short beep for thinking. +* **Button Input:** A button on GPIO0 triggers a chat cycle. +* **Battery Management:** Sets `BAT_EN` (GPIO15) HIGH to enable battery power. + +## Project Structure + +* `CMakeLists.txt`: Main project CMake file. +* `main/CMakeLists.txt`: Component CMake file for the `main` component. +* `main/main.c`: Main application source code. +* `main/Kconfig.projbuild`: Defines Kconfig options for Wi-Fi credentials, Gemini API key, and LCD pin overrides. +* `sdkconfig.defaults`: Default configuration settings, including UART console, FreeRTOS tick rate, and placeholders for Wi-Fi and Gemini API key. + +## Build and Flash Instructions + +1. **Set the ESP-IDF Target:** + ```bash + idf.py set-target esp32c6 + ``` + +2. **Configure Project Settings:** + Run `menuconfig` to set your Wi-Fi SSID, Wi-Fi Password, and Gemini API Key. You can also override default LCD pin assignments here if needed. + ```bash + idf.py menuconfig + ``` + Navigate to "Application Configuration" to find the Wi-Fi and Gemini API key settings. + Navigate to "Application Configuration" -> "LCD Pin Configuration" to adjust pin assignments. + +3. **Build, Flash, and Monitor:** + This command will build the project, flash it to your ESP32-C6 board, and open a serial monitor to view logs. + ```bash + idf.py build flash monitor + ``` + +## Acceptance Criteria + +* Upon boot, the LCD should display a color-sweep during the auto-probe routine, followed by the BOOT, CONNECTING, and READY states. +* Pressing the button should initiate the LISTENING state (with a tone), transition to THINKING (with a beep), perform an HTTP POST to the Gemini API, move to SPEAKING (with a tone) while logging the reply, and finally return to the READY state. +* The console logs should clearly show auto-probe attempts and results, Wi-Fi connection status, HTTP status codes, and the extracted Gemini text response. +* The application should handle Wi-Fi or HTTP failures gracefully, transitioning to an ERROR state with appropriate logging. + +## Dependencies + +The project is designed to be lightweight and uses the following ESP-IDF components: + +* `esp_lcd` +* `esp_http_client` +* `cJSON` +* `esp_wifi` +* `driver` (for GPIO and LEDC) +* `esp_timer` diff --git a/components/cjson/CMakeLists.txt b/components/cjson/CMakeLists.txt new file mode 100644 index 0000000..3e4b2bd --- /dev/null +++ b/components/cjson/CMakeLists.txt @@ -0,0 +1 @@ +idf_component_register(SRCS "cJSON.c" INCLUDE_DIRS ".") diff --git a/components/cjson/cJSON.c b/components/cjson/cJSON.c new file mode 100644 index 0000000..371ccb5 --- /dev/null +++ b/components/cjson/cJSON.c @@ -0,0 +1,3452 @@ +/* + 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 != 18) + #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); + item->valuestring = NULL; + } + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + global_hooks.deallocate(item->string); + item->string = NULL; + } + 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; + unsigned char decimal_point = get_decimal_point(); + size_t i = 0; + size_t number_string_length = 0; + cJSON_bool has_decimal_point = false; + + 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; 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_string_length++; + break; + + case '.': + number_string_length++; + has_decimal_point = true; + break; + + default: + goto loop_end; + } + } +loop_end: + /* malloc for temporary buffer, add 1 for '\0' */ + number_c_string = (unsigned char *) input_buffer->hooks.allocate(number_string_length + 1); + if (number_c_string == NULL) + { + return false; /* allocation failure */ + } + + memcpy(number_c_string, buffer_at_offset(input_buffer), number_string_length); + number_c_string[number_string_length] = '\0'; + + if (has_decimal_point) + { + for (i = 0; i < number_string_length; i++) + { + if (number_c_string[i] == '.') + { + /* replace '.' with the decimal point of the current locale (for strtod) */ + number_c_string[i] = decimal_point; + } + } + } + + number = strtod((const char*)number_c_string, (char**)&after_end); + if (number_c_string == after_end) + { + /* free the temporary buffer */ + input_buffer->hooks.deallocate(number_c_string); + 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); + /* free the temporary buffer */ + input_buffer->hooks.deallocate(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; +} + +/* Note: when passing a NULL valuestring, cJSON_SetValuestring treats this as an error and return NULL */ +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring) +{ + char *copy = NULL; + size_t v1_len; + size_t v2_len; + /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */ + if ((object == NULL) || !(object->type & cJSON_String) || (object->type & cJSON_IsReference)) + { + return NULL; + } + /* return NULL if the object is corrupted or valuestring is NULL */ + if (object->valuestring == NULL || valuestring == NULL) + { + return NULL; + } + + v1_len = strlen(valuestring); + v2_len = strlen(object->valuestring); + + if (v1_len <= v2_len) + { + /* strcpy does not handle overlapping string: [X1, X2] [Y1, Y2] => X2 < Y1 or Y2 < X1 */ + if (!( valuestring + v1_len < object->valuestring || object->valuestring + v2_len < valuestring )) + { + return NULL; + } + 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; +} + +/* 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; +} + +/* Note: when passing a NULL valuestring, cJSON_SetValuestring treats this as an error and return NULL */ +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring) +{ + char *copy = NULL; + size_t v1_len; + size_t v2_len; + /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */ + if ((object == NULL) || !(object->type & cJSON_String) || (object->type & cJSON_IsReference)) + { + return NULL; + } + /* return NULL if the object is corrupted or valuestring is NULL */ + if (object->valuestring == NULL || valuestring == NULL) + { + return NULL; + } + + v1_len = strlen(valuestring); + v2_len = strlen(object->valuestring); + + if (v1_len <= v2_len) + { + /* strcpy does not handle overlapping string: [X1, X2] [Y1, Y2] => X2 < Y1 or Y2 < X1 */ + if (!( valuestring + v1_len < object->valuestring || object->valuestring + v2_len < valuestring )) + { + return NULL; + } + 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); + output = NULL; + } + + 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); + buffer->buffer = NULL; + } + + return printed; + +fail: + if (buffer->buffer != NULL) + { + hooks->deallocate(buffer->buffer); + buffer->buffer = NULL; + } + + if (printed != NULL) + { + hooks->deallocate(printed); + printed = NULL; + } + + 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); + p.buffer = NULL; + 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; + } + + if (cannot_access_at_index(input_buffer, 1)) + { + goto fail; /* nothing comes after the comma */ + } + + /* 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 and advance */ + 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) || (item != parent->child && item->prev == 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 || newitem == NULL) + { + return false; + } + + after_inserted = get_array_item(array, (size_t)which); + if (after_inserted == NULL) + { + return add_item_to_array(array, newitem); + } + + if (after_inserted != array->child && after_inserted->prev == NULL) { + /* return false if after_inserted is a corrupted array item */ + return false; + } + + newitem->next = after_inserted; + newitem->prev = after_inserted->prev; + after_inserted->prev = newitem; + if (after_inserted == array->child) + { + array->child = newitem; + } + 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 (newitem->prev != NULL) + { + newitem->prev->next = newitem; + } + if (newitem->next == NULL) + { + array->child->prev = newitem; + } + } + + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement) +{ + if ((parent == NULL) || (parent->child == 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 * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse); + +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) +{ + return cJSON_Duplicate_rec(item, 0, recurse ); +} + +cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, 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) + { + if(depth >= CJSON_CIRCULAR_LIMIT) { + goto fail; + } + newchild = cJSON_Duplicate_rec(child, depth + 1, 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); + object = NULL; +} diff --git a/components/cjson/cJSON.h b/components/cjson/cJSON.h new file mode 100644 index 0000000..5057ea1 --- /dev/null +++ b/components/cjson/cJSON.h @@ -0,0 +1,306 @@ +/* + 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 18 + +#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 + +/* Limits the length of circular references can be before cJSON rejects to parse them. + * This is to prevent stack overflows. */ +#ifndef CJSON_CIRCULAR_LIMIT +#define CJSON_CIRCULAR_LIMIT 10000 +#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/main/CMakeLists.txt b/main/CMakeLists.txt new file mode 100644 index 0000000..3396a20 --- /dev/null +++ b/main/CMakeLists.txt @@ -0,0 +1,14 @@ +idf_component_register( + SRCS "main.c" + INCLUDE_DIRS "." + REQUIRES + esp_wifi + esp_event + esp_netif + nvs_flash + esp_lcd + driver + esp_http_client + esp_timer + cjson +) diff --git a/main/Kconfig.projbuild b/main/Kconfig.projbuild new file mode 100644 index 0000000..2c355f8 --- /dev/null +++ b/main/Kconfig.projbuild @@ -0,0 +1,85 @@ +menu "Application Configuration" + + config APP_WIFI_SSID + string "Wi-Fi SSID" + default "YOUR_WIFI_SSID" + help + SSID of the Wi-Fi network to connect to. + + config APP_WIFI_PASSWORD + string "Wi-Fi Password" + default "YOUR_WIFI_PASSWORD" + help + Password of the Wi-Fi network. + + config APP_GEMINI_API_KEY + string "Gemini API Key" + default "YOUR_GEMINI_API_KEY" + help + API key for accessing the Gemini API. + + menu "LCD Pin Configuration" + + config LCD_PIN_MOSI + int "LCD MOSI Pin" + default 7 + help + GPIO pin for LCD MOSI. + + config LCD_PIN_SCLK + int "LCD SCLK Pin" + default 6 + help + GPIO pin for LCD SCLK. + + config LCD_PIN_CS + int "LCD CS Pin" + default 5 + help + GPIO pin for LCD CS. + + config LCD_PIN_DC + int "LCD DC Pin" + default 2 + help + GPIO pin for LCD DC. + + config LCD_PIN_RST + int "LCD RST Pin" + default 4 + help + GPIO pin for LCD RST. + + config LCD_PIN_BL + int "LCD Backlight Pin" + default 15 + help + GPIO pin for LCD Backlight. + + config LCD_PIN_BUTTON + int "Button Pin" + default 0 + help + GPIO pin for the user button. + + config LCD_PIN_LED + int "Status LED Pin" + default 8 + help + GPIO pin for the status LED. + + config LCD_PIN_SPEAKER + int "Speaker Pin" + default 25 + help + GPIO pin for the speaker. + + config LCD_PIN_BAT_EN + int "Battery Enable Pin" + default 15 + help + GPIO pin to enable battery power. + + endmenu + +endmenu diff --git a/main/idf_component.yml b/main/idf_component.yml new file mode 100644 index 0000000..f17b35f --- /dev/null +++ b/main/idf_component.yml @@ -0,0 +1,16 @@ +## IDF Component Manager Manifest File +dependencies: + ## Required IDF version + idf: + version: ">=4.1.0" + # # Put list of dependencies here + # # For components maintained by Espressif: + # component: "~1.0.0" + # # For 3rd party components: + # username/component: ">=1.0.0,<2.0.0" + # username2/component2: + # version: "~1.0.0" + # # For transient dependencies `public` flag can be set. + # # `public` flag doesn't have an effect dependencies of the `main` component. + # # All dependencies of `main` are public by default. + # public: true diff --git a/main/main.c b/main/main.c new file mode 100644 index 0000000..e7b1577 --- /dev/null +++ b/main/main.c @@ -0,0 +1,598 @@ +#include +#include +#include + +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "freertos/semphr.h" + +#include "esp_log.h" +#include "esp_err.h" +#include "esp_timer.h" +#include "nvs_flash.h" +#include "esp_event.h" +#include "esp_netif.h" +#include "esp_netif_ip_addr.h" +#include "esp_wifi.h" +#include "esp_http_client.h" +// TLS bundle not required as a build dependency; keep header optional +#ifdef __has_include +# if __has_include("esp_crt_bundle.h") +# include "esp_crt_bundle.h" +# define HAS_CRT_BUNDLE 1 +# endif +#endif + +#include "driver/gpio.h" +#include "driver/ledc.h" +#include "driver/spi_master.h" + +#include "esp_lcd_panel_io.h" +#include "esp_lcd_panel_vendor.h" +#include "esp_lcd_panel_ops.h" +#include "esp_lcd_types.h" +#include "esp_heap_caps.h" + +#include +#include "cJSON.h" + +// Kconfig symbols +#include "sdkconfig.h" + +// Pins from Kconfig (with sensible fallbacks) +#ifndef CONFIG_LCD_PIN_MOSI +#define CONFIG_LCD_PIN_MOSI 7 +#endif +#ifndef CONFIG_LCD_PIN_SCLK +#define CONFIG_LCD_PIN_SCLK 6 +#endif +#ifndef CONFIG_LCD_PIN_CS +#define CONFIG_LCD_PIN_CS 5 +#endif +#ifndef CONFIG_LCD_PIN_DC +#define CONFIG_LCD_PIN_DC 2 +#endif +#ifndef CONFIG_LCD_PIN_RST +#define CONFIG_LCD_PIN_RST 4 +#endif +#ifndef CONFIG_LCD_PIN_BL +#define CONFIG_LCD_PIN_BL 15 +#endif +#ifndef CONFIG_LCD_PIN_BUTTON +#define CONFIG_LCD_PIN_BUTTON 0 +#endif +#ifndef CONFIG_LCD_PIN_LED +#define CONFIG_LCD_PIN_LED 8 +#endif +#ifndef CONFIG_LCD_PIN_SPEAKER +#define CONFIG_LCD_PIN_SPEAKER 25 +#endif +#ifndef CONFIG_LCD_PIN_BAT_EN +#define CONFIG_LCD_PIN_BAT_EN 15 +#endif + +// Display constants +#define LCD_H_RES 240 +#define LCD_V_RES 280 + +static const char *TAG = "GEMINI_GADGET"; + +typedef enum { + UI_BOOT, + UI_CONNECTING, + UI_READY, + UI_LISTENING, + UI_THINKING, + UI_SPEAKING, + UI_ERROR +} ui_state_t; + +// LCD handles +static esp_lcd_panel_handle_t s_panel = NULL; +static int s_rotation = 0; +static int s_offset_y = 0; +static int s_spi_clk_hz = 0; + +// Button semaphore to trigger a chat cycle +static SemaphoreHandle_t s_btn_sem = NULL; + +// Tone control +static void tone_init(void); +static void tone_start(uint32_t freq_hz); +static void tone_stop(void); +static void tone_beep(uint32_t freq_hz, uint32_t duration_ms); + +// Wi-Fi +static esp_err_t wifi_init_and_connect(const char *ssid, const char *pass, int timeout_ms); + +// HTTP / Gemini +static char *gemini_generate_text(const char *api_key, const char *prompt, int *http_status_out); + +// UI helpers +static void ui_set_state(ui_state_t state); +static bool lcd_autoprobe(void); + +// Simple color helper (RGB565) +static inline uint16_t rgb565(uint8_t r, uint8_t g, uint8_t b) { + return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3); +} + +static void draw_solid_color(uint16_t color) { + if (!s_panel) return; + static uint16_t *line = NULL; + const int width = LCD_H_RES; + const int height = LCD_V_RES; + if (!line) { + line = (uint16_t *)heap_caps_malloc(width * sizeof(uint16_t), MALLOC_CAP_DMA); + } + if (!line) { + ESP_LOGE(TAG, "Failed to alloc line buffer"); + return; + } + for (int x = 0; x < width; ++x) line[x] = color; + for (int y = 0; y < height; ++y) { + esp_lcd_panel_draw_bitmap(s_panel, 0, y, width, y + 1, line); + } +} + +static void color_sweep(void) { + if (!s_panel) return; + const uint16_t colors[] = { + rgb565(255, 0, 0), + rgb565(0, 255, 0), + rgb565(0, 0, 255), + rgb565(255, 255, 255), + rgb565(0, 0, 0) + }; + for (size_t i = 0; i < sizeof(colors)/sizeof(colors[0]); ++i) { + draw_solid_color(colors[i]); + vTaskDelay(pdMS_TO_TICKS(200)); + } +} + +static void ui_set_state(ui_state_t state) { + switch (state) { + case UI_BOOT: + ESP_LOGI(TAG, "STATE: BOOT"); + draw_solid_color(rgb565(32, 32, 64)); + break; + case UI_CONNECTING: + ESP_LOGI(TAG, "STATE: CONNECTING"); + draw_solid_color(rgb565(64, 64, 0)); + break; + case UI_READY: + ESP_LOGI(TAG, "STATE: READY"); + draw_solid_color(rgb565(0, 64, 0)); + break; + case UI_LISTENING: + ESP_LOGI(TAG, "STATE: LISTENING"); + draw_solid_color(rgb565(0, 0, 128)); + break; + case UI_THINKING: + ESP_LOGI(TAG, "STATE: THINKING"); + draw_solid_color(rgb565(128, 0, 128)); + break; + case UI_SPEAKING: + ESP_LOGI(TAG, "STATE: SPEAKING"); + draw_solid_color(rgb565(0, 128, 128)); + break; + case UI_ERROR: + default: + ESP_LOGE(TAG, "STATE: ERROR"); + draw_solid_color(rgb565(128, 0, 0)); + break; + } +} + +// Button ISR +static volatile uint64_t s_last_btn_us = 0; +static void IRAM_ATTR button_isr(void *arg) { + uint64_t now = esp_timer_get_time(); + if ((now - s_last_btn_us) > 200000) { // 200ms debounce + BaseType_t hpw = pdFALSE; + xSemaphoreGiveFromISR(s_btn_sem, &hpw); + if (hpw) portYIELD_FROM_ISR(); + s_last_btn_us = now; + } +} + +static void gpio_init_all(void) { + // Battery enable + gpio_config_t io = { + .pin_bit_mask = 1ULL << CONFIG_LCD_PIN_BAT_EN, + .mode = GPIO_MODE_OUTPUT, + .pull_up_en = GPIO_PULLUP_DISABLE, + .pull_down_en = GPIO_PULLDOWN_DISABLE, + .intr_type = GPIO_INTR_DISABLE + }; + gpio_config(&io); + gpio_set_level(CONFIG_LCD_PIN_BAT_EN, 1); + + // Backlight + io.pin_bit_mask = 1ULL << CONFIG_LCD_PIN_BL; + gpio_config(&io); + gpio_set_level(CONFIG_LCD_PIN_BL, 1); + + // Status LED (optional) + io.pin_bit_mask = 1ULL << CONFIG_LCD_PIN_LED; + gpio_config(&io); + gpio_set_level(CONFIG_LCD_PIN_LED, 0); + + // Button + gpio_config_t bi = { + .pin_bit_mask = 1ULL << CONFIG_LCD_PIN_BUTTON, + .mode = GPIO_MODE_INPUT, + .pull_up_en = GPIO_PULLUP_ENABLE, + .pull_down_en = GPIO_PULLDOWN_DISABLE, + .intr_type = GPIO_INTR_NEGEDGE + }; + gpio_config(&bi); + gpio_install_isr_service(0); + gpio_isr_handler_add(CONFIG_LCD_PIN_BUTTON, button_isr, NULL); +} + +static void tone_init(void) { + ledc_timer_config_t tcfg = { + .speed_mode = LEDC_LOW_SPEED_MODE, + .duty_resolution = LEDC_TIMER_10_BIT, + .timer_num = LEDC_TIMER_0, + .freq_hz = 2000, + .clk_cfg = LEDC_AUTO_CLK, + }; + ledc_timer_config(&tcfg); + + ledc_channel_config_t ccfg = { + .gpio_num = CONFIG_LCD_PIN_SPEAKER, + .speed_mode = LEDC_LOW_SPEED_MODE, + .channel = LEDC_CHANNEL_0, + .intr_type = LEDC_INTR_DISABLE, + .timer_sel = LEDC_TIMER_0, + .duty = 0, + .hpoint = 0, + .flags = {0}, + }; + ledc_channel_config(&ccfg); +} + +static void tone_start(uint32_t freq_hz) { + ledc_set_freq(LEDC_LOW_SPEED_MODE, LEDC_TIMER_0, freq_hz); + ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, (1 << 9)); // ~50% of 10-bit + ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0); +} + +static void tone_stop(void) { + ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, 0); + ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0); +} + +static void tone_beep(uint32_t freq_hz, uint32_t duration_ms) { + tone_start(freq_hz); + vTaskDelay(pdMS_TO_TICKS(duration_ms)); + tone_stop(); +} + +// LCD setup using esp_lcd +static bool lcd_autoprobe(void) { + ESP_LOGI(TAG, "LCD autoprobe start"); + + // Prepare SPI bus using SPI master driver (compatible across IDF versions) + spi_bus_config_t buscfg = { + .sclk_io_num = CONFIG_LCD_PIN_SCLK, + .mosi_io_num = CONFIG_LCD_PIN_MOSI, + .miso_io_num = -1, + .quadwp_io_num = -1, + .quadhd_io_num = -1, + .max_transfer_sz = LCD_H_RES * 40 * sizeof(uint16_t), + .flags = 0, + }; + ESP_ERROR_CHECK(spi_bus_initialize(SPI2_HOST, &buscfg, SPI_DMA_CH_AUTO)); + + const int clk_candidates[] = { 40000000, 32000000, 24000000 }; + const int offsets_y[] = { 0, 20 }; + + for (size_t ck = 0; ck < sizeof(clk_candidates)/sizeof(clk_candidates[0]); ++ck) { + for (int rot = 0; rot < 4; ++rot) { + for (size_t oy = 0; oy < sizeof(offsets_y)/sizeof(offsets_y[0]); ++oy) { + int offy = offsets_y[oy]; + ESP_LOGI(TAG, "Probe try: clk=%d rot=%d offY=%d", clk_candidates[ck], rot, offy); + + esp_lcd_panel_io_spi_config_t io_cfg = { + .dc_gpio_num = CONFIG_LCD_PIN_DC, + .cs_gpio_num = CONFIG_LCD_PIN_CS, + .pclk_hz = clk_candidates[ck], + .lcd_cmd_bits = 8, + .lcd_param_bits = 8, + .spi_mode = 0, + .trans_queue_depth = 10, + }; + + esp_lcd_panel_io_handle_t io_handle = NULL; + if (esp_lcd_new_panel_io_spi(SPI2_HOST, &io_cfg, &io_handle) != ESP_OK) { + ESP_LOGW(TAG, "io new failed"); + continue; + } + + esp_lcd_panel_dev_config_t panel_cfg = { + .reset_gpio_num = CONFIG_LCD_PIN_RST, + .color_space = ESP_LCD_COLOR_SPACE_RGB, + .bits_per_pixel = 16, + .vendor_config = NULL, + }; + + esp_lcd_panel_handle_t panel = NULL; + if (esp_lcd_new_panel_st7789(io_handle, &panel_cfg, &panel) != ESP_OK) { + ESP_LOGW(TAG, "panel new failed"); + esp_lcd_panel_io_del(io_handle); + continue; + } + + if (esp_lcd_panel_reset(panel) != ESP_OK || esp_lcd_panel_init(panel) != ESP_OK) { + ESP_LOGW(TAG, "panel init failed"); + esp_lcd_panel_del(panel); + esp_lcd_panel_io_del(io_handle); + continue; + } + + esp_lcd_panel_swap_xy(panel, rot & 1); + esp_lcd_panel_mirror(panel, (rot & 2) != 0, (rot & 2) != 0); + esp_lcd_panel_set_gap(panel, 0, offy); + + s_panel = panel; + s_rotation = rot; + s_offset_y = offy; + s_spi_clk_hz = clk_candidates[ck]; + + color_sweep(); + ESP_LOGI(TAG, "LCD autoprobe success: clk=%d rot=%d offY=%d", s_spi_clk_hz, s_rotation, s_offset_y); + return true; + } + } + } + + ESP_LOGE(TAG, "LCD autoprobe failed"); + return false; +} + +// Wi-Fi event group substitute via callbacks +static bool s_got_ip = false; +static void on_got_ip(void* arg, esp_event_base_t base, int32_t id, void* data) { + ip_event_got_ip_t *e = (ip_event_got_ip_t *)data; + ESP_LOGI(TAG, "Got IP: " IPSTR, IP2STR(&e->ip_info.ip)); + s_got_ip = true; +} + +static esp_err_t wifi_init_and_connect(const char *ssid, const char *pass, int timeout_ms) { + ESP_ERROR_CHECK(nvs_flash_init()); + ESP_ERROR_CHECK(esp_netif_init()); + ESP_ERROR_CHECK(esp_event_loop_create_default()); + esp_netif_create_default_wifi_sta(); + + wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); + ESP_ERROR_CHECK(esp_wifi_init(&cfg)); + + ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &on_got_ip, NULL)); + + wifi_config_t wcfg = {0}; + strlcpy((char*)wcfg.sta.ssid, ssid ? ssid : "", sizeof(wcfg.sta.ssid)); + strlcpy((char*)wcfg.sta.password, pass ? pass : "", sizeof(wcfg.sta.password)); + wcfg.sta.threshold.authmode = WIFI_AUTH_WPA2_PSK; + wcfg.sta.pmf_cfg.capable = true; + wcfg.sta.pmf_cfg.required = false; + + ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA)); + ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wcfg)); + ESP_ERROR_CHECK(esp_wifi_start()); + ESP_ERROR_CHECK(esp_wifi_connect()); + + const int64_t start = esp_timer_get_time(); + int backoff_ms = 500; + while (!s_got_ip) { + if ((esp_timer_get_time() - start) / 1000 > timeout_ms) { + ESP_LOGE(TAG, "Wi-Fi connect timeout"); + return ESP_ERR_TIMEOUT; + } + vTaskDelay(pdMS_TO_TICKS(backoff_ms)); + backoff_ms = backoff_ms < 5000 ? backoff_ms * 2 : 5000; + } + return ESP_OK; +} + +// HTTP client event: accumulate body +typedef struct { + char *buf; + size_t len; +} http_buf_t; + +static esp_err_t http_evt_hdl(esp_http_client_event_t *evt) { + http_buf_t *hb = (http_buf_t *)evt->user_data; + switch (evt->event_id) { + case HTTP_EVENT_ON_DATA: + if (evt->data_len > 0) { + char *p = realloc(hb->buf, hb->len + evt->data_len + 1); + if (!p) return ESP_FAIL; + hb->buf = p; + memcpy(hb->buf + hb->len, evt->data, evt->data_len); + hb->len += evt->data_len; + hb->buf[hb->len] = '\0'; + } + break; + default: + break; + } + return ESP_OK; +} + +static char *json_escape(const char *s) { + size_t n = 0; + for (const char *p = s; *p; ++p) { + switch (*p) { case '"': case '\\': case '\n': case '\r': case '\t': n += 2; break; default: n += 1; } + } + char *out = malloc(n + 1); + char *w = out; + for (const char *p = s; *p; ++p) { + switch (*p) { + case '"': *w++ = '\\'; *w++ = '"'; break; + case '\\': *w++ = '\\'; *w++ = '\\'; break; + case '\n': *w++ = '\\'; *w++ = 'n'; break; + case '\r': *w++ = '\\'; *w++ = 'r'; break; + case '\t': *w++ = '\\'; *w++ = 't'; break; + default: *w++ = *p; break; + } + } + *w = '\0'; + return out; +} + +static char *build_gemini_payload(const char *prompt) { + char *e = json_escape(prompt); + const char *fmt = "{\"contents\":[{\"parts\":[{\"text\":\"%s\"}]}],\"generationConfig\":{\"maxOutputTokens\":150,\"temperature\":0.7,\"topP\":0.8,\"topK\":40}}"; + size_t len = strlen(fmt) + strlen(e) + 1; + char *buf = malloc(len); + snprintf(buf, len, fmt, e); + free(e); + return buf; +} + +static char *parse_gemini_reply(const char *json) { + cJSON *root = cJSON_Parse(json); + if (!root) { + ESP_LOGE(TAG, "JSON parse error: %s", cJSON_GetErrorPtr()); + return NULL; + } + + cJSON *candidates = cJSON_GetObjectItemCaseSensitive(root, "candidates"); + if (!cJSON_IsArray(candidates) || cJSON_GetArraySize(candidates) == 0) { + ESP_LOGE(TAG, "No candidates found in JSON"); + cJSON_Delete(root); + return NULL; + } + + cJSON *first_candidate = cJSON_GetArrayItem(candidates, 0); + cJSON *content = cJSON_GetObjectItemCaseSensitive(first_candidate, "content"); + cJSON *parts = cJSON_GetObjectItemCaseSensitive(content, "parts"); + if (!cJSON_IsArray(parts) || cJSON_GetArraySize(parts) == 0) { + ESP_LOGE(TAG, "No parts found in content"); + cJSON_Delete(root); + return NULL; + } + + cJSON *first_part = cJSON_GetArrayItem(parts, 0); + cJSON *text = cJSON_GetObjectItemCaseSensitive(first_part, "text"); + + char *reply_text = NULL; + if (cJSON_IsString(text) && (text->valuestring != NULL)) { + reply_text = strdup(text->valuestring); + } else { + ESP_LOGE(TAG, "Text field not found or not a string"); + } + + cJSON_Delete(root); + return reply_text; +} + +static char *gemini_generate_text(const char *api_key, const char *prompt, int *http_status_out) { + if (!api_key || strlen(api_key) == 0) { + ESP_LOGE(TAG, "API key not set"); + return NULL; + } + + char url[256]; + snprintf(url, sizeof(url), + "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=%s", + api_key); + + http_buf_t hb = {0}; + esp_http_client_config_t cfg = { + .url = url, + .event_handler = http_evt_hdl, + .user_data = &hb, + .method = HTTP_METHOD_POST, + #ifdef HAS_CRT_BUNDLE + .crt_bundle_attach = esp_crt_bundle_attach, + #endif + .timeout_ms = 15000, + }; + esp_http_client_handle_t cli = esp_http_client_init(&cfg); + if (!cli) return NULL; + + char *payload = build_gemini_payload(prompt); + esp_http_client_set_header(cli, "Content-Type", "application/json"); + esp_http_client_set_post_field(cli, payload, strlen(payload)); + + esp_err_t err = esp_http_client_perform(cli); + int status = -1; + if (err == ESP_OK) { + status = esp_http_client_get_status_code(cli); + ESP_LOGI(TAG, "HTTP status: %d, len=%d", status, (int)hb.len); + } else { + ESP_LOGE(TAG, "HTTP perform failed: %s", esp_err_to_name(err)); + } + + if (http_status_out) *http_status_out = status; + char *reply_text = NULL; + if (status == 200 && hb.buf) { + reply_text = parse_gemini_reply(hb.buf); + } + + free(payload); + if (hb.buf) free(hb.buf); + esp_http_client_cleanup(cli); + return reply_text; +} + +static void chat_cycle_task(void *arg) { + while (1) { + if (xSemaphoreTake(s_btn_sem, portMAX_DELAY) == pdTRUE) { + ui_set_state(UI_LISTENING); + tone_start(880); + vTaskDelay(pdMS_TO_TICKS(5000)); // simulate listening + tone_stop(); + + ui_set_state(UI_THINKING); + tone_beep(1400, 150); + + int http_status = -1; + char *reply = gemini_generate_text(CONFIG_APP_GEMINI_API_KEY, "Say a friendly hello from ESP32-C6.", &http_status); + + if (!reply) { + ESP_LOGE(TAG, "Gemini request failed (status=%d)", http_status); + ui_set_state(UI_ERROR); + vTaskDelay(pdMS_TO_TICKS(1000)); + ui_set_state(UI_READY); + continue; + } + + ui_set_state(UI_SPEAKING); + ESP_LOGI(TAG, "Gemini reply: %s", reply); + tone_start(660); + vTaskDelay(pdMS_TO_TICKS(1500)); + tone_stop(); + + free(reply); + ui_set_state(UI_READY); + } + } +} + +void app_main(void) { + s_btn_sem = xSemaphoreCreateBinary(); + gpio_init_all(); + tone_init(); + + ui_set_state(UI_BOOT); + + if (!lcd_autoprobe()) { + ui_set_state(UI_ERROR); + return; + } + + ui_set_state(UI_CONNECTING); + if (wifi_init_and_connect(CONFIG_APP_WIFI_SSID, CONFIG_APP_WIFI_PASSWORD, 30000) != ESP_OK) { + ui_set_state(UI_ERROR); + return; + } + + ui_set_state(UI_READY); + + xTaskCreate(chat_cycle_task, "chat", 8192, NULL, 5, NULL); +} diff --git a/readme_ai.md b/readme_ai.md new file mode 100644 index 0000000..bfa71a6 --- /dev/null +++ b/readme_ai.md @@ -0,0 +1,46 @@ +You are an embedded engineer. Build a minimal ESP-IDF project that turns an ESP32-C6-LCD-1.69 board into a Gemini chat gadget with on-screen states and speaker beeps. +• Target +MCU/Board: ESP32-C6 DevKitC-1, ESP-IDF ≥ 5.4 +Display: 1.69" ST7789V2, 240×280, SPI +Pins (default; make configurable via Kconfig): MOSI=7, SCLK=6, CS=5, DC=2, RST=4, BL=15, BUTTON=0, LED=8, SPEAKER=25, BAT_EN=15 (drive HIGH on battery) +• Project structure (ESP-IDF) +CMakeLists.txt (project) +main/CMakeLists.txt +main/main.c +sdkconfig.defaults (UART console on, tick 1 kHz; placeholders for Wi‑Fi SSID/PASS and GEMINI_API_KEY) +• Functional requirements +Power/Battery: Set BAT_EN (GPIO15) HIGH in app_main. +Display (esp_lcd): +Use esp_lcd_panel_io_spi + esp_lcd_new_panel_st7789. +Implement an auto-probe routine that tries common rotations (0–3), offsets for 240×280 (e.g., 0/20 rows), and SPI clk (24–40 MHz) until color sweep appears; log each attempt. +On success, show simple UI states with solid colors and brief labels (OK to log labels to Serial if you don’t add a font renderer). +Wi‑Fi: +STA mode; read SSID/PASS from Kconfig (fallback to sdkconfig.defaults). +Connect with retry/backoff; log IP or fail after timeout. +Gemini API: +Use esp_http_client + cJSON. +POST to https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=${GEMINI_API_KEY}. +Payload: contents[0].parts[0].text = short prompt; generationConfig with maxOutputTokens=150, temperature=0.7, topP=0.8, topK=40. +Parse candidates[0].content.parts[0].text; log response. +GEMINI_API_KEY configurable via Kconfig string; do not hardcode in source. +UI state machine: +States: BOOT → CONNECTING → READY → LISTENING (simulate 5s) → THINKING (HTTP) → SPEAKING (show/log reply) → READY; ERROR on failures. +Show colors per state and print logs; optional minimal on-screen text. +Audio: +LEDC: 10-bit, tones on SPEAKER=25. Short beep on THINKING; continuous tone during LISTENING/SPEAKING demos. +Input: +Button on GPIO0 (FALLING), ISR + debounce counter to trigger one chat cycle. +• Deliverables +Buildable ESP-IDF project with the files above. +Kconfig options: WIFI_SSID, WIFI_PASSWORD, GEMINI_API_KEY, and LCD pin overrides. +Console logs that clearly show: auto-probe attempts/results, Wi‑Fi connect, HTTP status, extracted Gemini text. +Basic README with build/flash steps and how to set Kconfig. +• Build/flash +idf.py set-target esp32c6 +idf.py menuconfig (set Wi‑Fi and API key) +idf.py build flash monitor +• Acceptance criteria +On boot: color-sweep during LCD auto-probe, then BOOT/CONNECTING/READY cycle. +Button press: LISTENING (tone), THINKING (beep), HTTP POST, SPEAKING (tone) with reply logged, return to READY. +Robust logs (no silent failures); clean error state if Wi‑Fi or HTTP fails. +Keep the code small, clear, and dependency-light (esp_lcd, esp_http_client, cJSON, Wi‑Fi, LEDC). \ No newline at end of file diff --git a/sdkconfig.defaults b/sdkconfig.defaults new file mode 100644 index 0000000..1716a41 --- /dev/null +++ b/sdkconfig.defaults @@ -0,0 +1,26 @@ +# UART console on +CONFIG_ESP_CONSOLE_UART_ENABLE=y +CONFIG_ESP_CONSOLE_UART_NUM=0 +CONFIG_ESP_CONSOLE_UART_BAUDRATE=115200 + +# Tick 1 kHz +CONFIG_FREERTOS_HZ=1000 + +# Wi-Fi SSID and Password placeholders +CONFIG_APP_WIFI_SSID="YOUR_WIFI_SSID" +CONFIG_APP_WIFI_PASSWORD="YOUR_WIFI_PASSWORD" + +# Gemini API Key placeholder +CONFIG_APP_GEMINI_API_KEY="YOUR_GEMINI_API_KEY" + +# Default LCD Pin Configuration (from readme_ai.md) +CONFIG_LCD_PIN_MOSI=7 +CONFIG_LCD_PIN_SCLK=6 +CONFIG_LCD_PIN_CS=5 +CONFIG_LCD_PIN_DC=2 +CONFIG_LCD_PIN_RST=4 +CONFIG_LCD_PIN_BL=15 +CONFIG_LCD_PIN_BUTTON=0 +CONFIG_LCD_PIN_LED=8 +CONFIG_LCD_PIN_SPEAKER=25 +CONFIG_LCD_PIN_BAT_EN=15