├── .gitattributes ├── .gitignore ├── .pio ├── build │ ├── esp32-c3-devkitm-1 │ │ └── idedata.json │ └── project.checksum └── libdeps │ ├── esp32-c3-devkitm-1 │ ├── Adafruit BusIO │ │ ├── .github │ │ │ ├── ISSUE_TEMPLATE.md │ │ │ ├── PULL_REQUEST_TEMPLATE.md │ │ │ └── workflows │ │ │ │ └── githubci.yml │ │ ├── .piopm │ │ ├── Adafruit_BusIO_Register.cpp │ │ ├── Adafruit_BusIO_Register.h │ │ ├── Adafruit_GenericDevice.cpp │ │ ├── Adafruit_GenericDevice.h │ │ ├── Adafruit_I2CDevice.cpp │ │ ├── Adafruit_I2CDevice.h │ │ ├── Adafruit_I2CRegister.h │ │ ├── Adafruit_SPIDevice.cpp │ │ ├── Adafruit_SPIDevice.h │ │ ├── CMakeLists.txt │ │ ├── LICENSE │ │ ├── README.md │ │ ├── component.mk │ │ ├── examples │ │ │ ├── genericdevice_uartregtest │ │ │ │ ├── .uno.test.skip │ │ │ │ └── genericdevice_uartregtest.ino │ │ │ ├── genericdevice_uarttest │ │ │ │ ├── .uno.test.skip │ │ │ │ └── genericdevice_uarttest.ino │ │ │ ├── i2c_address_detect │ │ │ │ └── i2c_address_detect.ino │ │ │ ├── i2c_readwrite │ │ │ │ └── i2c_readwrite.ino │ │ │ ├── i2c_registers │ │ │ │ └── i2c_registers.ino │ │ │ ├── i2corspi_register │ │ │ │ └── i2corspi_register.ino │ │ │ ├── spi_modetest │ │ │ │ └── spi_modetest.ino │ │ │ ├── spi_readwrite │ │ │ │ └── spi_readwrite.ino │ │ │ ├── spi_register_bits │ │ │ │ └── spi_register_bits.ino │ │ │ └── spi_registers │ │ │ │ └── spi_registers.ino │ │ └── library.properties │ ├── Adafruit GFX Library │ │ ├── .github │ │ │ ├── ISSUE_TEMPLATE.md │ │ │ ├── PULL_REQUEST_TEMPLATE.md │ │ │ └── workflows │ │ │ │ └── githubci.yml │ │ ├── .gitignore │ │ ├── .piopm │ │ ├── Adafruit_GFX.cpp │ │ ├── Adafruit_GFX.h │ │ ├── Adafruit_GrayOLED.cpp │ │ ├── Adafruit_GrayOLED.h │ │ ├── Adafruit_SPITFT.cpp │ │ ├── Adafruit_SPITFT.h │ │ ├── Adafruit_SPITFT_Macros.h │ │ ├── CMakeLists.txt │ │ ├── Fonts │ │ │ ├── FreeMono12pt7b.h │ │ │ ├── FreeMono18pt7b.h │ │ │ ├── FreeMono24pt7b.h │ │ │ ├── FreeMono9pt7b.h │ │ │ ├── FreeMonoBold12pt7b.h │ │ │ ├── FreeMonoBold18pt7b.h │ │ │ ├── FreeMonoBold24pt7b.h │ │ │ ├── FreeMonoBold9pt7b.h │ │ │ ├── FreeMonoBoldOblique12pt7b.h │ │ │ ├── FreeMonoBoldOblique18pt7b.h │ │ │ ├── FreeMonoBoldOblique24pt7b.h │ │ │ ├── FreeMonoBoldOblique9pt7b.h │ │ │ ├── FreeMonoOblique12pt7b.h │ │ │ ├── FreeMonoOblique18pt7b.h │ │ │ ├── FreeMonoOblique24pt7b.h │ │ │ ├── FreeMonoOblique9pt7b.h │ │ │ ├── FreeSans12pt7b.h │ │ │ ├── FreeSans18pt7b.h │ │ │ ├── FreeSans24pt7b.h │ │ │ ├── FreeSans9pt7b.h │ │ │ ├── FreeSansBold12pt7b.h │ │ │ ├── FreeSansBold18pt7b.h │ │ │ ├── FreeSansBold24pt7b.h │ │ │ ├── FreeSansBold9pt7b.h │ │ │ ├── FreeSansBoldOblique12pt7b.h │ │ │ ├── FreeSansBoldOblique18pt7b.h │ │ │ ├── FreeSansBoldOblique24pt7b.h │ │ │ ├── FreeSansBoldOblique9pt7b.h │ │ │ ├── FreeSansOblique12pt7b.h │ │ │ ├── FreeSansOblique18pt7b.h │ │ │ ├── FreeSansOblique24pt7b.h │ │ │ ├── FreeSansOblique9pt7b.h │ │ │ ├── FreeSerif12pt7b.h │ │ │ ├── FreeSerif18pt7b.h │ │ │ ├── FreeSerif24pt7b.h │ │ │ ├── FreeSerif9pt7b.h │ │ │ ├── FreeSerifBold12pt7b.h │ │ │ ├── FreeSerifBold18pt7b.h │ │ │ ├── FreeSerifBold24pt7b.h │ │ │ ├── FreeSerifBold9pt7b.h │ │ │ ├── FreeSerifBoldItalic12pt7b.h │ │ │ ├── FreeSerifBoldItalic18pt7b.h │ │ │ ├── FreeSerifBoldItalic24pt7b.h │ │ │ ├── FreeSerifBoldItalic9pt7b.h │ │ │ ├── FreeSerifItalic12pt7b.h │ │ │ ├── FreeSerifItalic18pt7b.h │ │ │ ├── FreeSerifItalic24pt7b.h │ │ │ ├── FreeSerifItalic9pt7b.h │ │ │ ├── Org_01.h │ │ │ ├── Picopixel.h │ │ │ ├── Tiny3x3a2pt7b.h │ │ │ └── TomThumb.h │ │ ├── README.md │ │ ├── component.mk │ │ ├── examples │ │ │ ├── GFXcanvas │ │ │ │ ├── GFXcanvas.ino │ │ │ │ ├── GFXcanvasSerialDemo.cpp │ │ │ │ └── GFXcanvasSerialDemo.h │ │ │ └── mock_ili9341 │ │ │ │ └── mock_ili9341.ino │ │ ├── fontconvert │ │ │ ├── Makefile │ │ │ ├── bdf2adafruit.py │ │ │ ├── fontconvert.c │ │ │ ├── fontconvert_win.md │ │ │ └── makefonts.sh │ │ ├── gfxfont.h │ │ ├── glcdfont.c │ │ ├── library.properties │ │ └── license.txt │ ├── Adafruit SSD1306 │ │ ├── .github │ │ │ ├── ISSUE_TEMPLATE.md │ │ │ ├── PULL_REQUEST_TEMPLATE.md │ │ │ └── workflows │ │ │ │ └── githubci.yml │ │ ├── .gitignore │ │ ├── .piopm │ │ ├── Adafruit_SSD1306.cpp │ │ ├── Adafruit_SSD1306.h │ │ ├── CMakeLists.txt │ │ ├── README.md │ │ ├── component.mk │ │ ├── examples │ │ │ ├── OLED_featherwing │ │ │ │ └── OLED_featherwing.ino │ │ │ ├── ssd1306_128x32_i2c │ │ │ │ └── ssd1306_128x32_i2c.ino │ │ │ ├── ssd1306_128x32_spi │ │ │ │ └── ssd1306_128x32_spi.ino │ │ │ ├── ssd1306_128x64_i2c │ │ │ │ └── ssd1306_128x64_i2c.ino │ │ │ └── ssd1306_128x64_spi │ │ │ │ └── ssd1306_128x64_spi.ino │ │ ├── library.properties │ │ ├── license.txt │ │ ├── scripts │ │ │ ├── Makefile │ │ │ └── make_splash.py │ │ └── splash.h │ ├── ArduinoJson │ │ ├── .piopm │ │ ├── ArduinoJson.h │ │ ├── LICENSE.txt │ │ ├── README.md │ │ ├── examples │ │ │ ├── JsonConfigFile │ │ │ │ └── JsonConfigFile.ino │ │ │ ├── JsonFilterExample │ │ │ │ └── JsonFilterExample.ino │ │ │ ├── JsonGeneratorExample │ │ │ │ └── JsonGeneratorExample.ino │ │ │ ├── JsonHttpClient │ │ │ │ └── JsonHttpClient.ino │ │ │ ├── JsonParserExample │ │ │ │ └── JsonParserExample.ino │ │ │ ├── JsonServer │ │ │ │ └── JsonServer.ino │ │ │ ├── JsonUdpBeacon │ │ │ │ └── JsonUdpBeacon.ino │ │ │ ├── MsgPackParser │ │ │ │ └── MsgPackParser.ino │ │ │ ├── ProgmemExample │ │ │ │ └── ProgmemExample.ino │ │ │ └── StringExample │ │ │ │ └── StringExample.ino │ │ ├── library.json │ │ ├── library.properties │ │ └── src │ │ │ ├── ArduinoJson.h │ │ │ ├── ArduinoJson.hpp │ │ │ ├── ArduinoJson │ │ │ ├── Array │ │ │ │ ├── ElementProxy.hpp │ │ │ │ ├── JsonArray.hpp │ │ │ │ ├── JsonArrayConst.hpp │ │ │ │ ├── JsonArrayImpl.hpp │ │ │ │ ├── JsonArrayIterator.hpp │ │ │ │ └── Utilities.hpp │ │ │ ├── Collection │ │ │ │ ├── CollectionData.hpp │ │ │ │ └── CollectionImpl.hpp │ │ │ ├── Configuration.hpp │ │ │ ├── Deserialization │ │ │ │ ├── DeserializationError.hpp │ │ │ │ ├── DeserializationOptions.hpp │ │ │ │ ├── Filter.hpp │ │ │ │ ├── NestingLimit.hpp │ │ │ │ ├── Reader.hpp │ │ │ │ ├── Readers │ │ │ │ │ ├── ArduinoStreamReader.hpp │ │ │ │ │ ├── ArduinoStringReader.hpp │ │ │ │ │ ├── FlashReader.hpp │ │ │ │ │ ├── IteratorReader.hpp │ │ │ │ │ ├── RamReader.hpp │ │ │ │ │ ├── StdStreamReader.hpp │ │ │ │ │ └── VariantReader.hpp │ │ │ │ └── deserialize.hpp │ │ │ ├── Document │ │ │ │ ├── BasicJsonDocument.hpp │ │ │ │ ├── DynamicJsonDocument.hpp │ │ │ │ ├── JsonDocument.hpp │ │ │ │ └── StaticJsonDocument.hpp │ │ │ ├── Json │ │ │ │ ├── EscapeSequence.hpp │ │ │ │ ├── JsonDeserializer.hpp │ │ │ │ ├── JsonSerializer.hpp │ │ │ │ ├── Latch.hpp │ │ │ │ ├── PrettyJsonSerializer.hpp │ │ │ │ ├── TextFormatter.hpp │ │ │ │ ├── Utf16.hpp │ │ │ │ └── Utf8.hpp │ │ │ ├── Memory │ │ │ │ ├── Alignment.hpp │ │ │ │ └── MemoryPool.hpp │ │ │ ├── Misc │ │ │ │ └── SerializedValue.hpp │ │ │ ├── MsgPack │ │ │ │ ├── MsgPackDeserializer.hpp │ │ │ │ ├── MsgPackSerializer.hpp │ │ │ │ ├── endianess.hpp │ │ │ │ └── ieee754.hpp │ │ │ ├── Namespace.hpp │ │ │ ├── Numbers │ │ │ │ ├── FloatParts.hpp │ │ │ │ ├── FloatTraits.hpp │ │ │ │ ├── JsonFloat.hpp │ │ │ │ ├── JsonInteger.hpp │ │ │ │ ├── arithmeticCompare.hpp │ │ │ │ ├── convertNumber.hpp │ │ │ │ └── parseNumber.hpp │ │ │ ├── Object │ │ │ │ ├── JsonObject.hpp │ │ │ │ ├── JsonObjectConst.hpp │ │ │ │ ├── JsonObjectImpl.hpp │ │ │ │ ├── JsonObjectIterator.hpp │ │ │ │ ├── JsonPair.hpp │ │ │ │ └── MemberProxy.hpp │ │ │ ├── Polyfills │ │ │ │ ├── alias_cast.hpp │ │ │ │ ├── assert.hpp │ │ │ │ ├── attributes.hpp │ │ │ │ ├── ctype.hpp │ │ │ │ ├── integer.hpp │ │ │ │ ├── limits.hpp │ │ │ │ ├── math.hpp │ │ │ │ ├── mpl │ │ │ │ │ └── max.hpp │ │ │ │ ├── pgmspace.hpp │ │ │ │ ├── pgmspace_generic.hpp │ │ │ │ ├── preprocessor.hpp │ │ │ │ ├── type_traits.hpp │ │ │ │ ├── type_traits │ │ │ │ │ ├── conditional.hpp │ │ │ │ │ ├── declval.hpp │ │ │ │ │ ├── enable_if.hpp │ │ │ │ │ ├── integral_constant.hpp │ │ │ │ │ ├── is_array.hpp │ │ │ │ │ ├── is_base_of.hpp │ │ │ │ │ ├── is_class.hpp │ │ │ │ │ ├── is_const.hpp │ │ │ │ │ ├── is_convertible.hpp │ │ │ │ │ ├── is_enum.hpp │ │ │ │ │ ├── is_floating_point.hpp │ │ │ │ │ ├── is_integral.hpp │ │ │ │ │ ├── is_pointer.hpp │ │ │ │ │ ├── is_same.hpp │ │ │ │ │ ├── is_signed.hpp │ │ │ │ │ ├── is_unsigned.hpp │ │ │ │ │ ├── make_unsigned.hpp │ │ │ │ │ ├── make_void.hpp │ │ │ │ │ ├── remove_const.hpp │ │ │ │ │ ├── remove_cv.hpp │ │ │ │ │ ├── remove_reference.hpp │ │ │ │ │ └── type_identity.hpp │ │ │ │ └── utility.hpp │ │ │ ├── Serialization │ │ │ │ ├── CountingDecorator.hpp │ │ │ │ ├── Writer.hpp │ │ │ │ ├── Writers │ │ │ │ │ ├── ArduinoStringWriter.hpp │ │ │ │ │ ├── DummyWriter.hpp │ │ │ │ │ ├── PrintWriter.hpp │ │ │ │ │ ├── StaticStringWriter.hpp │ │ │ │ │ ├── StdStreamWriter.hpp │ │ │ │ │ └── StdStringWriter.hpp │ │ │ │ ├── measure.hpp │ │ │ │ └── serialize.hpp │ │ │ ├── StringStorage │ │ │ │ ├── StringCopier.hpp │ │ │ │ ├── StringMover.hpp │ │ │ │ └── StringStorage.hpp │ │ │ ├── Strings │ │ │ │ ├── Adapters │ │ │ │ │ ├── FlashString.hpp │ │ │ │ │ ├── JsonString.hpp │ │ │ │ │ ├── RamString.hpp │ │ │ │ │ └── StringObject.hpp │ │ │ │ ├── IsString.hpp │ │ │ │ ├── JsonString.hpp │ │ │ │ ├── StoragePolicy.hpp │ │ │ │ ├── StringAdapter.hpp │ │ │ │ ├── StringAdapters.hpp │ │ │ │ └── StringTraits.hpp │ │ │ ├── Variant │ │ │ │ ├── Converter.hpp │ │ │ │ ├── ConverterImpl.hpp │ │ │ │ ├── JsonVariant.hpp │ │ │ │ ├── JsonVariantConst.hpp │ │ │ │ ├── SlotFunctions.hpp │ │ │ │ ├── VariantAttorney.hpp │ │ │ │ ├── VariantCompare.hpp │ │ │ │ ├── VariantContent.hpp │ │ │ │ ├── VariantData.hpp │ │ │ │ ├── VariantFunctions.hpp │ │ │ │ ├── VariantImpl.hpp │ │ │ │ ├── VariantOperators.hpp │ │ │ │ ├── VariantRefBase.hpp │ │ │ │ ├── VariantSlot.hpp │ │ │ │ ├── VariantTag.hpp │ │ │ │ ├── VariantTo.hpp │ │ │ │ └── Visitor.hpp │ │ │ ├── compatibility.hpp │ │ │ └── version.hpp │ │ │ └── CMakeLists.txt │ ├── AsyncTCP │ │ ├── .github │ │ │ ├── scripts │ │ │ │ ├── install-arduino-core-esp32.sh │ │ │ │ ├── install-arduino-ide.sh │ │ │ │ ├── install-platformio.sh │ │ │ │ └── on-push.sh │ │ │ ├── stale.yml │ │ │ └── workflows │ │ │ │ └── push.yml │ │ ├── .gitignore │ │ ├── .piopm │ │ ├── .travis.yml │ │ ├── CMakeLists.txt │ │ ├── Kconfig.projbuild │ │ ├── LICENSE │ │ ├── README.md │ │ ├── component.mk │ │ ├── library.json │ │ ├── library.properties │ │ └── src │ │ │ ├── AsyncTCP.cpp │ │ │ └── AsyncTCP.h │ └── integrity.dat │ └── seeed_xiao_esp32c3 │ ├── Adafruit BusIO │ ├── .github │ │ ├── ISSUE_TEMPLATE.md │ │ ├── PULL_REQUEST_TEMPLATE.md │ │ └── workflows │ │ │ └── githubci.yml │ ├── .piopm │ ├── Adafruit_BusIO_Register.cpp │ ├── Adafruit_BusIO_Register.h │ ├── Adafruit_GenericDevice.cpp │ ├── Adafruit_GenericDevice.h │ ├── Adafruit_I2CDevice.cpp │ ├── Adafruit_I2CDevice.h │ ├── Adafruit_I2CRegister.h │ ├── Adafruit_SPIDevice.cpp │ ├── Adafruit_SPIDevice.h │ ├── CMakeLists.txt │ ├── LICENSE │ ├── README.md │ ├── component.mk │ ├── examples │ │ ├── genericdevice_uartregtest │ │ │ ├── .uno.test.skip │ │ │ └── genericdevice_uartregtest.ino │ │ ├── genericdevice_uarttest │ │ │ ├── .uno.test.skip │ │ │ └── genericdevice_uarttest.ino │ │ ├── i2c_address_detect │ │ │ └── i2c_address_detect.ino │ │ ├── i2c_readwrite │ │ │ └── i2c_readwrite.ino │ │ ├── i2c_registers │ │ │ └── i2c_registers.ino │ │ ├── i2corspi_register │ │ │ └── i2corspi_register.ino │ │ ├── spi_modetest │ │ │ └── spi_modetest.ino │ │ ├── spi_readwrite │ │ │ └── spi_readwrite.ino │ │ ├── spi_register_bits │ │ │ └── spi_register_bits.ino │ │ └── spi_registers │ │ │ └── spi_registers.ino │ └── library.properties │ ├── Adafruit GFX Library │ ├── .github │ │ ├── ISSUE_TEMPLATE.md │ │ ├── PULL_REQUEST_TEMPLATE.md │ │ └── workflows │ │ │ └── githubci.yml │ ├── .gitignore │ ├── .piopm │ ├── Adafruit_GFX.cpp │ ├── Adafruit_GFX.h │ ├── Adafruit_GrayOLED.cpp │ ├── Adafruit_GrayOLED.h │ ├── Adafruit_SPITFT.cpp │ ├── Adafruit_SPITFT.h │ ├── Adafruit_SPITFT_Macros.h │ ├── CMakeLists.txt │ ├── Fonts │ │ ├── FreeMono12pt7b.h │ │ ├── FreeMono18pt7b.h │ │ ├── FreeMono24pt7b.h │ │ ├── FreeMono9pt7b.h │ │ ├── FreeMonoBold12pt7b.h │ │ ├── FreeMonoBold18pt7b.h │ │ ├── FreeMonoBold24pt7b.h │ │ ├── FreeMonoBold9pt7b.h │ │ ├── FreeMonoBoldOblique12pt7b.h │ │ ├── FreeMonoBoldOblique18pt7b.h │ │ ├── FreeMonoBoldOblique24pt7b.h │ │ ├── FreeMonoBoldOblique9pt7b.h │ │ ├── FreeMonoOblique12pt7b.h │ │ ├── FreeMonoOblique18pt7b.h │ │ ├── FreeMonoOblique24pt7b.h │ │ ├── FreeMonoOblique9pt7b.h │ │ ├── FreeSans12pt7b.h │ │ ├── FreeSans18pt7b.h │ │ ├── FreeSans24pt7b.h │ │ ├── FreeSans9pt7b.h │ │ ├── FreeSansBold12pt7b.h │ │ ├── FreeSansBold18pt7b.h │ │ ├── FreeSansBold24pt7b.h │ │ ├── FreeSansBold9pt7b.h │ │ ├── FreeSansBoldOblique12pt7b.h │ │ ├── FreeSansBoldOblique18pt7b.h │ │ ├── FreeSansBoldOblique24pt7b.h │ │ ├── FreeSansBoldOblique9pt7b.h │ │ ├── FreeSansOblique12pt7b.h │ │ ├── FreeSansOblique18pt7b.h │ │ ├── FreeSansOblique24pt7b.h │ │ ├── FreeSansOblique9pt7b.h │ │ ├── FreeSerif12pt7b.h │ │ ├── FreeSerif18pt7b.h │ │ ├── FreeSerif24pt7b.h │ │ ├── FreeSerif9pt7b.h │ │ ├── FreeSerifBold12pt7b.h │ │ ├── FreeSerifBold18pt7b.h │ │ ├── FreeSerifBold24pt7b.h │ │ ├── FreeSerifBold9pt7b.h │ │ ├── FreeSerifBoldItalic12pt7b.h │ │ ├── FreeSerifBoldItalic18pt7b.h │ │ ├── FreeSerifBoldItalic24pt7b.h │ │ ├── FreeSerifBoldItalic9pt7b.h │ │ ├── FreeSerifItalic12pt7b.h │ │ ├── FreeSerifItalic18pt7b.h │ │ ├── FreeSerifItalic24pt7b.h │ │ ├── FreeSerifItalic9pt7b.h │ │ ├── Org_01.h │ │ ├── Picopixel.h │ │ ├── Tiny3x3a2pt7b.h │ │ └── TomThumb.h │ ├── README.md │ ├── component.mk │ ├── examples │ │ ├── GFXcanvas │ │ │ ├── GFXcanvas.ino │ │ │ ├── GFXcanvasSerialDemo.cpp │ │ │ └── GFXcanvasSerialDemo.h │ │ └── mock_ili9341 │ │ │ └── mock_ili9341.ino │ ├── fontconvert │ │ ├── Makefile │ │ ├── bdf2adafruit.py │ │ ├── fontconvert.c │ │ ├── fontconvert_win.md │ │ └── makefonts.sh │ ├── gfxfont.h │ ├── glcdfont.c │ ├── library.properties │ └── license.txt │ ├── Adafruit SSD1306 │ ├── .github │ │ ├── ISSUE_TEMPLATE.md │ │ ├── PULL_REQUEST_TEMPLATE.md │ │ └── workflows │ │ │ └── githubci.yml │ ├── .gitignore │ ├── .piopm │ ├── Adafruit_SSD1306.cpp │ ├── Adafruit_SSD1306.h │ ├── CMakeLists.txt │ ├── README.md │ ├── component.mk │ ├── examples │ │ ├── OLED_featherwing │ │ │ └── OLED_featherwing.ino │ │ ├── ssd1306_128x32_i2c │ │ │ └── ssd1306_128x32_i2c.ino │ │ ├── ssd1306_128x32_spi │ │ │ └── ssd1306_128x32_spi.ino │ │ ├── ssd1306_128x64_i2c │ │ │ └── ssd1306_128x64_i2c.ino │ │ └── ssd1306_128x64_spi │ │ │ └── ssd1306_128x64_spi.ino │ ├── library.properties │ ├── license.txt │ ├── scripts │ │ ├── Makefile │ │ └── make_splash.py │ └── splash.h │ ├── ArduinoJson │ ├── .piopm │ ├── ArduinoJson.h │ ├── LICENSE.txt │ ├── README.md │ ├── examples │ │ ├── JsonConfigFile │ │ │ └── JsonConfigFile.ino │ │ ├── JsonFilterExample │ │ │ └── JsonFilterExample.ino │ │ ├── JsonGeneratorExample │ │ │ └── JsonGeneratorExample.ino │ │ ├── JsonHttpClient │ │ │ └── JsonHttpClient.ino │ │ ├── JsonParserExample │ │ │ └── JsonParserExample.ino │ │ ├── JsonServer │ │ │ └── JsonServer.ino │ │ ├── JsonUdpBeacon │ │ │ └── JsonUdpBeacon.ino │ │ ├── MsgPackParser │ │ │ └── MsgPackParser.ino │ │ ├── ProgmemExample │ │ │ └── ProgmemExample.ino │ │ └── StringExample │ │ │ └── StringExample.ino │ ├── library.json │ ├── library.properties │ └── src │ │ ├── ArduinoJson.h │ │ ├── ArduinoJson.hpp │ │ ├── ArduinoJson │ │ ├── Array │ │ │ ├── ElementProxy.hpp │ │ │ ├── JsonArray.hpp │ │ │ ├── JsonArrayConst.hpp │ │ │ ├── JsonArrayImpl.hpp │ │ │ ├── JsonArrayIterator.hpp │ │ │ └── Utilities.hpp │ │ ├── Collection │ │ │ ├── CollectionData.hpp │ │ │ └── CollectionImpl.hpp │ │ ├── Configuration.hpp │ │ ├── Deserialization │ │ │ ├── DeserializationError.hpp │ │ │ ├── DeserializationOptions.hpp │ │ │ ├── Filter.hpp │ │ │ ├── NestingLimit.hpp │ │ │ ├── Reader.hpp │ │ │ ├── Readers │ │ │ │ ├── ArduinoStreamReader.hpp │ │ │ │ ├── ArduinoStringReader.hpp │ │ │ │ ├── FlashReader.hpp │ │ │ │ ├── IteratorReader.hpp │ │ │ │ ├── RamReader.hpp │ │ │ │ ├── StdStreamReader.hpp │ │ │ │ └── VariantReader.hpp │ │ │ └── deserialize.hpp │ │ ├── Document │ │ │ ├── BasicJsonDocument.hpp │ │ │ ├── DynamicJsonDocument.hpp │ │ │ ├── JsonDocument.hpp │ │ │ └── StaticJsonDocument.hpp │ │ ├── Json │ │ │ ├── EscapeSequence.hpp │ │ │ ├── JsonDeserializer.hpp │ │ │ ├── JsonSerializer.hpp │ │ │ ├── Latch.hpp │ │ │ ├── PrettyJsonSerializer.hpp │ │ │ ├── TextFormatter.hpp │ │ │ ├── Utf16.hpp │ │ │ └── Utf8.hpp │ │ ├── Memory │ │ │ ├── Alignment.hpp │ │ │ └── MemoryPool.hpp │ │ ├── Misc │ │ │ └── SerializedValue.hpp │ │ ├── MsgPack │ │ │ ├── MsgPackDeserializer.hpp │ │ │ ├── MsgPackSerializer.hpp │ │ │ ├── endianess.hpp │ │ │ └── ieee754.hpp │ │ ├── Namespace.hpp │ │ ├── Numbers │ │ │ ├── FloatParts.hpp │ │ │ ├── FloatTraits.hpp │ │ │ ├── JsonFloat.hpp │ │ │ ├── JsonInteger.hpp │ │ │ ├── arithmeticCompare.hpp │ │ │ ├── convertNumber.hpp │ │ │ └── parseNumber.hpp │ │ ├── Object │ │ │ ├── JsonObject.hpp │ │ │ ├── JsonObjectConst.hpp │ │ │ ├── JsonObjectImpl.hpp │ │ │ ├── JsonObjectIterator.hpp │ │ │ ├── JsonPair.hpp │ │ │ └── MemberProxy.hpp │ │ ├── Polyfills │ │ │ ├── alias_cast.hpp │ │ │ ├── assert.hpp │ │ │ ├── attributes.hpp │ │ │ ├── ctype.hpp │ │ │ ├── integer.hpp │ │ │ ├── limits.hpp │ │ │ ├── math.hpp │ │ │ ├── mpl │ │ │ │ └── max.hpp │ │ │ ├── pgmspace.hpp │ │ │ ├── pgmspace_generic.hpp │ │ │ ├── preprocessor.hpp │ │ │ ├── type_traits.hpp │ │ │ ├── type_traits │ │ │ │ ├── conditional.hpp │ │ │ │ ├── declval.hpp │ │ │ │ ├── enable_if.hpp │ │ │ │ ├── integral_constant.hpp │ │ │ │ ├── is_array.hpp │ │ │ │ ├── is_base_of.hpp │ │ │ │ ├── is_class.hpp │ │ │ │ ├── is_const.hpp │ │ │ │ ├── is_convertible.hpp │ │ │ │ ├── is_enum.hpp │ │ │ │ ├── is_floating_point.hpp │ │ │ │ ├── is_integral.hpp │ │ │ │ ├── is_pointer.hpp │ │ │ │ ├── is_same.hpp │ │ │ │ ├── is_signed.hpp │ │ │ │ ├── is_unsigned.hpp │ │ │ │ ├── make_unsigned.hpp │ │ │ │ ├── make_void.hpp │ │ │ │ ├── remove_const.hpp │ │ │ │ ├── remove_cv.hpp │ │ │ │ ├── remove_reference.hpp │ │ │ │ └── type_identity.hpp │ │ │ └── utility.hpp │ │ ├── Serialization │ │ │ ├── CountingDecorator.hpp │ │ │ ├── Writer.hpp │ │ │ ├── Writers │ │ │ │ ├── ArduinoStringWriter.hpp │ │ │ │ ├── DummyWriter.hpp │ │ │ │ ├── PrintWriter.hpp │ │ │ │ ├── StaticStringWriter.hpp │ │ │ │ ├── StdStreamWriter.hpp │ │ │ │ └── StdStringWriter.hpp │ │ │ ├── measure.hpp │ │ │ └── serialize.hpp │ │ ├── StringStorage │ │ │ ├── StringCopier.hpp │ │ │ ├── StringMover.hpp │ │ │ └── StringStorage.hpp │ │ ├── Strings │ │ │ ├── Adapters │ │ │ │ ├── FlashString.hpp │ │ │ │ ├── JsonString.hpp │ │ │ │ ├── RamString.hpp │ │ │ │ └── StringObject.hpp │ │ │ ├── IsString.hpp │ │ │ ├── JsonString.hpp │ │ │ ├── StoragePolicy.hpp │ │ │ ├── StringAdapter.hpp │ │ │ ├── StringAdapters.hpp │ │ │ └── StringTraits.hpp │ │ ├── Variant │ │ │ ├── Converter.hpp │ │ │ ├── ConverterImpl.hpp │ │ │ ├── JsonVariant.hpp │ │ │ ├── JsonVariantConst.hpp │ │ │ ├── SlotFunctions.hpp │ │ │ ├── VariantAttorney.hpp │ │ │ ├── VariantCompare.hpp │ │ │ ├── VariantContent.hpp │ │ │ ├── VariantData.hpp │ │ │ ├── VariantFunctions.hpp │ │ │ ├── VariantImpl.hpp │ │ │ ├── VariantOperators.hpp │ │ │ ├── VariantRefBase.hpp │ │ │ ├── VariantSlot.hpp │ │ │ ├── VariantTag.hpp │ │ │ ├── VariantTo.hpp │ │ │ └── Visitor.hpp │ │ ├── compatibility.hpp │ │ └── version.hpp │ │ └── CMakeLists.txt │ ├── AsyncTCP │ ├── .piopm │ ├── LICENSE │ ├── README.md │ ├── examples │ │ ├── AsyncSend │ │ │ └── AsyncSend.ino │ │ ├── Client │ │ │ └── Client.ino │ │ └── FetchWebsite │ │ │ └── FetchWebsite.ino │ ├── library.json │ ├── library.properties │ └── src │ │ ├── AsyncTCP.cpp │ │ ├── AsyncTCP.h │ │ └── AsyncTCPVersion.h │ ├── AsyncTCP@1.1.1 │ ├── .github │ │ ├── scripts │ │ │ ├── install-arduino-core-esp32.sh │ │ │ ├── install-arduino-ide.sh │ │ │ ├── install-platformio.sh │ │ │ └── on-push.sh │ │ ├── stale.yml │ │ └── workflows │ │ │ └── push.yml │ ├── .gitignore │ ├── .piopm │ ├── .travis.yml │ ├── CMakeLists.txt │ ├── Kconfig.projbuild │ ├── LICENSE │ ├── README.md │ ├── component.mk │ ├── library.json │ ├── library.properties │ └── src │ │ ├── AsyncTCP.cpp │ │ └── AsyncTCP.h │ ├── ESPAsyncTCP │ ├── .github │ │ ├── scripts │ │ │ ├── install-arduino-core-esp8266.sh │ │ │ ├── install-arduino-ide.sh │ │ │ ├── install-platformio.sh │ │ │ └── on-push.sh │ │ ├── stale.yml │ │ └── workflows │ │ │ └── push.yml │ ├── .gitignore │ ├── .piopm │ ├── LICENSE.txt │ ├── README.md │ ├── examples │ │ ├── ClientServer │ │ │ ├── Client │ │ │ │ ├── Client.ino │ │ │ │ └── config.h │ │ │ └── Server │ │ │ │ ├── Server.ino │ │ │ │ └── config.h │ │ └── SyncClient │ │ │ ├── .esp31b.skip │ │ │ └── SyncClient.ino │ ├── library.json │ ├── library.properties │ ├── src │ │ ├── AsyncPrinter.cpp │ │ ├── AsyncPrinter.h │ │ ├── DebugPrintMacros.h │ │ ├── ESPAsyncTCP.cpp │ │ ├── ESPAsyncTCP.h │ │ ├── ESPAsyncTCPbuffer.cpp │ │ ├── ESPAsyncTCPbuffer.h │ │ ├── SyncClient.cpp │ │ ├── SyncClient.h │ │ ├── async_config.h │ │ ├── tcp_axtls.c │ │ └── tcp_axtls.h │ └── ssl │ │ ├── gen_server_cert.sh │ │ ├── server.cer │ │ └── server.key │ ├── RPAsyncTCP │ ├── .codespellrc │ ├── .github │ │ ├── ISSUE_TEMPLATE │ │ │ ├── bug_report.md │ │ │ └── feature_request.md │ │ └── workflows │ │ │ ├── build-arduino.yml │ │ │ ├── build-pio.yml │ │ │ ├── report-size-deltas.yml │ │ │ └── stale.yml │ ├── .gitignore │ ├── .piopm │ ├── CONTRIBUTING.md │ ├── LICENSE │ ├── README.md │ ├── changelog.md │ ├── docs │ │ ├── splash-dark.png │ │ └── splash-light.png │ ├── examples │ │ ├── Client │ │ │ └── Client.ino │ │ └── Server │ │ │ └── Server.ino │ ├── library.json │ ├── library.properties │ ├── platformio.ini │ ├── src │ │ ├── AsyncPrinter.cpp │ │ ├── AsyncPrinter.h │ │ ├── DebugPrintMacros.h │ │ ├── RPAsyncTCP.cpp │ │ ├── RPAsyncTCP.h │ │ ├── RPAsyncTCP_Debug.h │ │ ├── RPAsyncTCP_buffer.cpp │ │ ├── RPAsyncTCP_buffer.h │ │ ├── SyncClient.cpp │ │ ├── SyncClient.h │ │ ├── async_config.h │ │ ├── c_types.h │ │ ├── cbuf.cpp │ │ ├── cbuf.h │ │ ├── debug.cpp │ │ ├── debug.h │ │ ├── tcp_axtls.c │ │ └── tcp_axtls.h │ └── utils │ │ ├── astyle_library.conf │ │ └── restyle.sh │ └── integrity.dat ├── .vscode ├── c_cpp_properties.json ├── extensions.json └── launch.json ├── HARDWARE ├── FM_TX.PcbDoc ├── FM_TX.PrjPcb ├── FM_TX.SchDoc └── GERBER.zip ├── LICENSE ├── README.md ├── README_EN.md ├── README_JP.md ├── data ├── index.html ├── script.js └── style.css ├── img ├── IMG_5528(20250418-191057).JPG ├── coilcraft_logo.png ├── fmtx.JPG ├── fmtx.png ├── pcb_back.png ├── pcb_front.png └── power_test.png ├── include └── README ├── lib ├── QN8027 │ ├── QN8027Radio.cpp │ └── QN8027Radio.h └── README ├── platformio.ini ├── src └── main.cpp └── test └── README /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Prerequisites 2 | *.d 3 | 4 | # Compiled Object files 5 | *.slo 6 | *.lo 7 | *.o 8 | *.obj 9 | 10 | # Precompiled Headers 11 | *.gch 12 | *.pch 13 | 14 | # Compiled Dynamic libraries 15 | *.so 16 | *.dylib 17 | *.dll 18 | 19 | # Fortran module files 20 | *.mod 21 | *.smod 22 | 23 | # Compiled Static libraries 24 | *.lai 25 | *.la 26 | *.a 27 | *.lib 28 | 29 | # Executables 30 | *.exe 31 | *.out 32 | *.app 33 | -------------------------------------------------------------------------------- /.pio/build/project.checksum: -------------------------------------------------------------------------------- 1 | 3e0d960aa8e4bdf6fd6e002d6c47bc532ccd6f77 -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/.github/workflows/githubci.yml: -------------------------------------------------------------------------------- 1 | name: Arduino Library CI 2 | 3 | on: [pull_request, push, repository_dispatch] 4 | 5 | jobs: 6 | build: 7 | runs-on: ubuntu-latest 8 | 9 | steps: 10 | - uses: actions/setup-python@v4 11 | with: 12 | python-version: '3.x' 13 | - uses: actions/checkout@v3 14 | - uses: actions/checkout@v3 15 | with: 16 | repository: adafruit/ci-arduino 17 | path: ci 18 | 19 | - name: Install the prerequisites 20 | run: bash ci/actions_install.sh 21 | 22 | - name: Check for correct code formatting with clang-format 23 | run: python3 ci/run-clang-format.py -e "ci/*" -e "bin/*" -r . 24 | 25 | - name: Check for correct documentation with doxygen 26 | env: 27 | GH_REPO_TOKEN: ${{ secrets.GH_REPO_TOKEN }} 28 | PRETTYNAME : "Adafruit Bus IO Library" 29 | run: bash ci/doxy_gen_and_deploy.sh 30 | 31 | - name: Test the code on supported platforms 32 | run: python3 ci/build_platform.py main_platforms zero feather32u4 33 | 34 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/.piopm: -------------------------------------------------------------------------------- 1 | {"type": "library", "name": "Adafruit BusIO", "version": "1.17.0", "spec": {"owner": "adafruit", "id": 6214, "name": "Adafruit BusIO", "requirements": null, "uri": null}} -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/Adafruit_I2CRegister.h: -------------------------------------------------------------------------------- 1 | #ifndef _ADAFRUIT_I2C_REGISTER_H_ 2 | #define _ADAFRUIT_I2C_REGISTER_H_ 3 | 4 | #include 5 | #include 6 | 7 | typedef Adafruit_BusIO_Register Adafruit_I2CRegister; 8 | typedef Adafruit_BusIO_RegisterBits Adafruit_I2CRegisterBits; 9 | 10 | #endif 11 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Adafruit Bus IO Library 2 | # https://github.com/adafruit/Adafruit_BusIO 3 | # MIT License 4 | 5 | cmake_minimum_required(VERSION 3.5) 6 | 7 | idf_component_register(SRCS "Adafruit_I2CDevice.cpp" "Adafruit_BusIO_Register.cpp" "Adafruit_SPIDevice.cpp" 8 | INCLUDE_DIRS "." 9 | REQUIRES arduino-esp32) 10 | 11 | project(Adafruit_BusIO) 12 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2017 Adafruit Industries 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/README.md: -------------------------------------------------------------------------------- 1 | # Adafruit Bus IO Library [![Build Status](https://github.com/adafruit/Adafruit_BusIO/workflows/Arduino%20Library%20CI/badge.svg)](https://github.com/adafruit/Adafruit_BusIO/actions) 2 | 3 | 4 | This is a helper library to abstract away I2C, SPI, and 'generic transport' (e.g. UART) transactions and registers 5 | 6 | Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit! 7 | 8 | MIT license, all text above must be included in any redistribution 9 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/component.mk: -------------------------------------------------------------------------------- 1 | COMPONENT_ADD_INCLUDEDIRS = . 2 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/examples/genericdevice_uartregtest/.uno.test.skip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/emoestudio/ESP32C3_FM_TRANSMITTER/89e15ecc685345bd09ffc6144ae0cd63ae41983e/.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/examples/genericdevice_uartregtest/.uno.test.skip -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/examples/genericdevice_uarttest/.uno.test.skip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/emoestudio/ESP32C3_FM_TRANSMITTER/89e15ecc685345bd09ffc6144ae0cd63ae41983e/.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/examples/genericdevice_uarttest/.uno.test.skip -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/examples/i2c_address_detect/i2c_address_detect.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | Adafruit_I2CDevice i2c_dev = Adafruit_I2CDevice(0x10); 4 | 5 | void setup() { 6 | while (!Serial) { delay(10); } 7 | Serial.begin(115200); 8 | Serial.println("I2C address detection test"); 9 | 10 | if (!i2c_dev.begin()) { 11 | Serial.print("Did not find device at 0x"); 12 | Serial.println(i2c_dev.address(), HEX); 13 | while (1); 14 | } 15 | Serial.print("Device found on address 0x"); 16 | Serial.println(i2c_dev.address(), HEX); 17 | } 18 | 19 | void loop() { 20 | 21 | } 22 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/examples/i2c_readwrite/i2c_readwrite.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define I2C_ADDRESS 0x60 4 | Adafruit_I2CDevice i2c_dev = Adafruit_I2CDevice(I2C_ADDRESS); 5 | 6 | 7 | void setup() { 8 | while (!Serial) { delay(10); } 9 | Serial.begin(115200); 10 | Serial.println("I2C device read and write test"); 11 | 12 | if (!i2c_dev.begin()) { 13 | Serial.print("Did not find device at 0x"); 14 | Serial.println(i2c_dev.address(), HEX); 15 | while (1); 16 | } 17 | Serial.print("Device found on address 0x"); 18 | Serial.println(i2c_dev.address(), HEX); 19 | 20 | uint8_t buffer[32]; 21 | // Try to read 32 bytes 22 | i2c_dev.read(buffer, 32); 23 | Serial.print("Read: "); 24 | for (uint8_t i=0; i<32; i++) { 25 | Serial.print("0x"); Serial.print(buffer[i], HEX); Serial.print(", "); 26 | } 27 | Serial.println(); 28 | 29 | // read a register by writing first, then reading 30 | buffer[0] = 0x0C; // we'll reuse the same buffer 31 | i2c_dev.write_then_read(buffer, 1, buffer, 2, false); 32 | Serial.print("Write then Read: "); 33 | for (uint8_t i=0; i<2; i++) { 34 | Serial.print("0x"); Serial.print(buffer[i], HEX); Serial.print(", "); 35 | } 36 | Serial.println(); 37 | } 38 | 39 | void loop() { 40 | 41 | } 42 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/examples/i2c_registers/i2c_registers.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define I2C_ADDRESS 0x60 5 | Adafruit_I2CDevice i2c_dev = Adafruit_I2CDevice(I2C_ADDRESS); 6 | 7 | 8 | void setup() { 9 | while (!Serial) { delay(10); } 10 | Serial.begin(115200); 11 | Serial.println("I2C device register test"); 12 | 13 | if (!i2c_dev.begin()) { 14 | Serial.print("Did not find device at 0x"); 15 | Serial.println(i2c_dev.address(), HEX); 16 | while (1); 17 | } 18 | Serial.print("Device found on address 0x"); 19 | Serial.println(i2c_dev.address(), HEX); 20 | 21 | Adafruit_BusIO_Register id_reg = Adafruit_BusIO_Register(&i2c_dev, 0x0C, 2, LSBFIRST); 22 | uint16_t id; 23 | id_reg.read(&id); 24 | Serial.print("ID register = 0x"); Serial.println(id, HEX); 25 | 26 | Adafruit_BusIO_Register thresh_reg = Adafruit_BusIO_Register(&i2c_dev, 0x01, 2, LSBFIRST); 27 | uint16_t thresh; 28 | thresh_reg.read(&thresh); 29 | Serial.print("Initial threshold register = 0x"); Serial.println(thresh, HEX); 30 | 31 | thresh_reg.write(~thresh); 32 | 33 | Serial.print("Post threshold register = 0x"); Serial.println(thresh_reg.read(), HEX); 34 | } 35 | 36 | void loop() { 37 | 38 | } -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/examples/i2corspi_register/i2corspi_register.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // Define which interface to use by setting the unused interface to NULL! 4 | 5 | #define SPIDEVICE_CS 10 6 | Adafruit_SPIDevice *spi_dev = NULL; // new Adafruit_SPIDevice(SPIDEVICE_CS); 7 | 8 | #define I2C_ADDRESS 0x5D 9 | Adafruit_I2CDevice *i2c_dev = new Adafruit_I2CDevice(I2C_ADDRESS); 10 | 11 | void setup() { 12 | while (!Serial) { delay(10); } 13 | Serial.begin(115200); 14 | Serial.println("I2C or SPI device register test"); 15 | 16 | if (spi_dev && !spi_dev->begin()) { 17 | Serial.println("Could not initialize SPI device"); 18 | } 19 | 20 | if (i2c_dev) { 21 | if (i2c_dev->begin()) { 22 | Serial.print("Device found on I2C address 0x"); 23 | Serial.println(i2c_dev->address(), HEX); 24 | } else { 25 | Serial.print("Did not find I2C device at 0x"); 26 | Serial.println(i2c_dev->address(), HEX); 27 | } 28 | } 29 | 30 | Adafruit_BusIO_Register id_reg = Adafruit_BusIO_Register(i2c_dev, spi_dev, ADDRBIT8_HIGH_TOREAD, 0x0F); 31 | uint8_t id=0; 32 | id_reg.read(&id); 33 | Serial.print("ID register = 0x"); Serial.println(id, HEX); 34 | } 35 | 36 | void loop() { 37 | 38 | } 39 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/examples/spi_modetest/spi_modetest.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define SPIDEVICE_CS 10 4 | Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS, 100000, SPI_BITORDER_MSBFIRST, SPI_MODE1); 5 | //Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS, 13, 12, 11, 100000, SPI_BITORDER_MSBFIRST, SPI_MODE1); 6 | 7 | 8 | void setup() { 9 | while (!Serial) { delay(10); } 10 | Serial.begin(115200); 11 | Serial.println("SPI device mode test"); 12 | 13 | if (!spi_dev.begin()) { 14 | Serial.println("Could not initialize SPI device"); 15 | while (1); 16 | } 17 | } 18 | 19 | void loop() { 20 | Serial.println("\n\nTransfer test"); 21 | for (uint16_t x=0; x<=0xFF; x++) { 22 | uint8_t i = x; 23 | Serial.print("0x"); Serial.print(i, HEX); 24 | spi_dev.read(&i, 1, i); 25 | Serial.print("/"); Serial.print(i, HEX); 26 | Serial.print(", "); 27 | delay(25); 28 | } 29 | } -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/examples/spi_readwrite/spi_readwrite.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define SPIDEVICE_CS 10 4 | Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS); 5 | 6 | 7 | void setup() { 8 | while (!Serial) { delay(10); } 9 | Serial.begin(115200); 10 | Serial.println("SPI device read and write test"); 11 | 12 | if (!spi_dev.begin()) { 13 | Serial.println("Could not initialize SPI device"); 14 | while (1); 15 | } 16 | 17 | uint8_t buffer[32]; 18 | 19 | // Try to read 32 bytes 20 | spi_dev.read(buffer, 32); 21 | Serial.print("Read: "); 22 | for (uint8_t i=0; i<32; i++) { 23 | Serial.print("0x"); Serial.print(buffer[i], HEX); Serial.print(", "); 24 | } 25 | Serial.println(); 26 | 27 | // read a register by writing first, then reading 28 | buffer[0] = 0x8F; // we'll reuse the same buffer 29 | spi_dev.write_then_read(buffer, 1, buffer, 2, false); 30 | Serial.print("Write then Read: "); 31 | for (uint8_t i=0; i<2; i++) { 32 | Serial.print("0x"); Serial.print(buffer[i], HEX); Serial.print(", "); 33 | } 34 | Serial.println(); 35 | } 36 | 37 | void loop() { 38 | 39 | } 40 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/examples/spi_registers/spi_registers.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define SPIDEVICE_CS 10 5 | Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS); 6 | 7 | void setup() { 8 | while (!Serial) { delay(10); } 9 | Serial.begin(115200); 10 | Serial.println("SPI device register test"); 11 | 12 | if (!spi_dev.begin()) { 13 | Serial.println("Could not initialize SPI device"); 14 | while (1); 15 | } 16 | 17 | Adafruit_BusIO_Register id_reg = Adafruit_BusIO_Register(&spi_dev, 0x0F, ADDRBIT8_HIGH_TOREAD); 18 | uint8_t id = 0; 19 | id_reg.read(&id); 20 | Serial.print("ID register = 0x"); Serial.println(id, HEX); 21 | 22 | Adafruit_BusIO_Register thresh_reg = Adafruit_BusIO_Register(&spi_dev, 0x0C, ADDRBIT8_HIGH_TOREAD, 2, LSBFIRST); 23 | uint16_t thresh = 0; 24 | thresh_reg.read(&thresh); 25 | Serial.print("Initial threshold register = 0x"); Serial.println(thresh, HEX); 26 | 27 | thresh_reg.write(~thresh); 28 | 29 | Serial.print("Post threshold register = 0x"); Serial.println(thresh_reg.read(), HEX); 30 | } 31 | 32 | void loop() { 33 | 34 | } 35 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit BusIO/library.properties: -------------------------------------------------------------------------------- 1 | name=Adafruit BusIO 2 | version=1.17.0 3 | author=Adafruit 4 | maintainer=Adafruit 5 | sentence=This is a library for abstracting away UART, I2C and SPI interfacing 6 | paragraph=This is a library for abstracting away UART, I2C and SPI interfacing 7 | category=Signal Input/Output 8 | url=https://github.com/adafruit/Adafruit_BusIO 9 | architectures=* 10 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit GFX Library/.github/workflows/githubci.yml: -------------------------------------------------------------------------------- 1 | name: Arduino Library CI 2 | 3 | on: [pull_request, push, repository_dispatch] 4 | 5 | jobs: 6 | build: 7 | runs-on: ubuntu-latest 8 | 9 | steps: 10 | - uses: actions/setup-python@v4 11 | with: 12 | python-version: '3.x' 13 | - uses: actions/checkout@v3 14 | - uses: actions/checkout@v3 15 | with: 16 | repository: adafruit/ci-arduino 17 | path: ci 18 | 19 | - name: pre-install 20 | run: bash ci/actions_install.sh 21 | 22 | - name: extra libraries 23 | run: | 24 | git clone --quiet https://github.com/adafruit/Adafruit_ILI9341.git /home/runner/Arduino/libraries/Adafruit_ILI9341 25 | 26 | - name: test platforms 27 | run: python3 ci/build_platform.py main_platforms 28 | 29 | - name: clang 30 | run: python3 ci/run-clang-format.py -e "ci/*" -e "bin/*" -r . 31 | 32 | - name: doxygen 33 | env: 34 | GH_REPO_TOKEN: ${{ secrets.GH_REPO_TOKEN }} 35 | PRETTYNAME : "Adafruit GFX Library" 36 | run: bash ci/doxy_gen_and_deploy.sh 37 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit GFX Library/.gitignore: -------------------------------------------------------------------------------- 1 | default.vim 2 | fontconvert/fontconvert 3 | # Our handy .gitignore for automation ease 4 | Doxyfile* 5 | doxygen_sqlite3.db 6 | html -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit GFX Library/.piopm: -------------------------------------------------------------------------------- 1 | {"type": "library", "name": "Adafruit GFX Library", "version": "1.12.0", "spec": {"owner": "adafruit", "id": 13, "name": "Adafruit GFX Library", "requirements": null, "uri": null}} -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit GFX Library/Adafruit_SPITFT_Macros.h: -------------------------------------------------------------------------------- 1 | // THIS FILE INTENTIONALLY LEFT BLANK. 2 | 3 | // Macros previously #defined here have been made into (mostly) inline 4 | // functions in the Adafruit_SPITFT class. Other libraries might still 5 | // contain code trying to #include this header file, so until everything's 6 | // updated this file still exists (but doing nothing) to avoid trouble. 7 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit GFX Library/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Adafruit GFX Library 2 | # https://github.com/adafruit/Adafruit-GFX-Library 3 | # BSD License 4 | 5 | cmake_minimum_required(VERSION 3.5) 6 | 7 | idf_component_register(SRCS "Adafruit_GFX.cpp" "Adafruit_GrayOLED.cpp" "Adafruit_SPITFT.cpp" "glcdfont.c" 8 | INCLUDE_DIRS "." 9 | REQUIRES arduino Adafruit_BusIO) 10 | 11 | project(Adafruit-GFX-Library) 12 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit GFX Library/component.mk: -------------------------------------------------------------------------------- 1 | COMPONENT_ADD_INCLUDEDIRS = . 2 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit GFX Library/fontconvert/Makefile: -------------------------------------------------------------------------------- 1 | all: fontconvert 2 | 3 | CC = gcc 4 | CFLAGS = -Wall -I/usr/local/include/freetype2 -I/usr/include/freetype2 -I/usr/include 5 | LIBS = -lfreetype 6 | 7 | fontconvert: fontconvert.c 8 | $(CC) $(CFLAGS) $< $(LIBS) -o $@ 9 | strip $@ 10 | 11 | clean: 12 | rm -f fontconvert 13 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit GFX Library/gfxfont.h: -------------------------------------------------------------------------------- 1 | // Font structures for newer Adafruit_GFX (1.1 and later). 2 | // Example fonts are included in 'Fonts' directory. 3 | // To use a font in your Arduino sketch, #include the corresponding .h 4 | // file and pass address of GFXfont struct to setFont(). Pass NULL to 5 | // revert to 'classic' fixed-space bitmap font. 6 | 7 | #ifndef _GFXFONT_H_ 8 | #define _GFXFONT_H_ 9 | 10 | /// Font data stored PER GLYPH 11 | typedef struct { 12 | uint16_t bitmapOffset; ///< Pointer into GFXfont->bitmap 13 | uint8_t width; ///< Bitmap dimensions in pixels 14 | uint8_t height; ///< Bitmap dimensions in pixels 15 | uint8_t xAdvance; ///< Distance to advance cursor (x axis) 16 | int8_t xOffset; ///< X dist from cursor pos to UL corner 17 | int8_t yOffset; ///< Y dist from cursor pos to UL corner 18 | } GFXglyph; 19 | 20 | /// Data stored for FONT AS A WHOLE 21 | typedef struct { 22 | uint8_t *bitmap; ///< Glyph bitmaps, concatenated 23 | GFXglyph *glyph; ///< Glyph array 24 | uint16_t first; ///< ASCII extents (first char) 25 | uint16_t last; ///< ASCII extents (last char) 26 | uint8_t yAdvance; ///< Newline distance (y axis) 27 | } GFXfont; 28 | 29 | #endif // _GFXFONT_H_ 30 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit GFX Library/library.properties: -------------------------------------------------------------------------------- 1 | name=Adafruit GFX Library 2 | version=1.12.0 3 | author=Adafruit 4 | maintainer=Adafruit 5 | sentence=Adafruit GFX graphics core library, this is the 'core' class that all our other graphics libraries derive from. 6 | paragraph=Install this library in addition to the display library for your hardware. 7 | category=Display 8 | url=https://github.com/adafruit/Adafruit-GFX-Library 9 | architectures=* 10 | depends=Adafruit BusIO 11 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit SSD1306/.github/workflows/githubci.yml: -------------------------------------------------------------------------------- 1 | name: Arduino Library CI 2 | 3 | on: [pull_request, push, repository_dispatch] 4 | 5 | jobs: 6 | build: 7 | runs-on: ubuntu-latest 8 | 9 | steps: 10 | - uses: actions/setup-python@v4 11 | with: 12 | python-version: '3.x' 13 | - uses: actions/checkout@v3 14 | - uses: actions/checkout@v3 15 | with: 16 | repository: adafruit/ci-arduino 17 | path: ci 18 | 19 | - name: pre-install 20 | run: bash ci/actions_install.sh 21 | 22 | - name: test platforms 23 | run: python3 ci/build_platform.py main_platforms rp2040_platforms 24 | 25 | - name: clang 26 | run: python3 ci/run-clang-format.py -e "ci/*" -e "bin/*" -r . 27 | 28 | - name: doxygen 29 | env: 30 | GH_REPO_TOKEN: ${{ secrets.GH_REPO_TOKEN }} 31 | PRETTYNAME : "Adafruit SSD1306" 32 | run: bash ci/doxy_gen_and_deploy.sh 33 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit SSD1306/.gitignore: -------------------------------------------------------------------------------- 1 | # Our handy .gitignore for automation ease 2 | Doxyfile* 3 | doxygen_sqlite3.db 4 | html 5 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit SSD1306/.piopm: -------------------------------------------------------------------------------- 1 | {"type": "library", "name": "Adafruit SSD1306", "version": "2.5.13", "spec": {"owner": "adafruit", "id": 135, "name": "Adafruit SSD1306", "requirements": null, "uri": null}} -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit SSD1306/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Adafruit Bus IO Library 2 | # https://github.com/adafruit/Adafruit_BusIO 3 | # MIT License 4 | 5 | cmake_minimum_required(VERSION 3.5) 6 | 7 | idf_component_register(SRCS "Adafruit_SSD1306.cpp" 8 | INCLUDE_DIRS "." 9 | REQUIRES arduino Adafruit-GFX-Library) 10 | 11 | project(Adafruit_SSD1306) 12 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit SSD1306/component.mk: -------------------------------------------------------------------------------- 1 | COMPONENT_ADD_INCLUDEDIRS = . 2 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit SSD1306/library.properties: -------------------------------------------------------------------------------- 1 | name=Adafruit SSD1306 2 | version=2.5.13 3 | author=Adafruit 4 | maintainer=Adafruit 5 | sentence=SSD1306 oled driver library for monochrome 128x64 and 128x32 displays 6 | paragraph=SSD1306 oled driver library for monochrome 128x64 and 128x32 displays 7 | category=Display 8 | url=https://github.com/adafruit/Adafruit_SSD1306 9 | architectures=* 10 | depends=Adafruit GFX Library 11 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit SSD1306/scripts/Makefile: -------------------------------------------------------------------------------- 1 | 2 | PY=python3 3 | 4 | define HEADER 5 | /** 6 | * This file is autogenerated, do not edit. 7 | * Run `make` from the scripts directory to produce splash.h 8 | * 9 | * Splashes will be stored in PROGMEM (flash). 10 | * If SSD1306_NO_SPLASH is defined, the splashes are omitted. 11 | */ 12 | 13 | #ifndef SSD1306_NO_SPLASH 14 | /* clang-format off */ 15 | endef 16 | 17 | define FOOTER 18 | /* clang-format on */ 19 | #endif 20 | endef 21 | 22 | export HEADER 23 | export FOOTER 24 | 25 | splash.h: make_splash.py splash1.png splash2.png 26 | echo "$$HEADER" > $@ 27 | ${PY} make_splash.py splash1.png splash1 >>$@ 28 | ${PY} make_splash.py splash2.png splash2 >>$@ 29 | echo "$$FOOTER" >> $@ 30 | 31 | clean: 32 | rm -f splash.h 33 | 34 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/Adafruit SSD1306/scripts/make_splash.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # pip install pillow to get the PIL module 3 | 4 | import sys 5 | from PIL import Image 6 | 7 | def main(fn, id): 8 | image = Image.open(fn) 9 | print("\n" 10 | "#define {id}_width {w}\n" 11 | "#define {id}_height {h}\n" 12 | "\n" 13 | "const uint8_t PROGMEM {id}_data[] = {{\n" 14 | .format(id=id, w=image.width, h=image.height), end='') 15 | for y in range(0, image.height): 16 | for x in range(0, (image.width + 7)//8 * 8): 17 | if x == 0: 18 | print(" ", end='') 19 | if x % 8 == 0: 20 | print("0b", end='') 21 | 22 | bit = '0' 23 | if x < image.width and image.getpixel((x,y)) != 0: 24 | bit = '1' 25 | print(bit, end='') 26 | 27 | if x % 8 == 7: 28 | print(",", end='') 29 | print() 30 | print("};") 31 | 32 | if __name__ == '__main__': 33 | if len(sys.argv) < 3: 34 | print("Usage: {} \n".format(sys.argv[0]), file=sys.stderr); 35 | sys.exit(1) 36 | fn = sys.argv[1] 37 | id = sys.argv[2] 38 | main(fn, id) 39 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/.piopm: -------------------------------------------------------------------------------- 1 | {"type": "library", "name": "ArduinoJson", "version": "6.21.5", "spec": {"owner": "bblanchon", "id": 64, "name": "ArduinoJson", "requirements": null, "uri": null}} -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/ArduinoJson.h: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #include "src/ArduinoJson.h" 6 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/LICENSE.txt: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | --------------------- 3 | 4 | Copyright © 2014-2023, Benoit BLANCHON 5 | 6 | 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: 7 | 8 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 9 | 10 | 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. 11 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/library.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "ArduinoJson", 3 | "keywords": "json, rest, http, web", 4 | "description": "A simple and efficient JSON library for embedded C++. ArduinoJson supports ✔ serialization, ✔ deserialization, ✔ MessagePack, ✔ fixed allocation, ✔ zero-copy, ✔ streams, ✔ filtering, and more. It is the most popular Arduino library on GitHub ❤❤❤❤❤. Check out arduinojson.org for a comprehensive documentation.", 5 | "homepage": "https://arduinojson.org/?utm_source=meta&utm_medium=library.json", 6 | "repository": { 7 | "type": "git", 8 | "url": "https://github.com/bblanchon/ArduinoJson.git" 9 | }, 10 | "version": "6.21.5", 11 | "authors": { 12 | "name": "Benoit Blanchon", 13 | "url": "https://blog.benoitblanchon.fr" 14 | }, 15 | "export": { 16 | "include": ["src", "examples", "LICENSE.txt", "ArduinoJson.h"] 17 | }, 18 | "frameworks": "*", 19 | "platforms": "*", 20 | "build": { 21 | "libArchive": false 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/library.properties: -------------------------------------------------------------------------------- 1 | name=ArduinoJson 2 | version=6.21.5 3 | author=Benoit Blanchon 4 | maintainer=Benoit Blanchon 5 | sentence=A simple and efficient JSON library for embedded C++. 6 | paragraph=ArduinoJson supports ✔ serialization, ✔ deserialization, ✔ MessagePack, ✔ fixed allocation, ✔ zero-copy, ✔ streams, ✔ filtering, and more. It is the most popular Arduino library on GitHub ❤❤❤❤❤. Check out arduinojson.org for a comprehensive documentation. 7 | category=Data Processing 8 | url=https://arduinojson.org/?utm_source=meta&utm_medium=library.properties 9 | architectures=* 10 | repository=https://github.com/bblanchon/ArduinoJson.git 11 | license=MIT 12 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson.h: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #ifdef __cplusplus 8 | 9 | # include "ArduinoJson.hpp" 10 | 11 | using namespace ArduinoJson; 12 | 13 | #else 14 | 15 | #error ArduinoJson requires a C++ compiler, please change file extension to .cc or .cpp 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Array/JsonArrayImpl.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE 11 | 12 | inline JsonObject JsonArray::createNestedObject() const { 13 | return add().to(); 14 | } 15 | 16 | ARDUINOJSON_END_PUBLIC_NAMESPACE 17 | 18 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 19 | 20 | template 21 | inline JsonArray VariantRefBase::createNestedArray() const { 22 | return add().template to(); 23 | } 24 | 25 | template 26 | inline JsonObject VariantRefBase::createNestedObject() const { 27 | return add().template to(); 28 | } 29 | 30 | template 31 | inline ElementProxy VariantRefBase::operator[]( 32 | size_t index) const { 33 | return ElementProxy(derived(), index); 34 | } 35 | 36 | ARDUINOJSON_END_PRIVATE_NAMESPACE 37 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Deserialization/DeserializationOptions.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 11 | 12 | template 13 | struct DeserializationOptions { 14 | TFilter filter; 15 | DeserializationOption::NestingLimit nestingLimit; 16 | }; 17 | 18 | template 19 | inline DeserializationOptions makeDeserializationOptions( 20 | TFilter filter, DeserializationOption::NestingLimit nestingLimit = {}) { 21 | return {filter, nestingLimit}; 22 | } 23 | 24 | template 25 | inline DeserializationOptions makeDeserializationOptions( 26 | DeserializationOption::NestingLimit nestingLimit, TFilter filter) { 27 | return {filter, nestingLimit}; 28 | } 29 | 30 | inline DeserializationOptions makeDeserializationOptions( 31 | DeserializationOption::NestingLimit nestingLimit = {}) { 32 | return {{}, nestingLimit}; 33 | } 34 | 35 | ARDUINOJSON_END_PRIVATE_NAMESPACE 36 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Deserialization/NestingLimit.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE 11 | 12 | namespace DeserializationOption { 13 | class NestingLimit { 14 | public: 15 | NestingLimit() : value_(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {} 16 | explicit NestingLimit(uint8_t n) : value_(n) {} 17 | 18 | NestingLimit decrement() const { 19 | ARDUINOJSON_ASSERT(value_ > 0); 20 | return NestingLimit(static_cast(value_ - 1)); 21 | } 22 | 23 | bool reached() const { 24 | return value_ == 0; 25 | } 26 | 27 | private: 28 | uint8_t value_; 29 | }; 30 | } // namespace DeserializationOption 31 | 32 | ARDUINOJSON_END_PUBLIC_NAMESPACE 33 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | struct Reader::value>::type> { 14 | public: 15 | explicit Reader(Stream& stream) : stream_(&stream) {} 16 | 17 | int read() { 18 | // don't use stream_.read() as it ignores the timeout 19 | char c; 20 | return stream_->readBytes(&c, 1) ? static_cast(c) : -1; 21 | } 22 | 23 | size_t readBytes(char* buffer, size_t length) { 24 | return stream_->readBytes(buffer, length); 25 | } 26 | 27 | private: 28 | Stream* stream_; 29 | }; 30 | 31 | ARDUINOJSON_END_PRIVATE_NAMESPACE 32 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | struct Reader::value>::type> 14 | : BoundedReader { 15 | explicit Reader(const ::String& s) 16 | : BoundedReader(s.c_str(), s.length()) {} 17 | }; 18 | 19 | ARDUINOJSON_END_PRIVATE_NAMESPACE 20 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | struct Reader::value>::type> { 14 | public: 15 | explicit Reader(std::istream& stream) : stream_(&stream) {} 16 | 17 | int read() { 18 | return stream_->get(); 19 | } 20 | 21 | size_t readBytes(char* buffer, size_t length) { 22 | stream_->read(buffer, static_cast(length)); 23 | return static_cast(stream_->gcount()); 24 | } 25 | 26 | private: 27 | std::istream* stream_; 28 | }; 29 | 30 | ARDUINOJSON_END_PRIVATE_NAMESPACE 31 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Deserialization/Readers/VariantReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 11 | 12 | template 13 | struct Reader::value>::type> 14 | : Reader { 15 | explicit Reader(const TVariant& x) 16 | : Reader(x.template as()) {} 17 | }; 18 | 19 | ARDUINOJSON_END_PRIVATE_NAMESPACE 20 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Document/DynamicJsonDocument.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // malloc, free 10 | 11 | ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE 12 | 13 | // The allocator of DynamicJsonDocument. 14 | struct DefaultAllocator { 15 | void* allocate(size_t size) { 16 | return malloc(size); 17 | } 18 | 19 | void deallocate(void* ptr) { 20 | free(ptr); 21 | } 22 | 23 | void* reallocate(void* ptr, size_t new_size) { 24 | return realloc(ptr, new_size); 25 | } 26 | }; 27 | 28 | // A JsonDocument with a memory pool in the heap. 29 | // https://arduinojson.org/v6/api/dynamicjsondocument/ 30 | typedef BasicJsonDocument DynamicJsonDocument; 31 | 32 | ARDUINOJSON_END_PUBLIC_NAMESPACE 33 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Json/EscapeSequence.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | class EscapeSequence { 12 | public: 13 | // Optimized for code size on a 8-bit AVR 14 | static char escapeChar(char c) { 15 | const char* p = escapeTable(true); 16 | while (p[0] && p[1] != c) { 17 | p += 2; 18 | } 19 | return p[0]; 20 | } 21 | 22 | // Optimized for code size on a 8-bit AVR 23 | static char unescapeChar(char c) { 24 | const char* p = escapeTable(false); 25 | for (;;) { 26 | if (p[0] == '\0') 27 | return 0; 28 | if (p[0] == c) 29 | return p[1]; 30 | p += 2; 31 | } 32 | } 33 | 34 | private: 35 | static const char* escapeTable(bool excludeSolidus) { 36 | return &"//\"\"\\\\b\bf\fn\nr\rt\t"[excludeSolidus ? 2 : 0]; 37 | } 38 | }; 39 | 40 | ARDUINOJSON_END_PRIVATE_NAMESPACE 41 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/MsgPack/endianess.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | #if ARDUINOJSON_LITTLE_ENDIAN 12 | inline void swapBytes(uint8_t& a, uint8_t& b) { 13 | uint8_t t(a); 14 | a = b; 15 | b = t; 16 | } 17 | 18 | inline void fixEndianess(uint8_t* p, integral_constant) { 19 | swapBytes(p[0], p[7]); 20 | swapBytes(p[1], p[6]); 21 | swapBytes(p[2], p[5]); 22 | swapBytes(p[3], p[4]); 23 | } 24 | 25 | inline void fixEndianess(uint8_t* p, integral_constant) { 26 | swapBytes(p[0], p[3]); 27 | swapBytes(p[1], p[2]); 28 | } 29 | 30 | inline void fixEndianess(uint8_t* p, integral_constant) { 31 | swapBytes(p[0], p[1]); 32 | } 33 | 34 | inline void fixEndianess(uint8_t*, integral_constant) {} 35 | 36 | template 37 | inline void fixEndianess(T& value) { 38 | fixEndianess(reinterpret_cast(&value), 39 | integral_constant()); 40 | } 41 | #else 42 | template 43 | inline void fixEndianess(T&) {} 44 | #endif 45 | 46 | ARDUINOJSON_END_PRIVATE_NAMESPACE 47 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/MsgPack/ieee754.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | inline void doubleToFloat(const uint8_t d[8], uint8_t f[4]) { 12 | f[0] = uint8_t((d[0] & 0xC0) | (d[0] << 3 & 0x3f) | (d[1] >> 5)); 13 | f[1] = uint8_t((d[1] << 3) | (d[2] >> 5)); 14 | f[2] = uint8_t((d[2] << 3) | (d[3] >> 5)); 15 | f[3] = uint8_t((d[3] << 3) | (d[4] >> 5)); 16 | } 17 | 18 | ARDUINOJSON_END_PRIVATE_NAMESPACE 19 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Numbers/JsonFloat.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE 11 | 12 | #if ARDUINOJSON_USE_DOUBLE 13 | typedef double JsonFloat; 14 | #else 15 | typedef float JsonFloat; 16 | #endif 17 | 18 | ARDUINOJSON_END_PUBLIC_NAMESPACE 19 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Numbers/JsonInteger.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | #include // int64_t 11 | 12 | ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE 13 | 14 | #if ARDUINOJSON_USE_LONG_LONG 15 | typedef int64_t JsonInteger; 16 | typedef uint64_t JsonUInt; 17 | #else 18 | typedef long JsonInteger; 19 | typedef unsigned long JsonUInt; 20 | #endif 21 | 22 | ARDUINOJSON_END_PUBLIC_NAMESPACE 23 | 24 | #define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T) \ 25 | static_assert(sizeof(T) <= sizeof(ArduinoJson::JsonInteger), \ 26 | "To use 64-bit integers with ArduinoJson, you must set " \ 27 | "ARDUINOJSON_USE_LONG_LONG to 1. See " \ 28 | "https://arduinojson.org/v6/api/config/use_long_long/"); 29 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/alias_cast.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include // for size_t 9 | 10 | #include 11 | #include "math.hpp" 12 | 13 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 14 | 15 | template 16 | struct alias_cast_t { 17 | union { 18 | F raw; 19 | T data; 20 | }; 21 | }; 22 | 23 | template 24 | T alias_cast(F raw_data) { 25 | alias_cast_t ac; 26 | ac.raw = raw_data; 27 | return ac.data; 28 | } 29 | 30 | ARDUINOJSON_END_PRIVATE_NAMESPACE 31 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/assert.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #if ARDUINOJSON_DEBUG 10 | # include 11 | # define ARDUINOJSON_ASSERT(X) assert(X) 12 | #else 13 | # define ARDUINOJSON_ASSERT(X) ((void)0) 14 | #endif 15 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/attributes.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #ifdef _MSC_VER // Visual Studio 8 | 9 | # define FORCE_INLINE // __forceinline causes C4714 when returning std::string 10 | # define NO_INLINE __declspec(noinline) 11 | 12 | #elif defined(__GNUC__) // GCC or Clang 13 | 14 | # define FORCE_INLINE __attribute__((always_inline)) 15 | # define NO_INLINE __attribute__((noinline)) 16 | 17 | #else // Other compilers 18 | 19 | # define FORCE_INLINE 20 | # define NO_INLINE 21 | 22 | #endif 23 | 24 | #if defined(__has_attribute) 25 | # if __has_attribute(no_sanitize) 26 | # define ARDUINOJSON_NO_SANITIZE(check) __attribute__((no_sanitize(check))) 27 | # else 28 | # define ARDUINOJSON_NO_SANITIZE(check) 29 | # endif 30 | #else 31 | # define ARDUINOJSON_NO_SANITIZE(check) 32 | #endif 33 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/ctype.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | #ifndef isdigit 12 | inline bool isdigit(char c) { 13 | return '0' <= c && c <= '9'; 14 | } 15 | #endif 16 | 17 | inline bool issign(char c) { 18 | return '-' == c || c == '+'; 19 | } 20 | 21 | ARDUINOJSON_END_PRIVATE_NAMESPACE 22 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/integer.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include // int8_t, int16_t 8 | 9 | #include 10 | 11 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 12 | 13 | template 14 | struct int_t; 15 | 16 | template <> 17 | struct int_t<8> { 18 | typedef int8_t type; 19 | }; 20 | 21 | template <> 22 | struct int_t<16> { 23 | typedef int16_t type; 24 | }; 25 | 26 | template <> 27 | struct int_t<32> { 28 | typedef int32_t type; 29 | }; 30 | 31 | ARDUINOJSON_END_PRIVATE_NAMESPACE 32 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/limits.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "type_traits.hpp" 8 | 9 | #ifdef _MSC_VER 10 | # pragma warning(push) 11 | # pragma warning(disable : 4310) 12 | #endif 13 | 14 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 15 | 16 | // Differs from standard because we can't use the symbols "min" and "max" 17 | template 18 | struct numeric_limits; 19 | 20 | template 21 | struct numeric_limits::value>::type> { 22 | static T lowest() { 23 | return 0; 24 | } 25 | static T highest() { 26 | return T(-1); 27 | } 28 | }; 29 | 30 | template 31 | struct numeric_limits< 32 | T, typename enable_if::value && is_signed::value>::type> { 33 | static T lowest() { 34 | return T(T(1) << (sizeof(T) * 8 - 1)); 35 | } 36 | static T highest() { 37 | return T(~lowest()); 38 | } 39 | }; 40 | 41 | ARDUINOJSON_END_PRIVATE_NAMESPACE 42 | 43 | #ifdef _MSC_VER 44 | # pragma warning(pop) 45 | #endif 46 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/math.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | // Some libraries #define isnan() and isinf() so we need to check before 12 | // using this name 13 | 14 | #ifndef isnan 15 | template 16 | bool isnan(T x) { 17 | return x != x; 18 | } 19 | #endif 20 | 21 | #ifndef isinf 22 | template 23 | bool isinf(T x) { 24 | return x != 0.0 && x * 2 == x; 25 | } 26 | #endif 27 | ARDUINOJSON_END_PRIVATE_NAMESPACE 28 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/mpl/max.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // for size_t 10 | 11 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 12 | 13 | // A meta-function that returns the highest value 14 | template Y)> 15 | struct Max {}; 16 | 17 | template 18 | struct Max { 19 | static const size_t value = X; 20 | }; 21 | 22 | template 23 | struct Max { 24 | static const size_t value = Y; 25 | }; 26 | 27 | ARDUINOJSON_END_PRIVATE_NAMESPACE 28 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/preprocessor.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #define ARDUINOJSON_CONCAT_(A, B) A##B 8 | #define ARDUINOJSON_CONCAT2(A, B) ARDUINOJSON_CONCAT_(A, B) 9 | #define ARDUINOJSON_CONCAT4(A, B, C, D) \ 10 | ARDUINOJSON_CONCAT2(ARDUINOJSON_CONCAT2(A, B), ARDUINOJSON_CONCAT2(C, D)) 11 | 12 | #define ARDUINOJSON_BIN2ALPHA_0000() A 13 | #define ARDUINOJSON_BIN2ALPHA_0001() B 14 | #define ARDUINOJSON_BIN2ALPHA_0010() C 15 | #define ARDUINOJSON_BIN2ALPHA_0011() D 16 | #define ARDUINOJSON_BIN2ALPHA_0100() E 17 | #define ARDUINOJSON_BIN2ALPHA_0101() F 18 | #define ARDUINOJSON_BIN2ALPHA_0110() G 19 | #define ARDUINOJSON_BIN2ALPHA_0111() H 20 | #define ARDUINOJSON_BIN2ALPHA_1000() I 21 | #define ARDUINOJSON_BIN2ALPHA_1001() J 22 | #define ARDUINOJSON_BIN2ALPHA_1010() K 23 | #define ARDUINOJSON_BIN2ALPHA_1011() L 24 | #define ARDUINOJSON_BIN2ALPHA_1100() M 25 | #define ARDUINOJSON_BIN2ALPHA_1101() N 26 | #define ARDUINOJSON_BIN2ALPHA_1110() O 27 | #define ARDUINOJSON_BIN2ALPHA_1111() P 28 | #define ARDUINOJSON_BIN2ALPHA_(A, B, C, D) ARDUINOJSON_BIN2ALPHA_##A##B##C##D() 29 | #define ARDUINOJSON_BIN2ALPHA(A, B, C, D) ARDUINOJSON_BIN2ALPHA_(A, B, C, D) 30 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "type_traits/conditional.hpp" 8 | #include "type_traits/enable_if.hpp" 9 | #include "type_traits/integral_constant.hpp" 10 | #include "type_traits/is_array.hpp" 11 | #include "type_traits/is_base_of.hpp" 12 | #include "type_traits/is_class.hpp" 13 | #include "type_traits/is_const.hpp" 14 | #include "type_traits/is_convertible.hpp" 15 | #include "type_traits/is_enum.hpp" 16 | #include "type_traits/is_floating_point.hpp" 17 | #include "type_traits/is_integral.hpp" 18 | #include "type_traits/is_pointer.hpp" 19 | #include "type_traits/is_same.hpp" 20 | #include "type_traits/is_signed.hpp" 21 | #include "type_traits/is_unsigned.hpp" 22 | #include "type_traits/make_unsigned.hpp" 23 | #include "type_traits/make_void.hpp" 24 | #include "type_traits/remove_const.hpp" 25 | #include "type_traits/remove_reference.hpp" 26 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/conditional.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | struct conditional { 13 | typedef TrueType type; 14 | }; 15 | 16 | template 17 | struct conditional { 18 | typedef FalseType type; 19 | }; 20 | 21 | ARDUINOJSON_END_PRIVATE_NAMESPACE 22 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/declval.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | T&& declval(); 13 | 14 | ARDUINOJSON_END_PRIVATE_NAMESPACE 15 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/enable_if.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | // A meta-function that return the type T if Condition is true. 12 | template 13 | struct enable_if {}; 14 | 15 | template 16 | struct enable_if { 17 | typedef T type; 18 | }; 19 | 20 | ARDUINOJSON_END_PRIVATE_NAMESPACE 21 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/integral_constant.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | struct integral_constant { 13 | static const T value = v; 14 | }; 15 | 16 | typedef integral_constant true_type; 17 | typedef integral_constant false_type; 18 | 19 | ARDUINOJSON_END_PRIVATE_NAMESPACE 20 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_array.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // size_t 10 | 11 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 12 | 13 | template 14 | struct is_array : false_type {}; 15 | 16 | template 17 | struct is_array : true_type {}; 18 | 19 | template 20 | struct is_array : true_type {}; 21 | 22 | ARDUINOJSON_END_PRIVATE_NAMESPACE 23 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_base_of.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include "remove_reference.hpp" 10 | 11 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 12 | 13 | // A meta-function that returns true if Derived inherits from TBase is an 14 | // integral type. 15 | template 16 | class is_base_of { 17 | protected: // <- to avoid GCC's "all member functions in class are private" 18 | static int probe(const TBase*); 19 | static char probe(...); 20 | 21 | public: 22 | static const bool value = 23 | sizeof(probe(reinterpret_cast::type*>( 24 | 0))) == sizeof(int); 25 | }; 26 | 27 | ARDUINOJSON_END_PRIVATE_NAMESPACE 28 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_class.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "declval.hpp" 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | struct is_class { 13 | protected: // <- to avoid GCC's "all member functions in class are private" 14 | template 15 | static int probe(void (U::*)(void)); 16 | template 17 | static char probe(...); 18 | 19 | public: 20 | static const bool value = sizeof(probe(0)) == sizeof(int); 21 | }; 22 | 23 | ARDUINOJSON_END_PRIVATE_NAMESPACE 24 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_const.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | // A meta-function that return the type T without the const modifier 12 | template 13 | struct is_const : false_type {}; 14 | 15 | template 16 | struct is_const : true_type {}; 17 | 18 | ARDUINOJSON_END_PRIVATE_NAMESPACE 19 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "declval.hpp" 8 | 9 | #ifdef _MSC_VER 10 | # pragma warning(push) 11 | // conversion from 'T' to 'To', possible loss of data 12 | # pragma warning(disable : 4244) 13 | #endif 14 | 15 | // clang-format off 16 | #ifdef __ICCARM__ 17 | // Suppress IAR Compiler Warning[Pa093]: implicit conversion from floating point to integer 18 | #pragma diag_suppress=Pa093 19 | #endif 20 | // clang-format on 21 | 22 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 23 | 24 | template 25 | struct is_convertible { 26 | protected: // <- to avoid GCC's "all member functions in class are private" 27 | static int probe(To); 28 | static char probe(...); 29 | 30 | static From& from_; 31 | 32 | public: 33 | static const bool value = sizeof(probe(from_)) == sizeof(int); 34 | }; 35 | 36 | ARDUINOJSON_END_PRIVATE_NAMESPACE 37 | 38 | #ifdef _MSC_VER 39 | # pragma warning(pop) 40 | #endif 41 | 42 | // clang-format off 43 | #ifdef __ICCARM__ 44 | #pragma diag_default=Pa093 45 | #endif 46 | // clang-format on 47 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_enum.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "is_class.hpp" 8 | #include "is_convertible.hpp" 9 | #include "is_floating_point.hpp" 10 | #include "is_integral.hpp" 11 | #include "is_same.hpp" 12 | 13 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 14 | 15 | template 16 | struct is_enum { 17 | static const bool value = is_convertible::value && 18 | !is_class::value && !is_integral::value && 19 | !is_floating_point::value; 20 | }; 21 | 22 | ARDUINOJSON_END_PRIVATE_NAMESPACE 23 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_floating_point.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | #include "is_same.hpp" 9 | #include "remove_cv.hpp" 10 | 11 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 12 | 13 | template 14 | struct is_floating_point 15 | : integral_constant< 16 | bool, // 17 | is_same::type>::value || 18 | is_same::type>::value> {}; 19 | 20 | ARDUINOJSON_END_PRIVATE_NAMESPACE 21 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_pointer.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | struct is_pointer : false_type {}; 13 | 14 | template 15 | struct is_pointer : true_type {}; 16 | 17 | ARDUINOJSON_END_PRIVATE_NAMESPACE 18 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_same.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | // A meta-function that returns true if types T and U are the same. 12 | template 13 | struct is_same : false_type {}; 14 | 15 | template 16 | struct is_same : true_type {}; 17 | 18 | ARDUINOJSON_END_PRIVATE_NAMESPACE 19 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_signed.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | #include "is_same.hpp" 9 | #include "remove_cv.hpp" 10 | 11 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 12 | 13 | // clang-format off 14 | template 15 | struct is_signed : integral_constant::type, char>::value || 17 | is_same::type, signed char>::value || 18 | is_same::type, signed short>::value || 19 | is_same::type, signed int>::value || 20 | is_same::type, signed long>::value || 21 | is_same::type, signed long long>::value || 22 | is_same::type, float>::value || 23 | is_same::type, double>::value> {}; 24 | // clang-format on 25 | 26 | ARDUINOJSON_END_PRIVATE_NAMESPACE 27 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_unsigned.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | #include "is_same.hpp" 9 | #include "remove_cv.hpp" 10 | 11 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 12 | 13 | // clang-format off 14 | template 15 | struct is_unsigned : integral_constant::type, unsigned char>::value || 17 | is_same::type, unsigned short>::value || 18 | is_same::type, unsigned int>::value || 19 | is_same::type, unsigned long>::value || 20 | is_same::type, unsigned long long>::value || 21 | is_same::type, bool>::value> {}; 22 | // clang-format on 23 | 24 | ARDUINOJSON_END_PRIVATE_NAMESPACE 25 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/make_void.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 8 | 9 | template 10 | struct make_void { 11 | typedef void type; 12 | }; 13 | 14 | ARDUINOJSON_END_PRIVATE_NAMESPACE 15 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/remove_const.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | // A meta-function that return the type T without the const modifier 12 | template 13 | struct remove_const { 14 | typedef T type; 15 | }; 16 | template 17 | struct remove_const { 18 | typedef T type; 19 | }; 20 | 21 | ARDUINOJSON_END_PRIVATE_NAMESPACE 22 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/remove_cv.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | struct remove_cv { 13 | typedef T type; 14 | }; 15 | template 16 | struct remove_cv { 17 | typedef T type; 18 | }; 19 | template 20 | struct remove_cv { 21 | typedef T type; 22 | }; 23 | template 24 | struct remove_cv { 25 | typedef T type; 26 | }; 27 | 28 | ARDUINOJSON_END_PRIVATE_NAMESPACE 29 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/remove_reference.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | // A meta-function that return the type T without the reference modifier. 12 | template 13 | struct remove_reference { 14 | typedef T type; 15 | }; 16 | template 17 | struct remove_reference { 18 | typedef T type; 19 | }; 20 | 21 | ARDUINOJSON_END_PRIVATE_NAMESPACE 22 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/type_identity.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | struct type_identity { 13 | typedef T type; 14 | }; 15 | 16 | ARDUINOJSON_END_PRIVATE_NAMESPACE 17 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Polyfills/utility.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "type_traits.hpp" 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | T&& forward(typename remove_reference::type& t) noexcept { 13 | return static_cast(t); 14 | } 15 | 16 | ARDUINOJSON_END_PRIVATE_NAMESPACE 17 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Serialization/CountingDecorator.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | class CountingDecorator { 13 | public: 14 | explicit CountingDecorator(TWriter& writer) : writer_(writer), count_(0) {} 15 | 16 | void write(uint8_t c) { 17 | count_ += writer_.write(c); 18 | } 19 | 20 | void write(const uint8_t* s, size_t n) { 21 | count_ += writer_.write(s, n); 22 | } 23 | 24 | size_t count() const { 25 | return count_; 26 | } 27 | 28 | private: 29 | TWriter writer_; 30 | size_t count_; 31 | }; 32 | 33 | ARDUINOJSON_END_PRIVATE_NAMESPACE 34 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template <> 12 | class Writer<::String, void> { 13 | static const size_t bufferCapacity = ARDUINOJSON_STRING_BUFFER_SIZE; 14 | 15 | public: 16 | explicit Writer(::String& str) : destination_(&str) { 17 | size_ = 0; 18 | } 19 | 20 | ~Writer() { 21 | flush(); 22 | } 23 | 24 | size_t write(uint8_t c) { 25 | if (size_ + 1 >= bufferCapacity) 26 | if (flush() != 0) 27 | return 0; 28 | buffer_[size_++] = static_cast(c); 29 | return 1; 30 | } 31 | 32 | size_t write(const uint8_t* s, size_t n) { 33 | for (size_t i = 0; i < n; i++) { 34 | write(s[i]); 35 | } 36 | return n; 37 | } 38 | 39 | size_t flush() { 40 | ARDUINOJSON_ASSERT(size_ < bufferCapacity); 41 | buffer_[size_] = 0; 42 | if (destination_->concat(buffer_)) 43 | size_ = 0; 44 | return size_; 45 | } 46 | 47 | private: 48 | ::String* destination_; 49 | char buffer_[bufferCapacity]; 50 | size_t size_; 51 | }; 52 | 53 | ARDUINOJSON_END_PRIVATE_NAMESPACE 54 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Serialization/Writers/DummyWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | class DummyWriter { 12 | public: 13 | size_t write(uint8_t) { 14 | return 1; 15 | } 16 | 17 | size_t write(const uint8_t*, size_t n) { 18 | return n; 19 | } 20 | }; 21 | 22 | ARDUINOJSON_END_PRIVATE_NAMESPACE 23 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Serialization/Writers/PrintWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | class Writer< 13 | TDestination, 14 | typename enable_if::value>::type> { 15 | public: 16 | explicit Writer(::Print& print) : print_(&print) {} 17 | 18 | size_t write(uint8_t c) { 19 | return print_->write(c); 20 | } 21 | 22 | size_t write(const uint8_t* s, size_t n) { 23 | return print_->write(s, n); 24 | } 25 | 26 | private: 27 | ::Print* print_; 28 | }; 29 | 30 | ARDUINOJSON_END_PRIVATE_NAMESPACE 31 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Serialization/Writers/StaticStringWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | class StaticStringWriter { 12 | public: 13 | StaticStringWriter(char* buf, size_t size) : end(buf + size), p(buf) {} 14 | 15 | size_t write(uint8_t c) { 16 | if (p >= end) 17 | return 0; 18 | *p++ = static_cast(c); 19 | return 1; 20 | } 21 | 22 | size_t write(const uint8_t* s, size_t n) { 23 | char* begin = p; 24 | while (p < end && n > 0) { 25 | *p++ = static_cast(*s++); 26 | n--; 27 | } 28 | return size_t(p - begin); 29 | } 30 | 31 | private: 32 | char* end; 33 | char* p; 34 | }; 35 | 36 | ARDUINOJSON_END_PRIVATE_NAMESPACE 37 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 10 | 11 | template 12 | class Writer< 13 | TDestination, 14 | typename enable_if::value>::type> { 15 | public: 16 | explicit Writer(std::ostream& os) : os_(&os) {} 17 | 18 | size_t write(uint8_t c) { 19 | os_->put(static_cast(c)); 20 | return 1; 21 | } 22 | 23 | size_t write(const uint8_t* s, size_t n) { 24 | os_->write(reinterpret_cast(s), 25 | static_cast(n)); 26 | return n; 27 | } 28 | 29 | private: 30 | std::ostream* os_; 31 | }; 32 | 33 | ARDUINOJSON_END_PRIVATE_NAMESPACE 34 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Serialization/Writers/StdStringWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 11 | 12 | template 13 | using void_t = void; 14 | 15 | template 16 | struct is_std_string : false_type {}; 17 | 18 | template 19 | struct is_std_string< 20 | T, void_t> 21 | : true_type {}; 22 | 23 | template 24 | class Writer::value>::type> { 26 | public: 27 | Writer(TDestination& str) : str_(&str) {} 28 | 29 | size_t write(uint8_t c) { 30 | str_->push_back(static_cast(c)); 31 | return 1; 32 | } 33 | 34 | size_t write(const uint8_t* s, size_t n) { 35 | str_->append(reinterpret_cast(s), n); 36 | return n; 37 | } 38 | 39 | private: 40 | TDestination* str_; 41 | }; 42 | 43 | ARDUINOJSON_END_PRIVATE_NAMESPACE 44 | -------------------------------------------------------------------------------- /.pio/libdeps/esp32-c3-devkitm-1/ArduinoJson/src/ArduinoJson/Serialization/measure.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright © 2014-2023, Benoit BLANCHON 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE 11 | 12 | template