diff options
| author | krolyxon <me@krolyxon.com> | 2026-06-08 23:10:46 +0530 |
|---|---|---|
| committer | krolyxon <me@krolyxon.com> | 2026-06-08 23:10:46 +0530 |
| commit | 3120783000d0025b183b0397acaa8b769499eb38 (patch) | |
| tree | 1c4f93be213f1b1d48f59e554562d847b4e7c25e /.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO | |
Initial gh-pages firmware hosting
Diffstat (limited to '.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO')
31 files changed, 2926 insertions, 0 deletions
diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.clang-format b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.clang-format new file mode 100644 index 0000000..c6cdd16 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.clang-format @@ -0,0 +1,243 @@ +Language: Cpp +# BasedOnStyle: LLVM +AccessModifierOffset: -2 +AlignAfterOpenBracket: Align +AlignArrayOfStructures: None +AlignConsecutiveAssignments: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + AlignFunctionPointers: false + PadOperators: true +AlignConsecutiveBitFields: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + AlignFunctionPointers: false + PadOperators: false +AlignConsecutiveDeclarations: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + AlignFunctionPointers: false + PadOperators: false +AlignConsecutiveMacros: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + AlignFunctionPointers: false + PadOperators: false +AlignConsecutiveShortCaseStatements: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCaseColons: false +AlignEscapedNewlines: Right +AlignOperands: Align +AlignTrailingComments: + Kind: Always + OverEmptyLines: 0 +AllowAllArgumentsOnNextLine: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowBreakBeforeNoexceptSpecifier: Never +AllowShortBlocksOnASingleLine: Never +AllowShortCaseLabelsOnASingleLine: false +AllowShortCompoundRequirementOnASingleLine: true +AllowShortEnumsOnASingleLine: true +AllowShortFunctionsOnASingleLine: All +AllowShortIfStatementsOnASingleLine: Never +AllowShortLambdasOnASingleLine: All +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: MultiLine +AttributeMacros: + - __capability +BinPackArguments: true +BinPackParameters: true +BitFieldColonSpacing: Both +BraceWrapping: + AfterCaseLabel: false + AfterClass: false + AfterControlStatement: Never + AfterEnum: false + AfterExternBlock: false + AfterFunction: false + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + BeforeCatch: false + BeforeElse: false + BeforeLambdaBody: false + BeforeWhile: false + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true +BreakAdjacentStringLiterals: true +BreakAfterAttributes: Leave +BreakAfterJavaFieldAnnotations: false +BreakArrays: true +BreakBeforeBinaryOperators: None +BreakBeforeConceptDeclarations: Always +BreakBeforeBraces: Attach +BreakBeforeInlineASMColon: OnlyMultiline +BreakBeforeTernaryOperators: true +BreakConstructorInitializers: BeforeColon +BreakInheritanceList: BeforeColon +BreakStringLiterals: true +ColumnLimit: 80 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: false +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DerivePointerAlignment: false +DisableFormat: false +EmptyLineAfterAccessModifier: Never +EmptyLineBeforeAccessModifier: LogicalBlock +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: true +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IfMacros: + - KJ_IF_MAYBE +IncludeBlocks: Preserve +IncludeCategories: + - Regex: '^"(llvm|llvm-c|clang|clang-c)/' + Priority: 2 + SortPriority: 0 + CaseSensitive: false + - Regex: '^(<|"(gtest|gmock|isl|json)/)' + Priority: 3 + SortPriority: 0 + CaseSensitive: false + - Regex: '.*' + Priority: 1 + SortPriority: 0 + CaseSensitive: false +IncludeIsMainRegex: '(Test)?$' +IncludeIsMainSourceRegex: '' +IndentAccessModifiers: false +IndentCaseBlocks: false +IndentCaseLabels: false +IndentExternBlock: AfterExternBlock +IndentGotoLabels: true +IndentPPDirectives: None +IndentRequiresClause: true +IndentWidth: 2 +IndentWrappedFunctionNames: false +InsertBraces: false +InsertNewlineAtEOF: false +InsertTrailingCommas: None +IntegerLiteralSeparator: + Binary: 0 + BinaryMinDigits: 0 + Decimal: 0 + DecimalMinDigits: 0 + Hex: 0 + HexMinDigits: 0 +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: true +KeepEmptyLinesAtEOF: false +LambdaBodyIndentation: Signature +LineEnding: DeriveLF +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBinPackProtocolList: Auto +ObjCBlockIndentWidth: 2 +ObjCBreakBeforeNestedBlockParam: true +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: true +PackConstructorInitializers: BinPack +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 19 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakOpenParenthesis: 0 +PenaltyBreakScopeResolution: 500 +PenaltyBreakString: 1000 +PenaltyBreakTemplateDeclaration: 10 +PenaltyExcessCharacter: 1000000 +PenaltyIndentedWhitespace: 0 +PenaltyReturnTypeOnItsOwnLine: 60 +PointerAlignment: Right +PPIndentWidth: -1 +QualifierAlignment: Leave +ReferenceAlignment: Pointer +ReflowComments: true +RemoveBracesLLVM: false +RemoveParentheses: Leave +RemoveSemicolon: false +RequiresClausePosition: OwnLine +RequiresExpressionIndentation: OuterScope +SeparateDefinitionBlocks: Leave +ShortNamespaceLines: 1 +SkipMacroDefinitionBody: false +SortIncludes: CaseSensitive +SortJavaStaticImport: Before +SortUsingDeclarations: LexicographicNumeric +SpaceAfterCStyleCast: false +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: true +SpaceAroundPointerQualifiers: Default +SpaceBeforeAssignmentOperators: true +SpaceBeforeCaseColon: false +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeJsonColon: false +SpaceBeforeParens: ControlStatements +SpaceBeforeParensOptions: + AfterControlStatements: true + AfterForeachMacros: true + AfterFunctionDefinitionName: false + AfterFunctionDeclarationName: false + AfterIfMacros: true + AfterOverloadedOperator: false + AfterPlacementOperator: true + AfterRequiresInClause: false + AfterRequiresInExpression: false + BeforeNonEmptyParentheses: false +SpaceBeforeRangeBasedForLoopColon: true +SpaceBeforeSquareBrackets: false +SpaceInEmptyBlock: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: Never +SpacesInContainerLiterals: true +SpacesInLineCommentPrefix: + Minimum: 1 + Maximum: -1 +SpacesInParens: Never +SpacesInParensOptions: + InCStyleCasts: false + InConditionalStatements: false + InEmptyParentheses: false + Other: false +SpacesInSquareBrackets: false +Standard: Latest +StatementAttributeLikeMacros: + - Q_EMIT +StatementMacros: + - Q_UNUSED + - QT_REQUIRE_VERSION +TabWidth: 8 +UseTab: Never +VerilogBreakBetweenInstancePorts: true +WhitespaceSensitiveMacros: + - BOOST_PP_STRINGIZE + - CF_SWIFT_NAME + - NS_SWIFT_NAME + - PP_STRINGIZE + - STRINGIZE
\ No newline at end of file diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.github/ISSUE_TEMPLATE.md b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.github/ISSUE_TEMPLATE.md new file mode 100644 index 0000000..f0e2614 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.github/ISSUE_TEMPLATE.md @@ -0,0 +1,46 @@ +Thank you for opening an issue on an Adafruit Arduino library repository. To +improve the speed of resolution please review the following guidelines and +common troubleshooting steps below before creating the issue: + +- **Do not use GitHub issues for troubleshooting projects and issues.** Instead use + the forums at http://forums.adafruit.com to ask questions and troubleshoot why + something isn't working as expected. In many cases the problem is a common issue + that you will more quickly receive help from the forum community. GitHub issues + are meant for known defects in the code. If you don't know if there is a defect + in the code then start with troubleshooting on the forum first. + +- **If following a tutorial or guide be sure you didn't miss a step.** Carefully + check all of the steps and commands to run have been followed. Consult the + forum if you're unsure or have questions about steps in a guide/tutorial. + +- **For Arduino projects check these very common issues to ensure they don't apply**: + + - For uploading sketches or communicating with the board make sure you're using + a **USB data cable** and **not** a **USB charge-only cable**. It is sometimes + very hard to tell the difference between a data and charge cable! Try using the + cable with other devices or swapping to another cable to confirm it is not + the problem. + + - **Be sure you are supplying adequate power to the board.** Check the specs of + your board and plug in an external power supply. In many cases just + plugging a board into your computer is not enough to power it and other + peripherals. + + - **Double check all soldering joints and connections.** Flakey connections + cause many mysterious problems. See the [guide to excellent soldering](https://learn.adafruit.com/adafruit-guide-excellent-soldering/tools) for examples of good solder joints. + + - **Ensure you are using an official Arduino or Adafruit board.** We can't + guarantee a clone board will have the same functionality and work as expected + with this code and don't support them. + +If you're sure this issue is a defect in the code and checked the steps above +please fill in the following fields to provide enough troubleshooting information. +You may delete the guideline and text above to just leave the following details: + +- Arduino board: **INSERT ARDUINO BOARD NAME/TYPE HERE** + +- Arduino IDE version (found in Arduino -> About Arduino menu): **INSERT ARDUINO + VERSION HERE** + +- List the steps to reproduce the problem below (if possible attach a sketch or + copy the sketch code in too): **LIST REPRO STEPS BELOW** diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.github/PULL_REQUEST_TEMPLATE.md b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..7b641eb --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,26 @@ +Thank you for creating a pull request to contribute to Adafruit's GitHub code! +Before you open the request please review the following guidelines and tips to +help it be more easily integrated: + +- **Describe the scope of your change--i.e. what the change does and what parts + of the code were modified.** This will help us understand any risks of integrating + the code. + +- **Describe any known limitations with your change.** For example if the change + doesn't apply to a supported platform of the library please mention it. + +- **Please run any tests or examples that can exercise your modified code.** We + strive to not break users of the code and running tests/examples helps with this + process. + +Thank you again for contributing! We will try to test and integrate the change +as soon as we can, but be aware we have many GitHub repositories to manage and +can't immediately respond to every request. There is no need to bump or check in +on a pull request (it will clutter the discussion of the request). + +Also don't be worried if the request is closed or not integrated--sometimes the +priorities of Adafruit's GitHub code (education, ease of use) might not match the +priorities of the pull request. Don't fret, the open source community thrives on +forks and GitHub makes it easy to keep your changes in a forked repo. + +After reviewing the guidelines above you can delete this text from the pull request. diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.github/workflows/githubci.yml b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.github/workflows/githubci.yml new file mode 100644 index 0000000..8a57d75 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.github/workflows/githubci.yml @@ -0,0 +1,33 @@ +name: Arduino Library CI + +on: [pull_request, push, repository_dispatch] + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/setup-python@v4 + with: + python-version: '3.x' + - uses: actions/checkout@v3 + - uses: actions/checkout@v3 + with: + repository: adafruit/ci-arduino + path: ci + + - name: Install the prerequisites + run: bash ci/actions_install.sh + + - name: Check for correct code formatting with clang-format + run: python3 ci/run-clang-format.py -e "ci/*" -e "bin/*" -r . + + - name: Check for correct documentation with doxygen + env: + GH_REPO_TOKEN: ${{ secrets.GH_REPO_TOKEN }} + PRETTYNAME : "Adafruit Bus IO Library" + run: bash ci/doxy_gen_and_deploy.sh + + - name: Test the code on supported platforms + run: python3 ci/build_platform.py main_platforms zero feather32u4 + diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.piopm b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.piopm new file mode 100644 index 0000000..6bd37c1 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/.piopm @@ -0,0 +1 @@ +{"type": "library", "name": "Adafruit BusIO", "version": "1.17.4", "spec": {"owner": "adafruit", "id": 6214, "name": "Adafruit BusIO", "requirements": null, "uri": null}}
\ No newline at end of file diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_BusIO_Register.cpp b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_BusIO_Register.cpp new file mode 100644 index 0000000..f3e8187 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_BusIO_Register.cpp @@ -0,0 +1,384 @@ +#include <Adafruit_BusIO_Register.h> + +#if !defined(SPI_INTERFACES_COUNT) || \ + (defined(SPI_INTERFACES_COUNT) && (SPI_INTERFACES_COUNT > 0)) + +/*! + * @brief Create a register we access over an I2C Device (which defines the + * bus and address) + * @param i2cdevice The I2CDevice to use for underlying I2C access + * @param reg_addr The address pointer value for the I2C/SMBus register, can + * be 8 or 16 bits + * @param width The width of the register data itself, defaults to 1 byte + * @param byteorder The byte order of the register (used when width is > 1), + * defaults to LSBFIRST + * @param address_width The width of the register address itself, defaults + * to 1 byte + */ +Adafruit_BusIO_Register::Adafruit_BusIO_Register(Adafruit_I2CDevice *i2cdevice, + uint16_t reg_addr, + uint8_t width, + uint8_t byteorder, + uint8_t address_width) { + _i2cdevice = i2cdevice; + _spidevice = nullptr; + _addrwidth = address_width; + _address = reg_addr; + _byteorder = byteorder; + _width = width; +} + +/*! + * @brief Create a register we access over an SPI Device (which defines the + * bus and CS pin) + * @param spidevice The SPIDevice to use for underlying SPI access + * @param reg_addr The address pointer value for the SPI register, can + * be 8 or 16 bits + * @param type The method we use to read/write data to SPI (which is not + * as well defined as I2C) + * @param width The width of the register data itself, defaults to 1 byte + * @param byteorder The byte order of the register (used when width is > 1), + * defaults to LSBFIRST + * @param address_width The width of the register address itself, defaults + * to 1 byte + */ +Adafruit_BusIO_Register::Adafruit_BusIO_Register(Adafruit_SPIDevice *spidevice, + uint16_t reg_addr, + Adafruit_BusIO_SPIRegType type, + uint8_t width, + uint8_t byteorder, + uint8_t address_width) { + _spidevice = spidevice; + _spiregtype = type; + _i2cdevice = nullptr; + _addrwidth = address_width; + _address = reg_addr; + _byteorder = byteorder; + _width = width; +} + +/*! + * @brief Create a register we access over an I2C or SPI Device. This is a + * handy function because we can pass in nullptr for the unused interface, + * allowing libraries to mass-define all the registers + * @param i2cdevice The I2CDevice to use for underlying I2C access, if + * nullptr we use SPI + * @param spidevice The SPIDevice to use for underlying SPI access, if + * nullptr we use I2C + * @param reg_addr The address pointer value for the I2C/SMBus/SPI register, + * can be 8 or 16 bits + * @param type The method we use to read/write data to SPI (which is not + * as well defined as I2C) + * @param width The width of the register data itself, defaults to 1 byte + * @param byteorder The byte order of the register (used when width is > 1), + * defaults to LSBFIRST + * @param address_width The width of the register address itself, defaults + * to 1 byte + */ +Adafruit_BusIO_Register::Adafruit_BusIO_Register( + Adafruit_I2CDevice *i2cdevice, Adafruit_SPIDevice *spidevice, + Adafruit_BusIO_SPIRegType type, uint16_t reg_addr, uint8_t width, + uint8_t byteorder, uint8_t address_width) { + _spidevice = spidevice; + _i2cdevice = i2cdevice; + _spiregtype = type; + _addrwidth = address_width; + _address = reg_addr; + _byteorder = byteorder; + _width = width; +} + +/*! + * @brief Create a register we access over a GenericDevice + * @param genericdevice Generic device to use + * @param reg_addr Register address we will read/write + * @param width Width of the register in bytes (1-4) + * @param byteorder Byte order of register data (LSBFIRST or MSBFIRST) + * @param address_width Width of the register address in bytes (1 or 2) + */ +Adafruit_BusIO_Register::Adafruit_BusIO_Register( + Adafruit_GenericDevice *genericdevice, uint16_t reg_addr, uint8_t width, + uint8_t byteorder, uint8_t address_width) { + _i2cdevice = nullptr; + _spidevice = nullptr; + _genericdevice = genericdevice; + _addrwidth = address_width; + _address = reg_addr; + _byteorder = byteorder; + _width = width; +} + +/*! + * @brief Write a buffer of data to the register location + * @param buffer Pointer to data to write + * @param len Number of bytes to write + * @return True on successful write (only really useful for I2C as SPI is + * uncheckable) + */ +bool Adafruit_BusIO_Register::write(uint8_t *buffer, uint8_t len) { + uint8_t addrbuffer[2] = {(uint8_t)(_address & 0xFF), + (uint8_t)(_address >> 8)}; + if (_i2cdevice) { + return _i2cdevice->write(buffer, len, true, addrbuffer, _addrwidth); + } + if (_spidevice) { + if (_spiregtype == ADDRESSED_OPCODE_BIT0_LOW_TO_WRITE) { + // very special case! + // pass the special opcode address which we set as the high byte of the + // regaddr + addrbuffer[0] = + (uint8_t)(_address >> 8) & ~0x01; // set bottom bit low to write + // the 'actual' reg addr is the second byte then + addrbuffer[1] = (uint8_t)(_address & 0xFF); + // the address appears to be a byte longer + return _spidevice->write(buffer, len, addrbuffer, _addrwidth + 1); + } + if (_spiregtype == ADDRBIT8_HIGH_TOREAD) { + addrbuffer[0] &= ~0x80; + } + if (_spiregtype == ADDRBIT8_HIGH_TOWRITE) { + addrbuffer[0] |= 0x80; + } + if (_spiregtype == AD8_HIGH_TOREAD_AD7_HIGH_TOINC) { + addrbuffer[0] &= ~0x80; + addrbuffer[0] |= 0x40; + } + return _spidevice->write(buffer, len, addrbuffer, _addrwidth); + } + if (_genericdevice) { + return _genericdevice->writeRegister(addrbuffer, _addrwidth, buffer, len); + } + return false; +} + +/*! + * @brief Write up to 4 bytes of data to the register location + * @param value Data to write + * @param numbytes How many bytes from 'value' to write + * @return True on successful write (only really useful for I2C as SPI is + * uncheckable) + */ +bool Adafruit_BusIO_Register::write(uint32_t value, uint8_t numbytes) { + if (numbytes == 0) { + numbytes = _width; + } + if (numbytes > 4) { + return false; + } + + // store a copy + _cached = value; + + for (int i = 0; i < numbytes; i++) { + if (_byteorder == LSBFIRST) { + _buffer[i] = value & 0xFF; + } else { + _buffer[numbytes - i - 1] = value & 0xFF; + } + value >>= 8; + } + return write(_buffer, numbytes); +} + +/*! + * @brief Read data from the register location. This does not do any error + * checking! + * @return Returns 0xFFFFFFFF on failure, value otherwise + */ +uint32_t Adafruit_BusIO_Register::read(void) { + if (!read(_buffer, _width)) { + return -1; + } + + uint32_t value = 0; + + for (int i = 0; i < _width; i++) { + value <<= 8; + if (_byteorder == LSBFIRST) { + value |= _buffer[_width - i - 1]; + } else { + value |= _buffer[i]; + } + } + + return value; +} + +/*! + * @brief Read cached data from last time we wrote to this register + * @return Returns 0xFFFFFFFF on failure, value otherwise + */ +uint32_t Adafruit_BusIO_Register::readCached(void) { return _cached; } + +/*! + @brief Read a number of bytes from a register into a buffer + @param buffer Buffer to read data into + @param len Number of bytes to read into the buffer + @return true on successful read, otherwise false +*/ +bool Adafruit_BusIO_Register::read(uint8_t *buffer, uint8_t len) { + uint8_t addrbuffer[2] = {(uint8_t)(_address & 0xFF), + (uint8_t)(_address >> 8)}; + if (_i2cdevice) { + return _i2cdevice->write_then_read(addrbuffer, _addrwidth, buffer, len); + } + if (_spidevice) { + if (_spiregtype == ADDRESSED_OPCODE_BIT0_LOW_TO_WRITE) { + // very special case! + // pass the special opcode address which we set as the high byte of the + // regaddr + addrbuffer[0] = + (uint8_t)(_address >> 8) | 0x01; // set bottom bit high to read + // the 'actual' reg addr is the second byte then + addrbuffer[1] = (uint8_t)(_address & 0xFF); + // the address appears to be a byte longer + return _spidevice->write_then_read(addrbuffer, _addrwidth + 1, buffer, + len); + } + if (_spiregtype == ADDRBIT8_HIGH_TOREAD) { + addrbuffer[0] |= 0x80; + } + if (_spiregtype == ADDRBIT8_HIGH_TOWRITE) { + addrbuffer[0] &= ~0x80; + } + if (_spiregtype == AD8_HIGH_TOREAD_AD7_HIGH_TOINC) { + addrbuffer[0] |= 0x80 | 0x40; + } + return _spidevice->write_then_read(addrbuffer, _addrwidth, buffer, len); + } + if (_genericdevice) { + return _genericdevice->readRegister(addrbuffer, _addrwidth, buffer, len); + } + return false; +} + +/*! + * @brief Read 2 bytes of data from the register location + * @param value Pointer to uint16_t variable to read into + * @return True on successful write (only really useful for I2C as SPI is + * uncheckable) + */ +bool Adafruit_BusIO_Register::read(uint16_t *value) { + if (!read(_buffer, 2)) { + return false; + } + + if (_byteorder == LSBFIRST) { + *value = _buffer[1]; + *value <<= 8; + *value |= _buffer[0]; + } else { + *value = _buffer[0]; + *value <<= 8; + *value |= _buffer[1]; + } + return true; +} + +/*! + * @brief Read 1 byte of data from the register location + * @param value Pointer to uint8_t variable to read into + * @return True on successful write (only really useful for I2C as SPI is + * uncheckable) + */ +bool Adafruit_BusIO_Register::read(uint8_t *value) { + if (!read(_buffer, 1)) { + return false; + } + + *value = _buffer[0]; + return true; +} + +/*! + * @brief Pretty printer for this register + * @param s The Stream to print to, defaults to &Serial + */ +void Adafruit_BusIO_Register::print(Stream *s) { + uint32_t val = read(); + s->print("0x"); + s->print(val, HEX); +} + +/*! + * @brief Pretty printer for this register + * @param s The Stream to print to, defaults to &Serial + */ +void Adafruit_BusIO_Register::println(Stream *s) { + print(s); + s->println(); +} + +/*! + * @brief Create a slice of the register that we can address without + * touching other bits + * @param reg The Adafruit_BusIO_Register which defines the bus/register + * @param bits The number of bits wide we are slicing + * @param shift The number of bits that our bit-slice is shifted from LSB + */ +Adafruit_BusIO_RegisterBits::Adafruit_BusIO_RegisterBits( + Adafruit_BusIO_Register *reg, uint8_t bits, uint8_t shift) { + _register = reg; + _bits = bits; + _shift = shift; +} + +/*! + * @brief Read 4 bytes of data from the register + * @return data The 4 bytes to read + */ +uint32_t Adafruit_BusIO_RegisterBits::read(void) { + uint32_t val = _register->read(); + val >>= _shift; + return val & ((1 << (_bits)) - 1); +} + +/*! + * @brief Write 4 bytes of data to the register + * @param data The 4 bytes to write + * @return True on successful write (only really useful for I2C as SPI is + * uncheckable) + */ +bool Adafruit_BusIO_RegisterBits::write(uint32_t data) { + uint32_t val = _register->read(); + + // mask off the data before writing + uint32_t mask = (1 << (_bits)) - 1; + data &= mask; + + mask <<= _shift; + val &= ~mask; // remove the current data at that spot + val |= data << _shift; // and add in the new data + + return _register->write(val, _register->width()); +} + +/*! + * @brief The width of the register data, helpful for doing calculations + * @returns The data width used when initializing the register + */ +uint8_t Adafruit_BusIO_Register::width(void) { return _width; } + +/*! + * @brief Set the default width of data + * @param width the default width of data read from register + */ +void Adafruit_BusIO_Register::setWidth(uint8_t width) { _width = width; } + +/*! + * @brief Set register address + * @param address the address from register + */ +void Adafruit_BusIO_Register::setAddress(uint16_t address) { + _address = address; +} + +/*! + * @brief Set the width of register address + * @param address_width the width for register address + */ +void Adafruit_BusIO_Register::setAddressWidth(uint16_t address_width) { + _addrwidth = address_width; +} + +#endif // SPI exists diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_BusIO_Register.h b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_BusIO_Register.h new file mode 100644 index 0000000..046e04c --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_BusIO_Register.h @@ -0,0 +1,117 @@ +#ifndef Adafruit_BusIO_Register_h +#define Adafruit_BusIO_Register_h + +#include <Arduino.h> + +#if !defined(SPI_INTERFACES_COUNT) || \ + (defined(SPI_INTERFACES_COUNT) && (SPI_INTERFACES_COUNT > 0)) + +#include <Adafruit_GenericDevice.h> +#include <Adafruit_I2CDevice.h> +#include <Adafruit_SPIDevice.h> + +typedef enum _Adafruit_BusIO_SPIRegType { + ADDRBIT8_HIGH_TOREAD = 0, + /*!< + * ADDRBIT8_HIGH_TOREAD + * When reading a register you must actually send the value 0x80 + register + * address to the device. e.g. To read the register 0x0B the register value + * 0x8B is sent and to write 0x0B is sent. + */ + AD8_HIGH_TOREAD_AD7_HIGH_TOINC = 1, + + /*!< + * ADDRBIT8_HIGH_TOWRITE + * When writing to a register you must actually send the value 0x80 + + * the register address to the device. e.g. To write to the register 0x19 the + * register value 0x99 is sent and to read 0x19 is sent. + */ + ADDRBIT8_HIGH_TOWRITE = 2, + + /*!< + * ADDRESSED_OPCODE_LOWBIT_TO_WRITE + * Used by the MCP23S series, we send 0x40 |'rd with the opcode + * Then set the lowest bit to write + */ + ADDRESSED_OPCODE_BIT0_LOW_TO_WRITE = 3, + +} Adafruit_BusIO_SPIRegType; + +/*! + * @brief The class which defines a device register (a location to read/write + * data from) + */ +class Adafruit_BusIO_Register { +public: + Adafruit_BusIO_Register(Adafruit_I2CDevice *i2cdevice, uint16_t reg_addr, + uint8_t width = 1, uint8_t byteorder = LSBFIRST, + uint8_t address_width = 1); + + Adafruit_BusIO_Register(Adafruit_SPIDevice *spidevice, uint16_t reg_addr, + Adafruit_BusIO_SPIRegType type, uint8_t width = 1, + uint8_t byteorder = LSBFIRST, + uint8_t address_width = 1); + + Adafruit_BusIO_Register(Adafruit_I2CDevice *i2cdevice, + Adafruit_SPIDevice *spidevice, + Adafruit_BusIO_SPIRegType type, uint16_t reg_addr, + uint8_t width = 1, uint8_t byteorder = LSBFIRST, + uint8_t address_width = 1); + + Adafruit_BusIO_Register(Adafruit_GenericDevice *genericdevice, + uint16_t reg_addr, uint8_t width = 1, + uint8_t byteorder = LSBFIRST, + uint8_t address_width = 1); + + bool read(uint8_t *buffer, uint8_t len); + bool read(uint8_t *value); + bool read(uint16_t *value); + uint32_t read(void); + uint32_t readCached(void); + bool write(uint8_t *buffer, uint8_t len); + bool write(uint32_t value, uint8_t numbytes = 0); + + uint8_t width(void); + + void setWidth(uint8_t width); + void setAddress(uint16_t address); + void setAddressWidth(uint16_t address_width); + +#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL) + void print(Stream *s = &Serial); + void println(Stream *s = &Serial); +#else + void print(Stream *s); + void println(Stream *s); +#endif + +private: + Adafruit_I2CDevice *_i2cdevice; + Adafruit_SPIDevice *_spidevice; + Adafruit_GenericDevice *_genericdevice; + Adafruit_BusIO_SPIRegType _spiregtype; + uint16_t _address; + uint8_t _width, _addrwidth, _byteorder; + uint8_t _buffer[4]; // we won't support anything larger than uint32 for + // non-buffered read + uint32_t _cached = 0; +}; + +/*! + * @brief The class which defines a slice of bits from within a device register + * (a location to read/write data from) + */ +class Adafruit_BusIO_RegisterBits { +public: + Adafruit_BusIO_RegisterBits(Adafruit_BusIO_Register *reg, uint8_t bits, + uint8_t shift); + bool write(uint32_t value); + uint32_t read(void); + +private: + Adafruit_BusIO_Register *_register; + uint8_t _bits, _shift; +}; + +#endif // SPI exists +#endif // BusIO_Register_h diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_GenericDevice.cpp b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_GenericDevice.cpp new file mode 100644 index 0000000..37f9cfd --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_GenericDevice.cpp @@ -0,0 +1,90 @@ +/* + Written with help by Claude! + https://claude.ai/chat/335f50b1-3dd8-435e-9139-57ec7ca26a3c (at this time + chats are not shareable :( +*/ + +#include "Adafruit_GenericDevice.h" + +/*! + * @brief Create a Generic device with the provided read/write functions + * @param obj Pointer to object instance + * @param read_func Function pointer for reading raw data + * @param write_func Function pointer for writing raw data + * @param readreg_func Function pointer for reading registers (optional) + * @param writereg_func Function pointer for writing registers (optional) */ +Adafruit_GenericDevice::Adafruit_GenericDevice( + void *obj, busio_genericdevice_read_t read_func, + busio_genericdevice_write_t write_func, + busio_genericdevice_readreg_t readreg_func, + busio_genericdevice_writereg_t writereg_func) { + _obj = obj; + _read_func = read_func; + _write_func = write_func; + _readreg_func = readreg_func; + _writereg_func = writereg_func; + _begun = false; +} + +/*! @brief Simple begin function (doesn't do much at this time) + @return true always +*/ +bool Adafruit_GenericDevice::begin(void) { + _begun = true; + return true; +} + +/*! +@brief Marks the GenericDevice as no longer in use. +@note: Since this is a GenericDevice, if you are using this with a Serial +object, this does NOT disable serial communication or release the RX/TX pins. +That must be done manually by calling Serial.end(). +*/ +void Adafruit_GenericDevice::end(void) { _begun = false; } + +/*! @brief Write a buffer of data + @param buffer Pointer to buffer of data to write + @param len Number of bytes to write + @return true if write was successful, otherwise false */ +bool Adafruit_GenericDevice::write(const uint8_t *buffer, size_t len) { + if (!_begun) + return false; + return _write_func(_obj, buffer, len); +} + +/*! @brief Read data into a buffer + @param buffer Pointer to buffer to read data into + @param len Number of bytes to read + @return true if read was successful, otherwise false */ +bool Adafruit_GenericDevice::read(uint8_t *buffer, size_t len) { + if (!_begun) + return false; + return _read_func(_obj, buffer, len); +} + +/*! @brief Read from a register location + @param addr_buf Buffer containing register address + @param addrsiz Size of register address in bytes + @param buf Buffer to store read data + @param bufsiz Size of data to read in bytes + @return true if read was successful, otherwise false */ +bool Adafruit_GenericDevice::readRegister(uint8_t *addr_buf, uint8_t addrsiz, + uint8_t *buf, uint16_t bufsiz) { + if (!_begun || !_readreg_func) + return false; + return _readreg_func(_obj, addr_buf, addrsiz, buf, bufsiz); +} + +/*! @brief Write to a register location + @param addr_buf Buffer containing register address + @param addrsiz Size of register address in bytes + @param buf Buffer containing data to write + @param bufsiz Size of data to write in bytes + @return true if write was successful, otherwise false */ +bool Adafruit_GenericDevice::writeRegister(uint8_t *addr_buf, uint8_t addrsiz, + const uint8_t *buf, + uint16_t bufsiz) { + if (!_begun || !_writereg_func) + return false; + return _writereg_func(_obj, addr_buf, addrsiz, buf, bufsiz); +} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_GenericDevice.h b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_GenericDevice.h new file mode 100644 index 0000000..d5cb326 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_GenericDevice.h @@ -0,0 +1,56 @@ +#ifndef ADAFRUIT_GENERICDEVICE_H +#define ADAFRUIT_GENERICDEVICE_H + +#include <Arduino.h> + +typedef bool (*busio_genericdevice_read_t)(void *obj, uint8_t *buffer, + size_t len); +typedef bool (*busio_genericdevice_write_t)(void *obj, const uint8_t *buffer, + size_t len); +typedef bool (*busio_genericdevice_readreg_t)(void *obj, uint8_t *addr_buf, + uint8_t addrsiz, uint8_t *data, + uint16_t datalen); +typedef bool (*busio_genericdevice_writereg_t)(void *obj, uint8_t *addr_buf, + uint8_t addrsiz, + const uint8_t *data, + uint16_t datalen); + +/*! + * @brief Class for communicating with a device via generic read/write functions + */ +class Adafruit_GenericDevice { +public: + Adafruit_GenericDevice( + void *obj, busio_genericdevice_read_t read_func, + busio_genericdevice_write_t write_func, + busio_genericdevice_readreg_t readreg_func = nullptr, + busio_genericdevice_writereg_t writereg_func = nullptr); + + bool begin(void); + void end(void); + + bool read(uint8_t *buffer, size_t len); + bool write(const uint8_t *buffer, size_t len); + bool readRegister(uint8_t *addr_buf, uint8_t addrsiz, uint8_t *buf, + uint16_t bufsiz); + bool writeRegister(uint8_t *addr_buf, uint8_t addrsiz, const uint8_t *buf, + uint16_t bufsiz); + +protected: + /*! @brief Function pointer for reading raw data from the device */ + busio_genericdevice_read_t _read_func; + /*! @brief Function pointer for writing raw data to the device */ + busio_genericdevice_write_t _write_func; + /*! @brief Function pointer for reading a 'register' from the device */ + busio_genericdevice_readreg_t _readreg_func; + /*! @brief Function pointer for writing a 'register' to the device */ + busio_genericdevice_writereg_t _writereg_func; + + bool _begun; ///< whether we have initialized yet (in case the function needs + ///< to do something) + +private: + void *_obj; ///< Pointer to object instance +}; + +#endif // ADAFRUIT_GENERICDEVICE_H diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_I2CDevice.cpp b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_I2CDevice.cpp new file mode 100644 index 0000000..2633cf1 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_I2CDevice.cpp @@ -0,0 +1,320 @@ +#include "Adafruit_I2CDevice.h" + +// #define DEBUG_SERIAL Serial + +/*! + * @brief Create an I2C device at a given address + * @param addr The 7-bit I2C address for the device + * @param theWire The I2C bus to use, defaults to &Wire + */ +Adafruit_I2CDevice::Adafruit_I2CDevice(uint8_t addr, TwoWire *theWire) { + _addr = addr; + _wire = theWire; + _begun = false; +#ifdef ARDUINO_ARCH_SAMD + _maxBufferSize = 250; // as defined in Wire.h's RingBuffer +#elif defined(ESP32) + _maxBufferSize = I2C_BUFFER_LENGTH; +#else + _maxBufferSize = 32; +#endif +} + +/*! + * @brief Initializes and does basic address detection + * @param addr_detect Whether we should attempt to detect the I2C address + * with a scan. 99% of sensors/devices don't mind, but once in a while they + * don't respond well to a scan! + * @return True if I2C initialized and a device with the addr found + */ +bool Adafruit_I2CDevice::begin(bool addr_detect) { + _wire->begin(); + _begun = true; + + if (addr_detect) { + return detected(); + } + return true; +} + +/*! + * @brief De-initialize device, turn off the Wire interface + */ +void Adafruit_I2CDevice::end(void) { + // Not all port implement Wire::end(), such as + // - ESP8266 + // - AVR core without WIRE_HAS_END + // - ESP32: end() is implemented since 2.0.1 which is latest at the moment. + // Temporarily disable for now to give time for user to update. +#if !(defined(ESP8266) || \ + (defined(ARDUINO_ARCH_AVR) && !defined(WIRE_HAS_END)) || \ + defined(ARDUINO_ARCH_ESP32)) + _wire->end(); + _begun = false; +#endif +} + +/*! + * @brief Scans I2C for the address - note will give a false-positive + * if there's no pullups on I2C + * @return True if I2C initialized and a device with the addr found + */ +bool Adafruit_I2CDevice::detected(void) { + // Init I2C if not done yet + if (!_begun && !begin()) { + return false; + } + + // A basic scanner, see if it ACK's + _wire->beginTransmission(_addr); +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.print(F("Address 0x")); + DEBUG_SERIAL.print(_addr, HEX); +#endif +#ifdef ARDUINO_ARCH_MBED + _wire->write(0); // forces a write request instead of a read +#endif + if (_wire->endTransmission() == 0) { +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.println(F(" Detected")); +#endif + return true; + } +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.println(F(" Not detected")); +#endif + return false; +} + +/*! + * @brief Write a buffer or two to the I2C device. Cannot be more than + * maxBufferSize() bytes. + * @param buffer Pointer to buffer of data to write. This is const to + * ensure the content of this buffer doesn't change. + * @param len Number of bytes from buffer to write + * @param prefix_buffer Pointer to optional array of data to write before + * buffer. Cannot be more than maxBufferSize() bytes. This is const to + * ensure the content of this buffer doesn't change. + * @param prefix_len Number of bytes from prefix buffer to write + * @param stop Whether to send an I2C STOP signal on write + * @return True if write was successful, otherwise false. + */ +bool Adafruit_I2CDevice::write(const uint8_t *buffer, size_t len, bool stop, + const uint8_t *prefix_buffer, + size_t prefix_len) { + if ((len + prefix_len) > maxBufferSize()) { + // currently not guaranteed to work if more than 32 bytes! + // we will need to find out if some platforms have larger + // I2C buffer sizes :/ +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.println(F("\tI2CDevice could not write such a large buffer")); +#endif + return false; + } + + _wire->beginTransmission(_addr); + + // Write the prefix data (usually an address) + if ((prefix_len != 0) && (prefix_buffer != nullptr)) { + if (_wire->write(prefix_buffer, prefix_len) != prefix_len) { +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.println(F("\tI2CDevice failed to write")); +#endif + return false; + } + } + + // Write the data itself + if (_wire->write(buffer, len) != len) { +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.println(F("\tI2CDevice failed to write")); +#endif + return false; + } + +#ifdef DEBUG_SERIAL + + DEBUG_SERIAL.print(F("\tI2CWRITE @ 0x")); + DEBUG_SERIAL.print(_addr, HEX); + DEBUG_SERIAL.print(F(" :: ")); + if ((prefix_len != 0) && (prefix_buffer != nullptr)) { + for (uint16_t i = 0; i < prefix_len; i++) { + DEBUG_SERIAL.print(F("0x")); + DEBUG_SERIAL.print(prefix_buffer[i], HEX); + DEBUG_SERIAL.print(F(", ")); + } + } + for (uint16_t i = 0; i < len; i++) { + DEBUG_SERIAL.print(F("0x")); + DEBUG_SERIAL.print(buffer[i], HEX); + DEBUG_SERIAL.print(F(", ")); + if (i % 32 == 31) { + DEBUG_SERIAL.println(); + } + } + + if (stop) { + DEBUG_SERIAL.print("\tSTOP"); + } +#endif + + if (_wire->endTransmission(stop) == 0) { +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.println(); + // DEBUG_SERIAL.println("Sent!"); +#endif + return true; + } else { +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.println("\tFailed to send!"); +#endif + return false; + } +} + +/*! + * @brief Read from I2C into a buffer from the I2C device. + * Cannot be more than maxBufferSize() bytes. + * @param buffer Pointer to buffer of data to read into + * @param len Number of bytes from buffer to read. + * @param stop Whether to send an I2C STOP signal on read + * @return True if read was successful, otherwise false. + */ +bool Adafruit_I2CDevice::read(uint8_t *buffer, size_t len, bool stop) { + size_t pos = 0; + while (pos < len) { + size_t read_len = + ((len - pos) > maxBufferSize()) ? maxBufferSize() : (len - pos); + bool read_stop = (pos < (len - read_len)) ? false : stop; + if (!_read(buffer + pos, read_len, read_stop)) + return false; + pos += read_len; + } + return true; +} + +bool Adafruit_I2CDevice::_read(uint8_t *buffer, size_t len, bool stop) { +#if defined(TinyWireM_h) + size_t recv = _wire->requestFrom((uint8_t)_addr, (uint8_t)len); +#elif defined(ARDUINO_ARCH_MEGAAVR) + size_t recv = _wire->requestFrom(_addr, len, stop); +#else + size_t recv = _wire->requestFrom((uint8_t)_addr, (uint8_t)len, (uint8_t)stop); +#endif + + if (recv != len) { + // Not enough data available to fulfill our obligation! +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.print(F("\tI2CDevice did not receive enough data: ")); + DEBUG_SERIAL.println(recv); +#endif + return false; + } + + for (uint16_t i = 0; i < len; i++) { + buffer[i] = _wire->read(); + } + +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.print(F("\tI2CREAD @ 0x")); + DEBUG_SERIAL.print(_addr, HEX); + DEBUG_SERIAL.print(F(" :: ")); + for (uint16_t i = 0; i < len; i++) { + DEBUG_SERIAL.print(F("0x")); + DEBUG_SERIAL.print(buffer[i], HEX); + DEBUG_SERIAL.print(F(", ")); + if (len % 32 == 31) { + DEBUG_SERIAL.println(); + } + } + DEBUG_SERIAL.println(); +#endif + + return true; +} + +/*! + * @brief Write some data, then read some data from I2C into another buffer. + * Cannot be more than maxBufferSize() bytes. The buffers can point to + * same/overlapping locations. + * @param write_buffer Pointer to buffer of data to write from + * @param write_len Number of bytes from buffer to write. + * @param read_buffer Pointer to buffer of data to read into. + * @param read_len Number of bytes from buffer to read. + * @param stop Whether to send an I2C STOP signal between the write and read + * @return True if write & read was successful, otherwise false. + */ +bool Adafruit_I2CDevice::write_then_read(const uint8_t *write_buffer, + size_t write_len, uint8_t *read_buffer, + size_t read_len, bool stop) { + if (!write(write_buffer, write_len, stop)) { + return false; + } + + return read(read_buffer, read_len); +} + +/*! + * @brief Returns the 7-bit address of this device + * @return The 7-bit address of this device + */ +uint8_t Adafruit_I2CDevice::address(void) { return _addr; } + +/*! + * @brief Change the I2C clock speed to desired (relies on + * underlying Wire support! + * @param desiredclk The desired I2C SCL frequency + * @return True if this platform supports changing I2C speed. + * Not necessarily that the speed was achieved! + */ +bool Adafruit_I2CDevice::setSpeed(uint32_t desiredclk) { +#if defined(__AVR_ATmega328__) || \ + defined(__AVR_ATmega328P__) // fix arduino core set clock + // calculate TWBR correctly + + if ((F_CPU / 18) < desiredclk) { +#ifdef DEBUG_SERIAL + Serial.println(F("I2C.setSpeed too high.")); +#endif + return false; + } + uint32_t atwbr = ((F_CPU / desiredclk) - 16) / 2; + if (atwbr > 16320) { +#ifdef DEBUG_SERIAL + Serial.println(F("I2C.setSpeed too low.")); +#endif + return false; + } + + if (atwbr <= 255) { + atwbr /= 1; + TWSR = 0x0; + } else if (atwbr <= 1020) { + atwbr /= 4; + TWSR = 0x1; + } else if (atwbr <= 4080) { + atwbr /= 16; + TWSR = 0x2; + } else { // if (atwbr <= 16320) + atwbr /= 64; + TWSR = 0x3; + } + TWBR = atwbr; + +#ifdef DEBUG_SERIAL + Serial.print(F("TWSR prescaler = ")); + Serial.println(pow(4, TWSR)); + Serial.print(F("TWBR = ")); + Serial.println(atwbr); +#endif + return true; +#elif (ARDUINO >= 157) && !defined(ARDUINO_STM32_FEATHER) && \ + !defined(TinyWireM_h) + _wire->setClock(desiredclk); + return true; + +#else + (void)desiredclk; + return false; +#endif +} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_I2CDevice.h b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_I2CDevice.h new file mode 100644 index 0000000..6bda7ba --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_I2CDevice.h @@ -0,0 +1,36 @@ +#ifndef Adafruit_I2CDevice_h +#define Adafruit_I2CDevice_h + +#include <Arduino.h> +#include <Wire.h> + +///< The class which defines how we will talk to this device over I2C +class Adafruit_I2CDevice { +public: + Adafruit_I2CDevice(uint8_t addr, TwoWire *theWire = &Wire); + uint8_t address(void); + bool begin(bool addr_detect = true); + void end(void); + bool detected(void); + + bool read(uint8_t *buffer, size_t len, bool stop = true); + bool write(const uint8_t *buffer, size_t len, bool stop = true, + const uint8_t *prefix_buffer = nullptr, size_t prefix_len = 0); + bool write_then_read(const uint8_t *write_buffer, size_t write_len, + uint8_t *read_buffer, size_t read_len, + bool stop = false); + bool setSpeed(uint32_t desiredclk); + + /*! @brief How many bytes we can read in a transaction + * @return The size of the Wire receive/transmit buffer */ + size_t maxBufferSize() { return _maxBufferSize; } + +private: + uint8_t _addr; + TwoWire *_wire; + bool _begun; + size_t _maxBufferSize; + bool _read(uint8_t *buffer, size_t len, bool stop); +}; + +#endif // Adafruit_I2CDevice_h diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_I2CRegister.h b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_I2CRegister.h new file mode 100644 index 0000000..186850f --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_I2CRegister.h @@ -0,0 +1,10 @@ +#ifndef _ADAFRUIT_I2C_REGISTER_H_ +#define _ADAFRUIT_I2C_REGISTER_H_ + +#include <Adafruit_BusIO_Register.h> +#include <Arduino.h> + +typedef Adafruit_BusIO_Register Adafruit_I2CRegister; +typedef Adafruit_BusIO_RegisterBits Adafruit_I2CRegisterBits; + +#endif diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_SPIDevice.cpp b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_SPIDevice.cpp new file mode 100644 index 0000000..3283de6 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_SPIDevice.cpp @@ -0,0 +1,512 @@ +#include "Adafruit_SPIDevice.h" + +// #define DEBUG_SERIAL Serial + +#ifdef BUSIO_USE_FAST_PINIO +#define BUSIO_SET_CLOCK_LOW() (*clkPort = *clkPort & ~clkPinMask) +#define BUSIO_SET_CLOCK_HIGH() (*clkPort = *clkPort | clkPinMask) +#define BUSIO_READ_MISO() (*misoPort & misoPinMask) +#define BUSIO_WRITE_MOSI(value) \ + do { \ + if (value) \ + *mosiPort = *mosiPort | mosiPinMask; \ + else \ + *mosiPort = *mosiPort & ~mosiPinMask; \ + } while (0) +#else +#define BUSIO_SET_CLOCK_LOW() digitalWrite(_sck, LOW) +#define BUSIO_SET_CLOCK_HIGH() digitalWrite(_sck, HIGH) +#define BUSIO_READ_MISO() digitalRead(_miso) +#define BUSIO_WRITE_MOSI(value) digitalWrite(_mosi, value) +#endif + +/*! + * @brief Create an SPI device with the given CS pin and settings + * @param cspin The arduino pin number to use for chip select + * @param freq The SPI clock frequency to use, defaults to 1MHz + * @param dataOrder The SPI data order to use for bits within each byte, + * defaults to SPI_BITORDER_MSBFIRST + * @param dataMode The SPI mode to use, defaults to SPI_MODE0 + * @param theSPI The SPI bus to use, defaults to &theSPI + */ +Adafruit_SPIDevice::Adafruit_SPIDevice(int8_t cspin, uint32_t freq, + BusIOBitOrder dataOrder, + uint8_t dataMode, SPIClass *theSPI) { +#ifdef BUSIO_HAS_HW_SPI + _cs = cspin; + _sck = _mosi = _miso = -1; + _spi = theSPI; + _begun = false; + _spiSetting = new SPISettings(freq, dataOrder, dataMode); + _freq = freq; + _dataOrder = dataOrder; + _dataMode = dataMode; +#else + // unused, but needed to suppress compiler warns + (void)cspin; + (void)freq; + (void)dataOrder; + (void)dataMode; + (void)theSPI; +#endif +} + +/*! + * @brief Create an SPI device with the given CS pin and settings + * @param cspin The arduino pin number to use for chip select + * @param sckpin The arduino pin number to use for SCK + * @param misopin The arduino pin number to use for MISO, set to -1 if not + * used + * @param mosipin The arduino pin number to use for MOSI, set to -1 if not + * used + * @param freq The SPI clock frequency to use, defaults to 1MHz + * @param dataOrder The SPI data order to use for bits within each byte, + * defaults to SPI_BITORDER_MSBFIRST + * @param dataMode The SPI mode to use, defaults to SPI_MODE0 + */ +Adafruit_SPIDevice::Adafruit_SPIDevice(int8_t cspin, int8_t sckpin, + int8_t misopin, int8_t mosipin, + uint32_t freq, BusIOBitOrder dataOrder, + uint8_t dataMode) { + _cs = cspin; + _sck = sckpin; + _miso = misopin; + _mosi = mosipin; + +#ifdef BUSIO_USE_FAST_PINIO + csPort = (BusIO_PortReg *)portOutputRegister(digitalPinToPort(cspin)); + csPinMask = digitalPinToBitMask(cspin); + if (mosipin != -1) { + mosiPort = (BusIO_PortReg *)portOutputRegister(digitalPinToPort(mosipin)); + mosiPinMask = digitalPinToBitMask(mosipin); + } + if (misopin != -1) { + misoPort = (BusIO_PortReg *)portInputRegister(digitalPinToPort(misopin)); + misoPinMask = digitalPinToBitMask(misopin); + } + clkPort = (BusIO_PortReg *)portOutputRegister(digitalPinToPort(sckpin)); + clkPinMask = digitalPinToBitMask(sckpin); +#endif + + _freq = freq; + _dataOrder = dataOrder; + _dataMode = dataMode; + _begun = false; +} + +/*! + * @brief Release memory allocated in constructors + */ +Adafruit_SPIDevice::~Adafruit_SPIDevice() { + if (_spiSetting) + delete _spiSetting; +} + +/*! + * @brief Initializes SPI bus and sets CS pin high + * @return Always returns true because there's no way to test success of SPI + * init + */ +bool Adafruit_SPIDevice::begin(void) { + if (_cs != -1) { + pinMode(_cs, OUTPUT); + digitalWrite(_cs, HIGH); + } + + if (_spi) { // hardware SPI +#ifdef BUSIO_HAS_HW_SPI + _spi->begin(); +#endif + } else { + pinMode(_sck, OUTPUT); + + if ((_dataMode == SPI_MODE0) || (_dataMode == SPI_MODE1)) { + // idle low on mode 0 and 1 + digitalWrite(_sck, LOW); + } else { + // idle high on mode 2 or 3 + digitalWrite(_sck, HIGH); + } + if (_mosi != -1) { + pinMode(_mosi, OUTPUT); + digitalWrite(_mosi, HIGH); + } + if (_miso != -1) { + pinMode(_miso, INPUT); + } + } + + _begun = true; + return true; +} + +/*! + * @brief Transfer (send/receive) a buffer over hard/soft SPI, without + * transaction management + * @param buffer The buffer to send and receive at the same time + * @param len The number of bytes to transfer + */ +void Adafruit_SPIDevice::transfer(uint8_t *buffer, size_t len) { + // + // HARDWARE SPI + // + if (_spi) { +#ifdef BUSIO_HAS_HW_SPI +#if defined(SPARK) + _spi->transfer(buffer, buffer, len, nullptr); +#elif defined(STM32) + for (size_t i = 0; i < len; i++) { + _spi->transfer(buffer[i]); + } +#else + _spi->transfer(buffer, len); +#endif + return; +#endif + } + + // + // SOFTWARE SPI + // + uint8_t startbit; + if (_dataOrder == SPI_BITORDER_LSBFIRST) { + startbit = 0x1; + } else { + startbit = 0x80; + } + + bool towrite, lastmosi = !(buffer[0] & startbit); + uint8_t bitdelay_us = (1000000 / _freq) / 2; + + for (size_t i = 0; i < len; i++) { + uint8_t reply = 0; + uint8_t send = buffer[i]; + + /* + Serial.print("\tSending software SPI byte 0x"); + Serial.print(send, HEX); + Serial.print(" -> 0x"); + */ + + // Serial.print(send, HEX); + for (uint8_t b = startbit; b != 0; + b = (_dataOrder == SPI_BITORDER_LSBFIRST) ? b << 1 : b >> 1) { + + if (bitdelay_us) { + delayMicroseconds(bitdelay_us); + } + + if (_dataMode == SPI_MODE0 || _dataMode == SPI_MODE2) { + towrite = send & b; + if ((_mosi != -1) && (lastmosi != towrite)) { + BUSIO_WRITE_MOSI(towrite); + lastmosi = towrite; + } + + BUSIO_SET_CLOCK_HIGH(); + + if (bitdelay_us) { + delayMicroseconds(bitdelay_us); + } + + if (_miso != -1) { + if (BUSIO_READ_MISO()) + reply |= b; + } + + BUSIO_SET_CLOCK_LOW(); + + } else if (_dataMode == SPI_MODE3) { + + if (_mosi != -1) { // transmit on falling edge + BUSIO_WRITE_MOSI(send & b); + } + + BUSIO_SET_CLOCK_LOW(); + + if (bitdelay_us) { + delayMicroseconds(bitdelay_us); + } + + BUSIO_SET_CLOCK_HIGH(); + + if (bitdelay_us) { + delayMicroseconds(bitdelay_us); + } + + if (_miso != -1) { // read on rising edge + if (BUSIO_READ_MISO()) { + reply |= b; + } + } + + } else { // || _dataMode == SPI_MODE1) + + BUSIO_SET_CLOCK_HIGH(); + + if (bitdelay_us) { + delayMicroseconds(bitdelay_us); + } + + if (_mosi != -1) { + BUSIO_WRITE_MOSI(send & b); + } + + BUSIO_SET_CLOCK_LOW(); + + if (_miso != -1) { + if (BUSIO_READ_MISO()) { + reply |= b; + } + } + } + } + if (_miso != -1) { + buffer[i] = reply; + } + } + return; +} + +/*! + * @brief Transfer (send/receive) one byte over hard/soft SPI, without + * transaction management + * @param send The byte to send + * @return The byte received while transmitting + */ +uint8_t Adafruit_SPIDevice::transfer(uint8_t send) { + uint8_t data = send; + transfer(&data, 1); + return data; +} + +/*! + * @brief Manually begin a transaction (calls beginTransaction if hardware + * SPI) + */ +void Adafruit_SPIDevice::beginTransaction(void) { + if (_spi) { +#ifdef BUSIO_HAS_HW_SPI + _spi->beginTransaction(*_spiSetting); +#endif + } +} + +/*! + * @brief Manually end a transaction (calls endTransaction if hardware SPI) + */ +void Adafruit_SPIDevice::endTransaction(void) { + if (_spi) { +#ifdef BUSIO_HAS_HW_SPI + _spi->endTransaction(); +#endif + } +} + +/*! + * @brief Assert/Deassert the CS pin if it is defined + * @param value The state the CS is set to + */ +void Adafruit_SPIDevice::setChipSelect(int value) { + if (_cs != -1) { + digitalWrite(_cs, value); + } +} + +/*! + * @brief Write a buffer or two to the SPI device, with transaction + * management. + * @brief Manually begin a transaction (calls beginTransaction if hardware + * SPI) with asserting the CS pin + */ +void Adafruit_SPIDevice::beginTransactionWithAssertingCS() { + beginTransaction(); + setChipSelect(LOW); +} + +/*! + * @brief Manually end a transaction (calls endTransaction if hardware SPI) + * with deasserting the CS pin + */ +void Adafruit_SPIDevice::endTransactionWithDeassertingCS() { + setChipSelect(HIGH); + endTransaction(); +} + +/*! + * @brief Write a buffer or two to the SPI device, with transaction + * management. + * @param buffer Pointer to buffer of data to write + * @param len Number of bytes from buffer to write + * @param prefix_buffer Pointer to optional array of data to write before + * buffer. + * @param prefix_len Number of bytes from prefix buffer to write + * @return Always returns true because there's no way to test success of SPI + * writes + */ +bool Adafruit_SPIDevice::write(const uint8_t *buffer, size_t len, + const uint8_t *prefix_buffer, + size_t prefix_len) { + beginTransactionWithAssertingCS(); + + // do the writing +#if defined(ARDUINO_ARCH_ESP32) + if (_spi) { + if (prefix_len > 0) { + _spi->transferBytes((uint8_t *)prefix_buffer, nullptr, prefix_len); + } + if (len > 0) { + _spi->transferBytes((uint8_t *)buffer, nullptr, len); + } + } else +#endif + { + for (size_t i = 0; i < prefix_len; i++) { + transfer(prefix_buffer[i]); + } + for (size_t i = 0; i < len; i++) { + transfer(buffer[i]); + } + } + endTransactionWithDeassertingCS(); + +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.print(F("\tSPIDevice Wrote: ")); + if ((prefix_len != 0) && (prefix_buffer != nullptr)) { + for (uint16_t i = 0; i < prefix_len; i++) { + DEBUG_SERIAL.print(F("0x")); + DEBUG_SERIAL.print(prefix_buffer[i], HEX); + DEBUG_SERIAL.print(F(", ")); + } + } + for (uint16_t i = 0; i < len; i++) { + DEBUG_SERIAL.print(F("0x")); + DEBUG_SERIAL.print(buffer[i], HEX); + DEBUG_SERIAL.print(F(", ")); + if (i % 32 == 31) { + DEBUG_SERIAL.println(); + } + } + DEBUG_SERIAL.println(); +#endif + + return true; +} + +/*! + * @brief Read from SPI into a buffer from the SPI device, with transaction + * management. + * @param buffer Pointer to buffer of data to read into + * @param len Number of bytes from buffer to read. + * @param sendvalue The 8-bits of data to write when doing the data read, + * defaults to 0xFF + * @return Always returns true because there's no way to test success of SPI + * writes + */ +bool Adafruit_SPIDevice::read(uint8_t *buffer, size_t len, uint8_t sendvalue) { + memset(buffer, sendvalue, len); // clear out existing buffer + + beginTransactionWithAssertingCS(); + transfer(buffer, len); + endTransactionWithDeassertingCS(); + +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.print(F("\tSPIDevice Read: ")); + for (uint16_t i = 0; i < len; i++) { + DEBUG_SERIAL.print(F("0x")); + DEBUG_SERIAL.print(buffer[i], HEX); + DEBUG_SERIAL.print(F(", ")); + if (len % 32 == 31) { + DEBUG_SERIAL.println(); + } + } + DEBUG_SERIAL.println(); +#endif + + return true; +} + +/*! + * @brief Write some data, then read some data from SPI into another buffer, + * with transaction management. The buffers can point to same/overlapping + * locations. This does not transmit-receive at the same time! + * @param write_buffer Pointer to buffer of data to write from + * @param write_len Number of bytes from buffer to write. + * @param read_buffer Pointer to buffer of data to read into. + * @param read_len Number of bytes from buffer to read. + * @param sendvalue The 8-bits of data to write when doing the data read, + * defaults to 0xFF + * @return Always returns true because there's no way to test success of SPI + * writes + */ +bool Adafruit_SPIDevice::write_then_read(const uint8_t *write_buffer, + size_t write_len, uint8_t *read_buffer, + size_t read_len, uint8_t sendvalue) { + beginTransactionWithAssertingCS(); + // do the writing +#if defined(ARDUINO_ARCH_ESP32) + if (_spi) { + if (write_len > 0) { + _spi->transferBytes((uint8_t *)write_buffer, nullptr, write_len); + } + } else +#endif + { + for (size_t i = 0; i < write_len; i++) { + transfer(write_buffer[i]); + } + } + +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.print(F("\tSPIDevice Wrote: ")); + for (uint16_t i = 0; i < write_len; i++) { + DEBUG_SERIAL.print(F("0x")); + DEBUG_SERIAL.print(write_buffer[i], HEX); + DEBUG_SERIAL.print(F(", ")); + if (write_len % 32 == 31) { + DEBUG_SERIAL.println(); + } + } + DEBUG_SERIAL.println(); +#endif + + // do the reading + for (size_t i = 0; i < read_len; i++) { + read_buffer[i] = transfer(sendvalue); + } + +#ifdef DEBUG_SERIAL + DEBUG_SERIAL.print(F("\tSPIDevice Read: ")); + for (uint16_t i = 0; i < read_len; i++) { + DEBUG_SERIAL.print(F("0x")); + DEBUG_SERIAL.print(read_buffer[i], HEX); + DEBUG_SERIAL.print(F(", ")); + if (read_len % 32 == 31) { + DEBUG_SERIAL.println(); + } + } + DEBUG_SERIAL.println(); +#endif + + endTransactionWithDeassertingCS(); + + return true; +} + +/*! + * @brief Write some data and read some data at the same time from SPI + * into the same buffer, with transaction management. This is basicaly a wrapper + * for transfer() with CS-pin and transaction management. This /does/ + * transmit-receive at the same time! + * @param buffer Pointer to buffer of data to write/read to/from + * @param len Number of bytes from buffer to write/read. + * @return Always returns true because there's no way to test success of SPI + * writes + */ +bool Adafruit_SPIDevice::write_and_read(uint8_t *buffer, size_t len) { + beginTransactionWithAssertingCS(); + transfer(buffer, len); + endTransactionWithDeassertingCS(); + + return true; +} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_SPIDevice.h b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_SPIDevice.h new file mode 100644 index 0000000..82a0281 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/Adafruit_SPIDevice.h @@ -0,0 +1,149 @@ +#ifndef Adafruit_SPIDevice_h +#define Adafruit_SPIDevice_h + +#include <Arduino.h> + +#if !defined(SPI_INTERFACES_COUNT) || \ + (defined(SPI_INTERFACES_COUNT) && (SPI_INTERFACES_COUNT > 0)) +// HW SPI available +#include <SPI.h> +#define BUSIO_HAS_HW_SPI +#else +// SW SPI ONLY +enum { SPI_MODE0, SPI_MODE1, SPI_MODE2, SPI_MODE3 }; +typedef uint8_t SPIClass; +#endif + +// some modern SPI definitions don't have BitOrder enum +#if (defined(__AVR__) && !defined(ARDUINO_ARCH_MEGAAVR)) || \ + defined(ESP8266) || defined(TEENSYDUINO) || defined(SPARK) || \ + defined(ARDUINO_ARCH_SPRESENSE) || defined(MEGATINYCORE) || \ + defined(DXCORE) || defined(ARDUINO_AVR_ATmega4809) || \ + defined(ARDUINO_AVR_ATmega4808) || defined(ARDUINO_AVR_ATmega3209) || \ + defined(ARDUINO_AVR_ATmega3208) || defined(ARDUINO_AVR_ATmega1609) || \ + defined(ARDUINO_AVR_ATmega1608) || defined(ARDUINO_AVR_ATmega809) || \ + defined(ARDUINO_AVR_ATmega808) || defined(ARDUINO_ARCH_ARC32) || \ + defined(ARDUINO_ARCH_XMC) + +typedef enum _BitOrder { + SPI_BITORDER_MSBFIRST = MSBFIRST, + SPI_BITORDER_LSBFIRST = LSBFIRST, +} BusIOBitOrder; + +#elif defined(ESP32) || defined(__ASR6501__) || defined(__ASR6502__) + +// some modern SPI definitions don't have BitOrder enum and have different SPI +// mode defines +typedef enum _BitOrder { + SPI_BITORDER_MSBFIRST = SPI_MSBFIRST, + SPI_BITORDER_LSBFIRST = SPI_LSBFIRST, +} BusIOBitOrder; + +#else +// Some platforms have a BitOrder enum but its named MSBFIRST/LSBFIRST +#define SPI_BITORDER_MSBFIRST MSBFIRST +#define SPI_BITORDER_LSBFIRST LSBFIRST +typedef BitOrder BusIOBitOrder; +#endif + +#if defined(__IMXRT1062__) // Teensy 4.x +// *Warning* I disabled the usage of FAST_PINIO as the set/clear operations +// used in the cpp file are not atomic and can effect multiple IO pins +// and if an interrupt happens in between the time the code reads the register +// and writes out the updated value, that changes one or more other IO pins +// on that same IO port, those change will be clobbered when the updated +// values are written back. A fast version can be implemented that uses the +// ports set and clear registers which are atomic. +// typedef volatile uint32_t BusIO_PortReg; +// typedef uint32_t BusIO_PortMask; +// #define BUSIO_USE_FAST_PINIO + +#elif defined(__MBED__) || defined(__ZEPHYR__) +// Boards based on RTOS cores like mbed or Zephyr are not going to expose the +// low level registers needed for fast pin manipulation +#undef BUSIO_USE_FAST_PINIO + +#elif defined(ARDUINO_ARCH_XMC) +#undef BUSIO_USE_FAST_PINIO + +#elif defined(__AVR__) || defined(TEENSYDUINO) +typedef volatile uint8_t BusIO_PortReg; +typedef uint8_t BusIO_PortMask; +#define BUSIO_USE_FAST_PINIO + +#elif defined(ESP8266) || defined(ESP32) || defined(__SAM3X8E__) || \ + defined(ARDUINO_ARCH_SAMD) +typedef volatile uint32_t BusIO_PortReg; +typedef uint32_t BusIO_PortMask; +#define BUSIO_USE_FAST_PINIO + +#elif (defined(__arm__) || defined(ARDUINO_FEATHER52)) && \ + !defined(ARDUINO_ARCH_RP2040) && !defined(ARDUINO_SILABS) && \ + !defined(ARDUINO_UNOR4_MINIMA) && !defined(ARDUINO_UNOR4_WIFI) && \ + !defined(PORTDUINO) +typedef volatile uint32_t BusIO_PortReg; +typedef uint32_t BusIO_PortMask; +#if !defined(__ASR6501__) && !defined(__ASR6502__) +#define BUSIO_USE_FAST_PINIO +#endif + +#else +#undef BUSIO_USE_FAST_PINIO +#endif + +/**! The class which defines how we will talk to this device over SPI **/ +class Adafruit_SPIDevice { +public: +#ifdef BUSIO_HAS_HW_SPI + Adafruit_SPIDevice(int8_t cspin, uint32_t freq = 1000000, + BusIOBitOrder dataOrder = SPI_BITORDER_MSBFIRST, + uint8_t dataMode = SPI_MODE0, SPIClass *theSPI = &SPI); +#else + Adafruit_SPIDevice(int8_t cspin, uint32_t freq = 1000000, + BusIOBitOrder dataOrder = SPI_BITORDER_MSBFIRST, + uint8_t dataMode = SPI_MODE0, SPIClass *theSPI = nullptr); +#endif + Adafruit_SPIDevice(int8_t cspin, int8_t sck, int8_t miso, int8_t mosi, + uint32_t freq = 1000000, + BusIOBitOrder dataOrder = SPI_BITORDER_MSBFIRST, + uint8_t dataMode = SPI_MODE0); + ~Adafruit_SPIDevice(); + + bool begin(void); + bool read(uint8_t *buffer, size_t len, uint8_t sendvalue = 0xFF); + bool write(const uint8_t *buffer, size_t len, + const uint8_t *prefix_buffer = nullptr, size_t prefix_len = 0); + bool write_then_read(const uint8_t *write_buffer, size_t write_len, + uint8_t *read_buffer, size_t read_len, + uint8_t sendvalue = 0xFF); + bool write_and_read(uint8_t *buffer, size_t len); + + uint8_t transfer(uint8_t send); + void transfer(uint8_t *buffer, size_t len); + void beginTransaction(void); + void endTransaction(void); + void beginTransactionWithAssertingCS(); + void endTransactionWithDeassertingCS(); + +private: +#ifdef BUSIO_HAS_HW_SPI + SPIClass *_spi = nullptr; + SPISettings *_spiSetting = nullptr; +#else + uint8_t *_spi = nullptr; + uint8_t *_spiSetting = nullptr; +#endif + uint32_t _freq; + BusIOBitOrder _dataOrder; + uint8_t _dataMode; + void setChipSelect(int value); + + int8_t _cs, _sck, _mosi, _miso; +#ifdef BUSIO_USE_FAST_PINIO + BusIO_PortReg *mosiPort, *clkPort, *misoPort, *csPort; + BusIO_PortMask mosiPinMask, misoPinMask, clkPinMask, csPinMask; +#endif + bool _begun; +}; + +#endif // Adafruit_SPIDevice_h diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/CMakeLists.txt b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/CMakeLists.txt new file mode 100644 index 0000000..3fcb0b8 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/CMakeLists.txt @@ -0,0 +1,11 @@ +# Adafruit Bus IO Library
+# https://github.com/adafruit/Adafruit_BusIO
+# MIT License
+
+cmake_minimum_required(VERSION 3.5)
+
+idf_component_register(SRCS "Adafruit_I2CDevice.cpp" "Adafruit_BusIO_Register.cpp" "Adafruit_SPIDevice.cpp" "Adafruit_GenericDevice.cpp"
+ INCLUDE_DIRS "."
+ REQUIRES arduino-esp32)
+
+project(Adafruit_BusIO)
diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/LICENSE b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/LICENSE new file mode 100644 index 0000000..860e3e2 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2017 Adafruit Industries + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE.
\ No newline at end of file diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/README.md b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/README.md new file mode 100644 index 0000000..59712ff --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/README.md @@ -0,0 +1,8 @@ +# Adafruit Bus IO Library [](https://github.com/adafruit/Adafruit_BusIO/actions) + + +This is a helper library to abstract away I2C, SPI, and 'generic transport' (e.g. UART) transactions and registers + +Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit! + +MIT license, all text above must be included in any redistribution diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/component.mk b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/component.mk new file mode 100644 index 0000000..049f190 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/component.mk @@ -0,0 +1 @@ +COMPONENT_ADD_INCLUDEDIRS = .
diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/.uno.test.skip b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/.uno.test.skip new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/.uno.test.skip diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/genericdevice_uartregtest.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/genericdevice_uartregtest.ino new file mode 100644 index 0000000..59af308 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/genericdevice_uartregtest.ino @@ -0,0 +1,219 @@ +/*
+ Advanced example of using bstracted transport for reading and writing
+ register data from a UART-based device such as a TMC2209
+
+ Written with help by Claude!
+ https://claude.ai/chat/335f50b1-3dd8-435e-9139-57ec7ca26a3c (at this time
+ chats are not shareable :(
+*/
+
+#include "Adafruit_BusIO_Register.h"
+#include "Adafruit_GenericDevice.h"
+
+// Debugging macros
+#define DEBUG_SERIAL Serial
+
+#ifdef DEBUG_SERIAL
+#define DEBUG_PRINT(x) DEBUG_SERIAL.print(x)
+#define DEBUG_PRINTLN(x) DEBUG_SERIAL.println(x)
+#define DEBUG_PRINT_HEX(x) \
+ do { \
+ if (x < 0x10) \
+ DEBUG_SERIAL.print('0'); \
+ DEBUG_SERIAL.print(x, HEX); \
+ DEBUG_SERIAL.print(' '); \
+ } while (0)
+#else
+#define DEBUG_PRINT(x)
+#define DEBUG_PRINTLN(x)
+#define DEBUG_PRINT_HEX(x)
+#endif
+
+#define TMC2209_IOIN 0x06
+
+class TMC2209_UART {
+private:
+ Stream *_uart_stream;
+ uint8_t _addr;
+
+ static bool uart_read(void *thiz, uint8_t *buffer, size_t len) {
+ TMC2209_UART *dev = (TMC2209_UART *)thiz;
+ uint16_t timeout = 100;
+ while (dev->_uart_stream->available() < len && timeout--) {
+ delay(1);
+ }
+ if (timeout == 0) {
+ DEBUG_PRINTLN("Read timeout!");
+ return false;
+ }
+
+ DEBUG_PRINT("Reading: ");
+ for (size_t i = 0; i < len; i++) {
+ buffer[i] = dev->_uart_stream->read();
+ DEBUG_PRINT_HEX(buffer[i]);
+ }
+ DEBUG_PRINTLN("");
+
+ return true;
+ }
+
+ static bool uart_write(void *thiz, const uint8_t *buffer, size_t len) {
+ TMC2209_UART *dev = (TMC2209_UART *)thiz;
+ DEBUG_PRINT("Writing: ");
+ for (size_t i = 0; i < len; i++) {
+ DEBUG_PRINT_HEX(buffer[i]);
+ }
+ DEBUG_PRINTLN("");
+
+ dev->_uart_stream->write(buffer, len);
+ return true;
+ }
+
+ static bool uart_readreg(void *thiz, uint8_t *addr_buf, uint8_t addrsiz,
+ uint8_t *data, uint16_t datalen) {
+ TMC2209_UART *dev = (TMC2209_UART *)thiz;
+ while (dev->_uart_stream->available())
+ dev->_uart_stream->read();
+
+ uint8_t packet[4] = {0x05, uint8_t(dev->_addr << 1), addr_buf[0], 0x00};
+
+ packet[3] = calcCRC(packet, 3);
+ if (!uart_write(thiz, packet, 4))
+ return false;
+
+ // Read back echo
+ uint8_t echo[4];
+ if (!uart_read(thiz, echo, 4))
+ return false;
+
+ // Verify echo
+ for (uint8_t i = 0; i < 4; i++) {
+ if (echo[i] != packet[i]) {
+ DEBUG_PRINTLN("Echo mismatch");
+ return false;
+ }
+ }
+
+ uint8_t response[8]; // sync + 0xFF + reg + 4 data bytes + CRC
+ if (!uart_read(thiz, response, 8))
+ return false;
+
+ // Verify response
+ if (response[0] != 0x05) {
+ DEBUG_PRINTLN("Invalid sync byte");
+ return false;
+ }
+
+ if (response[1] != 0xFF) {
+ DEBUG_PRINTLN("Invalid reply address");
+ return false;
+ }
+
+ if (response[2] != addr_buf[0]) {
+ DEBUG_PRINTLN("Register mismatch");
+ return false;
+ }
+
+ uint8_t crc = calcCRC(response, 7);
+ if (crc != response[7]) {
+ DEBUG_PRINTLN("CRC mismatch");
+ return false;
+ }
+
+ memcpy(data, &response[3], 4);
+ return true;
+ }
+
+ static bool uart_writereg(void *thiz, uint8_t *addr_buf, uint8_t addrsiz,
+ const uint8_t *data, uint16_t datalen) {
+ TMC2209_UART *dev = (TMC2209_UART *)thiz;
+ while (dev->_uart_stream->available())
+ dev->_uart_stream->read();
+
+ uint8_t packet[8] = {0x05,
+ uint8_t(dev->_addr << 1),
+ uint8_t(addr_buf[0] | 0x80),
+ data[0],
+ data[1],
+ data[2],
+ data[3],
+ 0x00};
+
+ packet[7] = calcCRC(packet, 7);
+ if (!uart_write(thiz, packet, 8))
+ return false;
+
+ uint8_t echo[8];
+ if (!uart_read(thiz, echo, 8))
+ return false;
+
+ for (uint8_t i = 0; i < 8; i++) {
+ if (echo[i] != packet[i]) {
+ DEBUG_PRINTLN("Write echo mismatch");
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ static uint8_t calcCRC(uint8_t *data, uint8_t length) {
+ uint8_t crc = 0;
+ for (uint8_t i = 0; i < length; i++) {
+ uint8_t currentByte = data[i];
+ for (uint8_t j = 0; j < 8; j++) {
+ if ((crc >> 7) ^ (currentByte & 0x01)) {
+ crc = (crc << 1) ^ 0x07;
+ } else {
+ crc = crc << 1;
+ }
+ currentByte = currentByte >> 1;
+ }
+ }
+ return crc;
+ }
+
+public:
+ TMC2209_UART(Stream *serial, uint8_t addr)
+ : _uart_stream(serial), _addr(addr) {}
+
+ Adafruit_GenericDevice *createDevice() {
+ return new Adafruit_GenericDevice(this, uart_read, uart_write, uart_readreg,
+ uart_writereg);
+ }
+};
+
+void setup() {
+ Serial.begin(115200);
+ while (!Serial)
+ ;
+ delay(100);
+ Serial.println("TMC2209 Generic Device register read/write test!");
+
+ Serial1.begin(115200);
+
+ TMC2209_UART uart(&Serial1, 0);
+ Adafruit_GenericDevice *device = uart.createDevice();
+ device->begin();
+
+ // Create register object for IOIN
+ Adafruit_BusIO_Register ioin_reg(device,
+ TMC2209_IOIN, // device and register address
+ 4, // width = 4 bytes
+ MSBFIRST, // byte order
+ 1); // address width = 1 byte
+ Serial.print("IOIN = 0x");
+ Serial.println(ioin_reg.read(), HEX);
+
+ // Create RegisterBits for VERSION field (bits 31:24)
+ Adafruit_BusIO_RegisterBits version_bits(
+ &ioin_reg, 8, 24); // 8 bits wide, starting at bit 24
+
+ Serial.println("Reading VERSION...");
+ uint8_t version = version_bits.read();
+
+ Serial.print("VERSION = 0x");
+ Serial.println(version, HEX);
+}
+
+void loop() { delay(1000); }
\ No newline at end of file diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/.uno.test.skip b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/.uno.test.skip new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/.uno.test.skip diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/genericdevice_uarttest.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/genericdevice_uarttest.ino new file mode 100644 index 0000000..6a11dbf --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/genericdevice_uarttest.ino @@ -0,0 +1,98 @@ +/*
+ Abstracted transport for reading and writing data from a UART-based
+ device such as a TMC2209
+
+ Written with help by Claude!
+ https://claude.ai/chat/335f50b1-3dd8-435e-9139-57ec7ca26a3c (at this time
+ chats are not shareable :(
+*/
+
+#include "Adafruit_GenericDevice.h"
+
+/**
+ * Basic UART device class that demonstrates using GenericDevice with a Stream
+ * interface. This example shows how to wrap a Stream (like HardwareSerial or
+ * SoftwareSerial) with read/write callbacks that can be used by BusIO's
+ * register functions.
+ */
+class UARTDevice {
+public:
+ UARTDevice(Stream *serial) : _serial(serial) {}
+
+ // Static callback for writing data to UART
+ // Called by GenericDevice when data needs to be sent
+ static bool uart_write(void *thiz, const uint8_t *buffer, size_t len) {
+ UARTDevice *dev = (UARTDevice *)thiz;
+ dev->_serial->write(buffer, len);
+ return true;
+ }
+
+ // Static callback for reading data from UART
+ // Includes timeout and will return false if not enough data available
+ static bool uart_read(void *thiz, uint8_t *buffer, size_t len) {
+ UARTDevice *dev = (UARTDevice *)thiz;
+ uint16_t timeout = 100;
+ while (dev->_serial->available() < len && timeout--) {
+ delay(1);
+ }
+ if (timeout == 0) {
+ return false;
+ }
+ for (size_t i = 0; i < len; i++) {
+ buffer[i] = dev->_serial->read();
+ }
+ return true;
+ }
+
+ // Create a GenericDevice instance using our callbacks
+ Adafruit_GenericDevice *createDevice() {
+ return new Adafruit_GenericDevice(this, uart_read, uart_write);
+ }
+
+private:
+ Stream *_serial; // Underlying Stream instance (HardwareSerial, etc)
+};
+
+void setup() {
+ Serial.begin(115200);
+ while (!Serial)
+ ;
+ delay(100);
+
+ Serial.println("Generic Device test!");
+
+ // Initialize UART for device communication
+ Serial1.begin(115200);
+
+ // Create UART wrapper and BusIO device
+ UARTDevice uart(&Serial1);
+ Adafruit_GenericDevice *device = uart.createDevice();
+ device->begin();
+
+ // Test write/read cycle
+ uint8_t write_buf[4] = {0x5, 0x0, 0x0, 0x48};
+ uint8_t read_buf[8];
+
+ Serial.println("Writing data...");
+ if (!device->write(write_buf, 4)) {
+ Serial.println("Write failed!");
+ return;
+ }
+
+ Serial.println("Reading response...");
+ if (!device->read(read_buf, 8)) {
+ Serial.println("Read failed!");
+ return;
+ }
+
+ // Print response bytes
+ Serial.print("Got response: ");
+ for (int i = 0; i < 8; i++) {
+ Serial.print("0x");
+ Serial.print(read_buf[i], HEX);
+ Serial.print(" ");
+ }
+ Serial.println();
+}
+
+void loop() { delay(1000); }
\ No newline at end of file diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_address_detect/i2c_address_detect.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_address_detect/i2c_address_detect.ino new file mode 100644 index 0000000..f2e6ba7 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_address_detect/i2c_address_detect.ino @@ -0,0 +1,22 @@ +#include <Adafruit_I2CDevice.h> + +Adafruit_I2CDevice i2c_dev = Adafruit_I2CDevice(0x10); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("I2C address detection test"); + + if (!i2c_dev.begin()) { + Serial.print("Did not find device at 0x"); + Serial.println(i2c_dev.address(), HEX); + while (1) + ; + } + Serial.print("Device found on address 0x"); + Serial.println(i2c_dev.address(), HEX); +} + +void loop() {} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_readwrite/i2c_readwrite.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_readwrite/i2c_readwrite.ino new file mode 100644 index 0000000..4ac2626 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_readwrite/i2c_readwrite.ino @@ -0,0 +1,45 @@ +#include <Adafruit_I2CDevice.h> + +#define I2C_ADDRESS 0x60 +Adafruit_I2CDevice i2c_dev = Adafruit_I2CDevice(I2C_ADDRESS); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("I2C device read and write test"); + + if (!i2c_dev.begin()) { + Serial.print("Did not find device at 0x"); + Serial.println(i2c_dev.address(), HEX); + while (1) + ; + } + Serial.print("Device found on address 0x"); + Serial.println(i2c_dev.address(), HEX); + + uint8_t buffer[32]; + // Try to read 32 bytes + i2c_dev.read(buffer, 32); + Serial.print("Read: "); + for (uint8_t i = 0; i < 32; i++) { + Serial.print("0x"); + Serial.print(buffer[i], HEX); + Serial.print(", "); + } + Serial.println(); + + // read a register by writing first, then reading + buffer[0] = 0x0C; // we'll reuse the same buffer + i2c_dev.write_then_read(buffer, 1, buffer, 2, false); + Serial.print("Write then Read: "); + for (uint8_t i = 0; i < 2; i++) { + Serial.print("0x"); + Serial.print(buffer[i], HEX); + Serial.print(", "); + } + Serial.println(); +} + +void loop() {} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_registers/i2c_registers.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_registers/i2c_registers.ino new file mode 100644 index 0000000..2d44c83 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_registers/i2c_registers.ino @@ -0,0 +1,43 @@ +#include <Adafruit_BusIO_Register.h> +#include <Adafruit_I2CDevice.h> + +#define I2C_ADDRESS 0x60 +Adafruit_I2CDevice i2c_dev = Adafruit_I2CDevice(I2C_ADDRESS); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("I2C device register test"); + + if (!i2c_dev.begin()) { + Serial.print("Did not find device at 0x"); + Serial.println(i2c_dev.address(), HEX); + while (1) + ; + } + Serial.print("Device found on address 0x"); + Serial.println(i2c_dev.address(), HEX); + + Adafruit_BusIO_Register id_reg = + Adafruit_BusIO_Register(&i2c_dev, 0x0C, 2, LSBFIRST); + uint16_t id; + id_reg.read(&id); + Serial.print("ID register = 0x"); + Serial.println(id, HEX); + + Adafruit_BusIO_Register thresh_reg = + Adafruit_BusIO_Register(&i2c_dev, 0x01, 2, LSBFIRST); + uint16_t thresh; + thresh_reg.read(&thresh); + Serial.print("Initial threshold register = 0x"); + Serial.println(thresh, HEX); + + thresh_reg.write(~thresh); + + Serial.print("Post threshold register = 0x"); + Serial.println(thresh_reg.read(), HEX); +} + +void loop() {}
\ No newline at end of file diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2corspi_register/i2corspi_register.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2corspi_register/i2corspi_register.ino new file mode 100644 index 0000000..be04606 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2corspi_register/i2corspi_register.ino @@ -0,0 +1,40 @@ +#include <Adafruit_BusIO_Register.h> + +// Define which interface to use by setting the unused interface to NULL! + +#define SPIDEVICE_CS 10 +Adafruit_SPIDevice *spi_dev = NULL; // new Adafruit_SPIDevice(SPIDEVICE_CS); + +#define I2C_ADDRESS 0x5D +Adafruit_I2CDevice *i2c_dev = new Adafruit_I2CDevice(I2C_ADDRESS); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("I2C or SPI device register test"); + + if (spi_dev && !spi_dev->begin()) { + Serial.println("Could not initialize SPI device"); + } + + if (i2c_dev) { + if (i2c_dev->begin()) { + Serial.print("Device found on I2C address 0x"); + Serial.println(i2c_dev->address(), HEX); + } else { + Serial.print("Did not find I2C device at 0x"); + Serial.println(i2c_dev->address(), HEX); + } + } + + Adafruit_BusIO_Register id_reg = + Adafruit_BusIO_Register(i2c_dev, spi_dev, ADDRBIT8_HIGH_TOREAD, 0x0F); + uint8_t id = 0; + id_reg.read(&id); + Serial.print("ID register = 0x"); + Serial.println(id, HEX); +} + +void loop() {} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_modetest/spi_modetest.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_modetest/spi_modetest.ino new file mode 100644 index 0000000..ebf14f9 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_modetest/spi_modetest.ino @@ -0,0 +1,35 @@ +#include <Adafruit_SPIDevice.h> + +#define SPIDEVICE_CS 10 +Adafruit_SPIDevice spi_dev = + Adafruit_SPIDevice(SPIDEVICE_CS, 100000, SPI_BITORDER_MSBFIRST, SPI_MODE1); +// Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS, 13, 12, 11, +// 100000, SPI_BITORDER_MSBFIRST, SPI_MODE1); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("SPI device mode test"); + + if (!spi_dev.begin()) { + Serial.println("Could not initialize SPI device"); + while (1) + ; + } +} + +void loop() { + Serial.println("\n\nTransfer test"); + for (uint16_t x = 0; x <= 0xFF; x++) { + uint8_t i = x; + Serial.print("0x"); + Serial.print(i, HEX); + spi_dev.read(&i, 1, i); + Serial.print("/"); + Serial.print(i, HEX); + Serial.print(", "); + delay(25); + } +}
\ No newline at end of file diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_readwrite/spi_readwrite.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_readwrite/spi_readwrite.ino new file mode 100644 index 0000000..4b9ecf1 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_readwrite/spi_readwrite.ino @@ -0,0 +1,43 @@ +#include <Adafruit_SPIDevice.h> + +#define SPIDEVICE_CS 10 +Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("SPI device read and write test"); + + if (!spi_dev.begin()) { + Serial.println("Could not initialize SPI device"); + while (1) + ; + } + + uint8_t buffer[32]; + + // Try to read 32 bytes + spi_dev.read(buffer, 32); + Serial.print("Read: "); + for (uint8_t i = 0; i < 32; i++) { + Serial.print("0x"); + Serial.print(buffer[i], HEX); + Serial.print(", "); + } + Serial.println(); + + // read a register by writing first, then reading + buffer[0] = 0x8F; // we'll reuse the same buffer + spi_dev.write_then_read(buffer, 1, buffer, 2, false); + Serial.print("Write then Read: "); + for (uint8_t i = 0; i < 2; i++) { + Serial.print("0x"); + Serial.print(buffer[i], HEX); + Serial.print(", "); + } + Serial.println(); +} + +void loop() {} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_register_bits/spi_register_bits.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_register_bits/spi_register_bits.ino new file mode 100644 index 0000000..d11b440 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_register_bits/spi_register_bits.ino @@ -0,0 +1,268 @@ +/*************************************************** + + This is an example for how to use Adafruit_BusIO_RegisterBits from + Adafruit_BusIO library. + + Designed specifically to work with the Adafruit RTD Sensor + ----> https://www.adafruit.com/products/3328 + uisng a MAX31865 RTD-to-Digital Converter + ----> https://datasheets.maximintegrated.com/en/ds/MAX31865.pdf + + This sensor uses SPI to communicate, 4 pins are required to + interface. + A fifth pin helps to detect when a new conversion is ready. + + Adafruit invests time and resources providing this open source code, + please support Adafruit and open-source hardware by purchasing + products from Adafruit! + + Example written (2020/3) by Andreas Hardtung/AnHard. + BSD license, all text above must be included in any redistribution + ****************************************************/ + +#include <Adafruit_BusIO_Register.h> +#include <Adafruit_SPIDevice.h> + +#define MAX31865_SPI_SPEED (5000000) +#define MAX31865_SPI_BITORDER (SPI_BITORDER_MSBFIRST) +#define MAX31865_SPI_MODE (SPI_MODE1) + +#define MAX31865_SPI_CS (10) +#define MAX31865_READY_PIN (2) + +Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice( + MAX31865_SPI_CS, MAX31865_SPI_SPEED, MAX31865_SPI_BITORDER, + MAX31865_SPI_MODE, &SPI); // Hardware SPI +// Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice( MAX31865_SPI_CS, 13, 12, 11, +// MAX31865_SPI_SPEED, MAX31865_SPI_BITORDER, MAX31865_SPI_MODE); // Software +// SPI + +// MAX31865 chip related +// ********************************************************************************************* +Adafruit_BusIO_Register config_reg = + Adafruit_BusIO_Register(&spi_dev, 0x00, ADDRBIT8_HIGH_TOWRITE, 1, MSBFIRST); +Adafruit_BusIO_RegisterBits bias_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 7); +Adafruit_BusIO_RegisterBits auto_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 6); +Adafruit_BusIO_RegisterBits oneS_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 5); +Adafruit_BusIO_RegisterBits wire_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 4); +Adafruit_BusIO_RegisterBits faultT_bits = + Adafruit_BusIO_RegisterBits(&config_reg, 2, 2); +Adafruit_BusIO_RegisterBits faultR_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 1); +Adafruit_BusIO_RegisterBits fi50hz_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 0); + +Adafruit_BusIO_Register rRatio_reg = + Adafruit_BusIO_Register(&spi_dev, 0x01, ADDRBIT8_HIGH_TOWRITE, 2, MSBFIRST); +Adafruit_BusIO_RegisterBits rRatio_bits = + Adafruit_BusIO_RegisterBits(&rRatio_reg, 15, 1); +Adafruit_BusIO_RegisterBits fault_bit = + Adafruit_BusIO_RegisterBits(&rRatio_reg, 1, 0); + +Adafruit_BusIO_Register maxRratio_reg = + Adafruit_BusIO_Register(&spi_dev, 0x03, ADDRBIT8_HIGH_TOWRITE, 2, MSBFIRST); +Adafruit_BusIO_RegisterBits maxRratio_bits = + Adafruit_BusIO_RegisterBits(&maxRratio_reg, 15, 1); + +Adafruit_BusIO_Register minRratio_reg = + Adafruit_BusIO_Register(&spi_dev, 0x05, ADDRBIT8_HIGH_TOWRITE, 2, MSBFIRST); +Adafruit_BusIO_RegisterBits minRratio_bits = + Adafruit_BusIO_RegisterBits(&minRratio_reg, 15, 1); + +Adafruit_BusIO_Register fault_reg = + Adafruit_BusIO_Register(&spi_dev, 0x07, ADDRBIT8_HIGH_TOWRITE, 1, MSBFIRST); +Adafruit_BusIO_RegisterBits range_high_fault_bit = + Adafruit_BusIO_RegisterBits(&fault_reg, 1, 7); +Adafruit_BusIO_RegisterBits range_low_fault_bit = + Adafruit_BusIO_RegisterBits(&fault_reg, 1, 6); +Adafruit_BusIO_RegisterBits refin_high_fault_bit = + Adafruit_BusIO_RegisterBits(&fault_reg, 1, 5); +Adafruit_BusIO_RegisterBits refin_low_fault_bit = + Adafruit_BusIO_RegisterBits(&fault_reg, 1, 4); +Adafruit_BusIO_RegisterBits rtdin_low_fault_bit = + Adafruit_BusIO_RegisterBits(&fault_reg, 1, 3); +Adafruit_BusIO_RegisterBits voltage_fault_bit = + Adafruit_BusIO_RegisterBits(&fault_reg, 1, 2); + +// Print the details of the configuration register. +void printConfig(void) { + Serial.print("BIAS: "); + if (bias_bit.read()) + Serial.print("ON"); + else + Serial.print("OFF"); + Serial.print(", AUTO: "); + if (auto_bit.read()) + Serial.print("ON"); + else + Serial.print("OFF"); + Serial.print(", ONES: "); + if (oneS_bit.read()) + Serial.print("ON"); + else + Serial.print("OFF"); + Serial.print(", WIRE: "); + if (wire_bit.read()) + Serial.print("3"); + else + Serial.print("2/4"); + Serial.print(", FAULTCLEAR: "); + if (faultR_bit.read()) + Serial.print("ON"); + else + Serial.print("OFF"); + Serial.print(", "); + if (fi50hz_bit.read()) + Serial.print("50HZ"); + else + Serial.print("60HZ"); + Serial.println(); +} + +// Check and print faults. Then clear them. +void checkFaults(void) { + if (fault_bit.read()) { + Serial.print("MAX: "); + Serial.println(maxRratio_bits.read()); + Serial.print("VAL: "); + Serial.println(rRatio_bits.read()); + Serial.print("MIN: "); + Serial.println(minRratio_bits.read()); + + if (range_high_fault_bit.read()) + Serial.println("Range high fault"); + if (range_low_fault_bit.read()) + Serial.println("Range low fault"); + if (refin_high_fault_bit.read()) + Serial.println("REFIN high fault"); + if (refin_low_fault_bit.read()) + Serial.println("REFIN low fault"); + if (rtdin_low_fault_bit.read()) + Serial.println("RTDIN low fault"); + if (voltage_fault_bit.read()) + Serial.println("Voltage fault"); + + faultR_bit.write(1); // clear fault + } +} + +void setup() { +#if (MAX31865_1_READY_PIN != -1) + pinMode(MAX31865_READY_PIN, INPUT_PULLUP); +#endif + + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("SPI Adafruit_BusIO_RegisterBits test on MAX31865"); + + if (!spi_dev.begin()) { + Serial.println("Could not initialize SPI device"); + while (1) + ; + } + + // Set up for automode 50Hz. We don't care about selfheating. We want the + // highest possible sampling rate. + auto_bit.write(0); // Don't switch filtermode while auto_mode is on. + fi50hz_bit.write(1); // Set filter to 50Hz mode. + faultR_bit.write(1); // Clear faults. + bias_bit.write(1); // In automode we want to have the bias current always on. + delay(5); // Wait until bias current settles down. + // 10.5 time constants of the input RC network is required. + // 10ms worst case for 10kω reference resistor and a 0.1µF capacitor + // across the RTD inputs. Adafruit Module has 0.1µF and only + // 430/4300ω So here 0.43/4.3ms + auto_bit.write( + 1); // Now we can set automode. Automatically starting first conversion. + +// Test the READY_PIN +#if (defined(MAX31865_READY_PIN) && (MAX31865_READY_PIN != -1)) + int i = 0; + while (digitalRead(MAX31865_READY_PIN) && i++ <= 100) { + delay(1); + } + if (i >= 100) { + Serial.print("ERROR: Max31865 Pin detection does not work. PIN:"); + Serial.println(MAX31865_READY_PIN); + } +#else + delay(100); +#endif + + // Set ratio range. + // Setting the temperatures would need some more calculation - not related to + // Adafruit_BusIO_RegisterBits. + uint16_t ratio = rRatio_bits.read(); + maxRratio_bits.write((ratio < 0x8fffu - 1000u) ? ratio + 1000u : 0x8fffu); + minRratio_bits.write((ratio > 1000u) ? ratio - 1000u : 0u); + + printConfig(); + checkFaults(); +} + +void loop() { +#if (defined(MAX31865_READY_PIN) && (MAX31865_1_READY_PIN != -1)) + // Is conversion ready? + if (!digitalRead(MAX31865_READY_PIN)) +#else + // Warant conversion is ready. + delay(21); // 21ms for 50Hz-mode. 19ms in 60Hz-mode. +#endif + { + // Read ratio, calculate temperature, scale, filter and print. + Serial.println(rRatio2C(rRatio_bits.read()) * 100.0f, + 0); // Temperature scaled by 100 + // Check, print, clear faults. + checkFaults(); + } + + // Do something else. + // delay(15000); +} + +// Module/Sensor related. Here Adafruit PT100 module with a 2_Wire PT100 Class C +// ***************************** +float rRatio2C(uint16_t ratio) { + // A simple linear conversion. + const float R0 = 100.0f; + const float Rref = 430.0f; + const float alphaPT = 0.003850f; + const float ADCmax = (1u << 15) - 1.0f; + const float rscale = Rref / ADCmax; + // Measured temperature in boiling water 101.08°C with factor a = 1 and b = 0. + // Rref and MAX at about 22±2°C. Measured temperature in ice/water bath 0.76°C + // with factor a = 1 and b = 0. Rref and MAX at about 22±2°C. + // const float a = 1.0f / (alphaPT * R0); + const float a = (100.0f / 101.08f) / (alphaPT * R0); + // const float b = 0.0f; // 101.08 + const float b = -0.76f; // 100.32 > 101.08 + + return filterRing(((ratio * rscale) - R0) * a + b); +} + +// General purpose +// ********************************************************************************************* +#define RINGLENGTH 250 +float filterRing(float newVal) { + static float ring[RINGLENGTH] = {0.0}; + static uint8_t ringIndex = 0; + static bool ringFull = false; + + if (ringIndex == RINGLENGTH) { + ringFull = true; + ringIndex = 0; + } + ring[ringIndex] = newVal; + uint8_t loopEnd = (ringFull) ? RINGLENGTH : ringIndex + 1; + float ringSum = 0.0f; + for (uint8_t i = 0; i < loopEnd; i++) + ringSum += ring[i]; + ringIndex++; + return ringSum / loopEnd; +} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_registers/spi_registers.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_registers/spi_registers.ino new file mode 100644 index 0000000..af6069b --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_registers/spi_registers.ino @@ -0,0 +1,40 @@ +#include <Adafruit_BusIO_Register.h> +#include <Adafruit_SPIDevice.h> + +#define SPIDEVICE_CS 10 +Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("SPI device register test"); + + if (!spi_dev.begin()) { + Serial.println("Could not initialize SPI device"); + while (1) + ; + } + + Adafruit_BusIO_Register id_reg = + Adafruit_BusIO_Register(&spi_dev, 0x0F, ADDRBIT8_HIGH_TOREAD); + uint8_t id = 0; + id_reg.read(&id); + Serial.print("ID register = 0x"); + Serial.println(id, HEX); + + Adafruit_BusIO_Register thresh_reg = Adafruit_BusIO_Register( + &spi_dev, 0x0C, ADDRBIT8_HIGH_TOREAD, 2, LSBFIRST); + uint16_t thresh = 0; + thresh_reg.read(&thresh); + Serial.print("Initial threshold register = 0x"); + Serial.println(thresh, HEX); + + thresh_reg.write(~thresh); + + Serial.print("Post threshold register = 0x"); + Serial.println(thresh_reg.read(), HEX); +} + +void loop() {} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/library.properties b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/library.properties new file mode 100644 index 0000000..1615468 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/library.properties @@ -0,0 +1,9 @@ +name=Adafruit BusIO +version=1.17.4 +author=Adafruit +maintainer=Adafruit <info@adafruit.com> +sentence=This is a library for abstracting away UART, I2C and SPI interfacing +paragraph=This is a library for abstracting away UART, I2C and SPI interfacing +category=Signal Input/Output +url=https://github.com/adafruit/Adafruit_BusIO +architectures=* |