mirror of
https://github.com/espressif/arduino-esp32
synced 2024-09-21 02:18:29 +00:00
refactor(style): Change some style options (#9526)
* refactor(style): Change some style options * refactor(style): Apply style changes
This commit is contained in:
parent
8cab8c9b31
commit
6bfcd6d9a9
188
.clang-format
188
.clang-format
@ -1,37 +1,69 @@
|
||||
# Source: https://github.com/arduino/tooling-project-assets/tree/main/other/clang-format-configuration
|
||||
# Clang format version: 18.1.3
|
||||
---
|
||||
BasedOnStyle: LLVM
|
||||
AccessModifierOffset: -2
|
||||
AlignAfterOpenBracket: Align
|
||||
AlignAfterOpenBracket: BlockIndent
|
||||
AlignArrayOfStructures: None
|
||||
AlignConsecutiveAssignments: None
|
||||
AlignConsecutiveBitFields: None
|
||||
AlignConsecutiveDeclarations: None
|
||||
AlignConsecutiveMacros: None
|
||||
AlignEscapedNewlines: DontAlign
|
||||
AlignConsecutiveAssignments:
|
||||
Enabled: false
|
||||
AcrossEmptyLines: false
|
||||
AcrossComments: false
|
||||
AlignCompound: false
|
||||
AlignFunctionPointers: false
|
||||
PadOperators: true
|
||||
AlignConsecutiveBitFields:
|
||||
Enabled: true
|
||||
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: true
|
||||
AcrossEmptyLines: false
|
||||
AcrossComments: false
|
||||
AlignCompound: false
|
||||
AlignFunctionPointers: false
|
||||
PadOperators: false
|
||||
AlignConsecutiveShortCaseStatements:
|
||||
Enabled: true
|
||||
AcrossEmptyLines: false
|
||||
AcrossComments: false
|
||||
AlignCaseColons: false
|
||||
AlignEscapedNewlines: Left
|
||||
AlignOperands: Align
|
||||
AlignTrailingComments: true
|
||||
AlignTrailingComments:
|
||||
Kind: Always
|
||||
OverEmptyLines: 0
|
||||
AllowAllArgumentsOnNextLine: true
|
||||
AllowAllConstructorInitializersOnNextLine: true
|
||||
AllowAllParametersOfDeclarationOnNextLine: true
|
||||
AllowShortBlocksOnASingleLine: Always
|
||||
AllowBreakBeforeNoexceptSpecifier: Never
|
||||
AllowShortBlocksOnASingleLine: Empty
|
||||
AllowShortCaseLabelsOnASingleLine: true
|
||||
AllowShortEnumsOnASingleLine: true
|
||||
AllowShortCompoundRequirementOnASingleLine: true
|
||||
AllowShortEnumsOnASingleLine: false
|
||||
AllowShortFunctionsOnASingleLine: Empty
|
||||
AllowShortIfStatementsOnASingleLine: AllIfsAndElse
|
||||
AllowShortIfStatementsOnASingleLine: Never
|
||||
AllowShortLambdasOnASingleLine: Empty
|
||||
AllowShortLoopsOnASingleLine: true
|
||||
AlwaysBreakAfterDefinitionReturnType: None
|
||||
AlwaysBreakAfterReturnType: None
|
||||
AlwaysBreakBeforeMultilineStrings: false
|
||||
AlwaysBreakTemplateDeclarations: No
|
||||
AlwaysBreakTemplateDeclarations: MultiLine
|
||||
AttributeMacros:
|
||||
- __capability
|
||||
BasedOnStyle: LLVM
|
||||
BinPackArguments: true
|
||||
BinPackParameters: true
|
||||
BitFieldColonSpacing: Both
|
||||
BraceWrapping:
|
||||
AfterCaseLabel: false
|
||||
AfterCaseLabel: true
|
||||
AfterClass: false
|
||||
AfterControlStatement: Never
|
||||
AfterEnum: false
|
||||
@ -46,33 +78,33 @@ BraceWrapping:
|
||||
BeforeLambdaBody: false
|
||||
BeforeWhile: false
|
||||
IndentBraces: false
|
||||
SplitEmptyFunction: true
|
||||
SplitEmptyFunction: false
|
||||
SplitEmptyRecord: true
|
||||
SplitEmptyNamespace: true
|
||||
BreakAdjacentStringLiterals: true
|
||||
BreakAfterAttributes: Always
|
||||
BreakAfterJavaFieldAnnotations: false
|
||||
BreakArrays: false
|
||||
BreakBeforeBinaryOperators: NonAssignment
|
||||
BreakBeforeBraces: Attach
|
||||
BreakBeforeConceptDeclarations: false
|
||||
BreakBeforeInheritanceComma: false
|
||||
BreakBeforeBraces: Custom
|
||||
BreakBeforeConceptDeclarations: Always
|
||||
BreakBeforeInlineASMColon: OnlyMultiline
|
||||
BreakBeforeTernaryOperators: true
|
||||
BreakConstructorInitializers: BeforeColon
|
||||
BreakConstructorInitializersBeforeComma: false
|
||||
BreakInheritanceList: BeforeColon
|
||||
BreakStringLiterals: false
|
||||
ColumnLimit: 0
|
||||
CommentPragmas: ''
|
||||
BreakStringLiterals: true
|
||||
ColumnLimit: 160
|
||||
CommentPragmas: ""
|
||||
CompactNamespaces: false
|
||||
ConstructorInitializerAllOnOneLineOrOnePerLine: false
|
||||
ConstructorInitializerIndentWidth: 2
|
||||
ContinuationIndentWidth: 2
|
||||
Cpp11BracedListStyle: false
|
||||
DeriveLineEnding: true
|
||||
DerivePointerAlignment: true
|
||||
Cpp11BracedListStyle: true
|
||||
DerivePointerAlignment: false
|
||||
DisableFormat: false
|
||||
EmptyLineAfterAccessModifier: Leave
|
||||
EmptyLineBeforeAccessModifier: Leave
|
||||
EmptyLineAfterAccessModifier: Never
|
||||
EmptyLineBeforeAccessModifier: LogicalBlock
|
||||
ExperimentalAutoDetectBinPacking: false
|
||||
FixNamespaceComments: false
|
||||
FixNamespaceComments: true
|
||||
ForEachMacros:
|
||||
- foreach
|
||||
- Q_FOREACH
|
||||
@ -81,38 +113,49 @@ IfMacros:
|
||||
- KJ_IF_MAYBE
|
||||
IncludeBlocks: Preserve
|
||||
IncludeCategories:
|
||||
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
|
||||
- Regex: ^"(llvm|llvm-c|clang|clang-c)/
|
||||
Priority: 2
|
||||
SortPriority: 0
|
||||
CaseSensitive: false
|
||||
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
|
||||
- Regex: ^(<|"(gtest|gmock|isl|json)/)
|
||||
Priority: 3
|
||||
SortPriority: 0
|
||||
CaseSensitive: false
|
||||
- Regex: '.*'
|
||||
- Regex: .*
|
||||
Priority: 1
|
||||
SortPriority: 0
|
||||
CaseSensitive: false
|
||||
IncludeIsMainRegex: ''
|
||||
IncludeIsMainSourceRegex: ''
|
||||
IncludeIsMainRegex: ""
|
||||
IncludeIsMainSourceRegex: ""
|
||||
IndentAccessModifiers: false
|
||||
IndentCaseBlocks: true
|
||||
IndentCaseBlocks: false
|
||||
IndentCaseLabels: true
|
||||
IndentExternBlock: Indent
|
||||
IndentExternBlock: NoIndent
|
||||
IndentGotoLabels: false
|
||||
IndentPPDirectives: None
|
||||
IndentRequires: true
|
||||
IndentRequiresClause: false
|
||||
IndentWidth: 2
|
||||
IndentWrappedFunctionNames: false
|
||||
IndentWrappedFunctionNames: true
|
||||
InsertBraces: true
|
||||
InsertNewlineAtEOF: true
|
||||
InsertTrailingCommas: None
|
||||
IntegerLiteralSeparator:
|
||||
Binary: 0
|
||||
BinaryMinDigits: 0
|
||||
Decimal: 0
|
||||
DecimalMinDigits: 0
|
||||
Hex: 0
|
||||
HexMinDigits: 0
|
||||
JavaScriptQuotes: Leave
|
||||
JavaScriptWrapImports: true
|
||||
KeepEmptyLinesAtEOF: false
|
||||
KeepEmptyLinesAtTheStartOfBlocks: true
|
||||
LambdaBodyIndentation: Signature
|
||||
Language: Cpp
|
||||
MacroBlockBegin: ''
|
||||
MacroBlockEnd: ''
|
||||
MaxEmptyLinesToKeep: 100000
|
||||
LineEnding: LF
|
||||
MacroBlockBegin: ""
|
||||
MacroBlockEnd: ""
|
||||
MaxEmptyLinesToKeep: 1
|
||||
NamespaceIndentation: None
|
||||
ObjCBinPackProtocolList: Auto
|
||||
ObjCBlockIndentWidth: 2
|
||||
@ -121,26 +164,32 @@ ObjCSpaceAfterProperty: false
|
||||
ObjCSpaceBeforeProtocolList: true
|
||||
PPIndentWidth: -1
|
||||
PackConstructorInitializers: BinPack
|
||||
PenaltyBreakAssignment: 1
|
||||
PenaltyBreakBeforeFirstCallParameter: 1
|
||||
PenaltyBreakComment: 1
|
||||
PenaltyBreakFirstLessLess: 1
|
||||
PenaltyBreakOpenParenthesis: 1
|
||||
PenaltyBreakString: 1
|
||||
PenaltyBreakTemplateDeclaration: 1
|
||||
PenaltyExcessCharacter: 1
|
||||
PenaltyIndentedWhitespace: 1
|
||||
PenaltyReturnTypeOnItsOwnLine: 1
|
||||
PenaltyBreakAssignment: 2
|
||||
PenaltyBreakBeforeFirstCallParameter: 19
|
||||
PenaltyBreakComment: 300
|
||||
PenaltyBreakFirstLessLess: 120
|
||||
PenaltyBreakOpenParenthesis: 0
|
||||
PenaltyBreakScopeResolution: 500
|
||||
PenaltyBreakString: 1000
|
||||
PenaltyBreakTemplateDeclaration: 10
|
||||
PenaltyExcessCharacter: 1000000
|
||||
PenaltyIndentedWhitespace: 0
|
||||
PenaltyReturnTypeOnItsOwnLine: 60
|
||||
PointerAlignment: Right
|
||||
QualifierAlignment: Leave
|
||||
ReferenceAlignment: Pointer
|
||||
ReflowComments: false
|
||||
RemoveBracesLLVM: false
|
||||
RemoveParentheses: Leave
|
||||
RemoveSemicolon: false
|
||||
RequiresClausePosition: OwnLine
|
||||
RequiresExpressionIndentation: OuterScope
|
||||
SeparateDefinitionBlocks: Leave
|
||||
ShortNamespaceLines: 0
|
||||
ShortNamespaceLines: 1
|
||||
SkipMacroDefinitionBody: false
|
||||
SortIncludes: Never
|
||||
SortJavaStaticImport: Before
|
||||
SortUsingDeclarations: false
|
||||
SortUsingDeclarations: LexicographicNumeric
|
||||
SpaceAfterCStyleCast: false
|
||||
SpaceAfterLogicalNot: false
|
||||
SpaceAfterTemplateKeyword: false
|
||||
@ -150,28 +199,34 @@ SpaceBeforeCaseColon: false
|
||||
SpaceBeforeCpp11BracedList: false
|
||||
SpaceBeforeCtorInitializerColon: true
|
||||
SpaceBeforeInheritanceColon: true
|
||||
SpaceBeforeJsonColon: false
|
||||
SpaceBeforeParens: ControlStatements
|
||||
SpaceBeforeParensOptions:
|
||||
AfterControlStatements: true
|
||||
AfterForeachMacros: true
|
||||
AfterFunctionDefinitionName: false
|
||||
AfterFunctionDeclarationName: false
|
||||
AfterFunctionDefinitionName: false
|
||||
AfterIfMacros: true
|
||||
AfterOverloadedOperator: false
|
||||
AfterOverloadedOperator: true
|
||||
AfterPlacementOperator: true
|
||||
AfterRequiresInClause: false
|
||||
AfterRequiresInExpression: false
|
||||
BeforeNonEmptyParentheses: false
|
||||
SpaceBeforeRangeBasedForLoopColon: true
|
||||
SpaceBeforeSquareBrackets: false
|
||||
SpaceInEmptyBlock: false
|
||||
SpaceInEmptyParentheses: false
|
||||
SpacesBeforeTrailingComments: 2
|
||||
SpacesInAngles: Leave
|
||||
SpacesInCStyleCastParentheses: false
|
||||
SpacesInConditionalStatement: false
|
||||
SpacesInAngles: Never
|
||||
SpacesInContainerLiterals: false
|
||||
SpacesInLineCommentPrefix:
|
||||
Minimum: 0
|
||||
Minimum: 1
|
||||
Maximum: -1
|
||||
SpacesInParentheses: false
|
||||
SpacesInParens: Never
|
||||
SpacesInParensOptions:
|
||||
InConditionalStatements: false
|
||||
InCStyleCasts: false
|
||||
InEmptyParentheses: false
|
||||
Other: false
|
||||
SpacesInSquareBrackets: false
|
||||
Standard: Auto
|
||||
StatementAttributeLikeMacros:
|
||||
@ -180,11 +235,12 @@ StatementMacros:
|
||||
- Q_UNUSED
|
||||
- QT_REQUIRE_VERSION
|
||||
TabWidth: 2
|
||||
UseCRLF: false
|
||||
UseTab: Never
|
||||
VerilogBreakBetweenInstancePorts: true
|
||||
WhitespaceSensitiveMacros:
|
||||
- STRINGIZE
|
||||
- PP_STRINGIZE
|
||||
- BOOST_PP_STRINGIZE
|
||||
- NS_SWIFT_NAME
|
||||
- CF_SWIFT_NAME
|
||||
- NS_SWIFT_NAME
|
||||
- PP_STRINGIZE
|
||||
- STRINGIZE
|
||||
BracedInitializerIndentWidth: 2
|
||||
|
@ -26,7 +26,7 @@ repos:
|
||||
exclude: ^.*\.(svd|SVD)$
|
||||
stages: [manual]
|
||||
- repo: https://github.com/pre-commit/mirrors-clang-format
|
||||
rev: "v15.0.7"
|
||||
rev: "v18.1.3"
|
||||
hooks:
|
||||
- id: clang-format
|
||||
types_or: [c, c++]
|
||||
|
@ -41,29 +41,29 @@
|
||||
#include "binary.h"
|
||||
#include "extra_attr.h"
|
||||
|
||||
#define PI 3.1415926535897932384626433832795
|
||||
#define HALF_PI 1.5707963267948966192313216916398
|
||||
#define TWO_PI 6.283185307179586476925286766559
|
||||
#define PI 3.1415926535897932384626433832795
|
||||
#define HALF_PI 1.5707963267948966192313216916398
|
||||
#define TWO_PI 6.283185307179586476925286766559
|
||||
#define DEG_TO_RAD 0.017453292519943295769236907684886
|
||||
#define RAD_TO_DEG 57.295779513082320876798154814105
|
||||
#define EULER 2.718281828459045235360287471352
|
||||
#define EULER 2.718281828459045235360287471352
|
||||
|
||||
#define SERIAL 0x0
|
||||
#define SERIAL 0x0
|
||||
#define DISPLAY 0x1
|
||||
|
||||
#define LSBFIRST 0
|
||||
#define MSBFIRST 1
|
||||
|
||||
//Interrupt Modes
|
||||
#define RISING 0x01
|
||||
#define FALLING 0x02
|
||||
#define CHANGE 0x03
|
||||
#define ONLOW 0x04
|
||||
#define ONHIGH 0x05
|
||||
#define ONLOW_WE 0x0C
|
||||
#define RISING 0x01
|
||||
#define FALLING 0x02
|
||||
#define CHANGE 0x03
|
||||
#define ONLOW 0x04
|
||||
#define ONHIGH 0x05
|
||||
#define ONLOW_WE 0x0C
|
||||
#define ONHIGH_WE 0x0D
|
||||
|
||||
#define DEFAULT 1
|
||||
#define DEFAULT 1
|
||||
#define EXTERNAL 0
|
||||
|
||||
#ifndef __STRINGIFY
|
||||
@ -71,65 +71,67 @@
|
||||
#endif
|
||||
|
||||
// can't define max() / min() because of conflicts with C++
|
||||
#define _min(a, b) ((a) < (b) ? (a) : (b))
|
||||
#define _max(a, b) ((a) > (b) ? (a) : (b))
|
||||
#define _abs(x) ((x) > 0 ? (x) : -(x)) // abs() comes from STL
|
||||
#define _min(a, b) ((a) < (b) ? (a) : (b))
|
||||
#define _max(a, b) ((a) > (b) ? (a) : (b))
|
||||
#define _abs(x) ((x) > 0 ? (x) : -(x)) // abs() comes from STL
|
||||
#define constrain(amt, low, high) ((amt) < (low) ? (low) : ((amt) > (high) ? (high) : (amt)))
|
||||
#define _round(x) ((x) >= 0 ? (long)((x) + 0.5) : (long)((x)-0.5)) // round() comes from STL
|
||||
#define radians(deg) ((deg)*DEG_TO_RAD)
|
||||
#define degrees(rad) ((rad)*RAD_TO_DEG)
|
||||
#define sq(x) ((x) * (x))
|
||||
#define _round(x) ((x) >= 0 ? (long)((x) + 0.5) : (long)((x) - 0.5)) // round() comes from STL
|
||||
#define radians(deg) ((deg) * DEG_TO_RAD)
|
||||
#define degrees(rad) ((rad) * RAD_TO_DEG)
|
||||
#define sq(x) ((x) * (x))
|
||||
|
||||
// ESP32xx runs FreeRTOS... disabling interrupts can lead to issues, such as Watchdog Timeout
|
||||
#define sei() portENABLE_INTERRUPTS()
|
||||
#define cli() portDISABLE_INTERRUPTS()
|
||||
#define interrupts() sei()
|
||||
#define sei() portENABLE_INTERRUPTS()
|
||||
#define cli() portDISABLE_INTERRUPTS()
|
||||
#define interrupts() sei()
|
||||
#define noInterrupts() cli()
|
||||
|
||||
#define clockCyclesPerMicrosecond() ((long int)getCpuFrequencyMhz())
|
||||
#define clockCyclesPerMicrosecond() ((long int)getCpuFrequencyMhz())
|
||||
#define clockCyclesToMicroseconds(a) ((a) / clockCyclesPerMicrosecond())
|
||||
#define microsecondsToClockCycles(a) ((a)*clockCyclesPerMicrosecond())
|
||||
#define microsecondsToClockCycles(a) ((a) * clockCyclesPerMicrosecond())
|
||||
|
||||
#define lowByte(w) ((uint8_t)((w)&0xff))
|
||||
#define lowByte(w) ((uint8_t)((w) & 0xff))
|
||||
#define highByte(w) ((uint8_t)((w) >> 8))
|
||||
|
||||
#define bitRead(value, bit) (((value) >> (bit)) & 0x01)
|
||||
#define bitSet(value, bit) ((value) |= (1UL << (bit)))
|
||||
#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
|
||||
#define bitToggle(value, bit) ((value) ^= (1UL << (bit)))
|
||||
#define bitRead(value, bit) (((value) >> (bit)) & 0x01)
|
||||
#define bitSet(value, bit) ((value) |= (1UL << (bit)))
|
||||
#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
|
||||
#define bitToggle(value, bit) ((value) ^= (1UL << (bit)))
|
||||
#define bitWrite(value, bit, bitvalue) ((bitvalue) ? bitSet(value, bit) : bitClear(value, bit))
|
||||
|
||||
// avr-libc defines _NOP() since 1.6.2
|
||||
#ifndef _NOP
|
||||
#define _NOP() \
|
||||
do { __asm__ volatile("nop"); } while (0)
|
||||
#define _NOP() \
|
||||
do { \
|
||||
__asm__ volatile("nop"); \
|
||||
} while (0)
|
||||
#endif
|
||||
|
||||
#define bit(b) (1UL << (b))
|
||||
#define _BV(b) (1UL << (b))
|
||||
|
||||
#define digitalPinToTimer(pin) (0)
|
||||
#define analogInPinToBit(P) (P)
|
||||
#define analogInPinToBit(P) (P)
|
||||
#if SOC_GPIO_PIN_COUNT <= 32
|
||||
#define digitalPinToPort(pin) (0)
|
||||
#define digitalPinToPort(pin) (0)
|
||||
#define digitalPinToBitMask(pin) (1UL << digitalPinToGPIONumber(pin))
|
||||
#define portOutputRegister(port) ((volatile uint32_t*)GPIO_OUT_REG)
|
||||
#define portInputRegister(port) ((volatile uint32_t*)GPIO_IN_REG)
|
||||
#define portModeRegister(port) ((volatile uint32_t*)GPIO_ENABLE_REG)
|
||||
#define portOutputRegister(port) ((volatile uint32_t *)GPIO_OUT_REG)
|
||||
#define portInputRegister(port) ((volatile uint32_t *)GPIO_IN_REG)
|
||||
#define portModeRegister(port) ((volatile uint32_t *)GPIO_ENABLE_REG)
|
||||
#elif SOC_GPIO_PIN_COUNT <= 64
|
||||
#define digitalPinToPort(pin) ((digitalPinToGPIONumber(pin) > 31) ? 1 : 0)
|
||||
#define digitalPinToPort(pin) ((digitalPinToGPIONumber(pin) > 31) ? 1 : 0)
|
||||
#define digitalPinToBitMask(pin) (1UL << (digitalPinToGPIONumber(pin) & 31))
|
||||
#define portOutputRegister(port) ((volatile uint32_t*)((port) ? GPIO_OUT1_REG : GPIO_OUT_REG))
|
||||
#define portInputRegister(port) ((volatile uint32_t*)((port) ? GPIO_IN1_REG : GPIO_IN_REG))
|
||||
#define portModeRegister(port) ((volatile uint32_t*)((port) ? GPIO_ENABLE1_REG : GPIO_ENABLE_REG))
|
||||
#define portOutputRegister(port) ((volatile uint32_t *)((port) ? GPIO_OUT1_REG : GPIO_OUT_REG))
|
||||
#define portInputRegister(port) ((volatile uint32_t *)((port) ? GPIO_IN1_REG : GPIO_IN_REG))
|
||||
#define portModeRegister(port) ((volatile uint32_t *)((port) ? GPIO_ENABLE1_REG : GPIO_ENABLE_REG))
|
||||
#else
|
||||
#error SOC_GPIO_PIN_COUNT > 64 not implemented
|
||||
#endif
|
||||
|
||||
#define NOT_A_PIN -1
|
||||
#define NOT_A_PORT -1
|
||||
#define NOT_A_PIN -1
|
||||
#define NOT_A_PORT -1
|
||||
#define NOT_AN_INTERRUPT -1
|
||||
#define NOT_ON_TIMER 0
|
||||
#define NOT_ON_TIMER 0
|
||||
|
||||
// some defines generic for all SoC moved from variants/board_name/pins_arduino.h
|
||||
#define NUM_DIGITAL_PINS SOC_GPIO_PIN_COUNT // All GPIOs
|
||||
@ -138,10 +140,10 @@
|
||||
#elif SOC_ADC_PERIPH_NUM == 2
|
||||
#define NUM_ANALOG_INPUTS (SOC_ADC_CHANNEL_NUM(0) + SOC_ADC_CHANNEL_NUM(1)) // Depends on the SoC (ESP32, ESP32S2, ESP32S3, ESP32C3)
|
||||
#endif
|
||||
#define EXTERNAL_NUM_INTERRUPTS NUM_DIGITAL_PINS // All GPIOs
|
||||
#define EXTERNAL_NUM_INTERRUPTS NUM_DIGITAL_PINS // All GPIOs
|
||||
#define analogInputToDigitalPin(p) (((p) < NUM_ANALOG_INPUTS) ? (analogChannelToDigitalPin(p)) : -1)
|
||||
#define digitalPinToInterrupt(p) ((((uint8_t)digitalPinToGPIONumber(p)) < NUM_DIGITAL_PINS) ? digitalPinToGPIONumber(p) : NOT_AN_INTERRUPT)
|
||||
#define digitalPinHasPWM(p) (((uint8_t)digitalPinToGPIONumber(p)) < NUM_DIGITAL_PINS)
|
||||
#define digitalPinToInterrupt(p) ((((uint8_t)digitalPinToGPIONumber(p)) < NUM_DIGITAL_PINS) ? digitalPinToGPIONumber(p) : NOT_AN_INTERRUPT)
|
||||
#define digitalPinHasPWM(p) (((uint8_t)digitalPinToGPIONumber(p)) < NUM_DIGITAL_PINS)
|
||||
|
||||
typedef bool boolean;
|
||||
typedef uint8_t byte;
|
||||
@ -170,15 +172,15 @@ long map(long, long, long, long, long);
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void init(void);
|
||||
void initVariant(void);
|
||||
void initArduino(void);
|
||||
void init(void);
|
||||
void initVariant(void);
|
||||
void initArduino(void);
|
||||
|
||||
unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout);
|
||||
unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout);
|
||||
unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout);
|
||||
unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout);
|
||||
|
||||
uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder);
|
||||
void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val);
|
||||
uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder);
|
||||
void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
@ -212,29 +214,33 @@ uint16_t makeWord(uint8_t h, uint8_t l);
|
||||
#define word(...) makeWord(__VA_ARGS__)
|
||||
|
||||
size_t getArduinoLoopTaskStackSize(void);
|
||||
#define SET_LOOP_TASK_STACK_SIZE(sz) \
|
||||
size_t getArduinoLoopTaskStackSize() { return sz; }
|
||||
#define SET_LOOP_TASK_STACK_SIZE(sz) \
|
||||
size_t getArduinoLoopTaskStackSize() { \
|
||||
return sz; \
|
||||
}
|
||||
|
||||
bool shouldPrintChipDebugReport(void);
|
||||
#define ENABLE_CHIP_DEBUG_REPORT \
|
||||
bool shouldPrintChipDebugReport(void) { return true; }
|
||||
#define ENABLE_CHIP_DEBUG_REPORT \
|
||||
bool shouldPrintChipDebugReport(void) { \
|
||||
return true; \
|
||||
}
|
||||
|
||||
// allows user to bypass esp_spiram_test()
|
||||
bool esp_psram_extram_test(void);
|
||||
#define BYPASS_SPIRAM_TEST(bypass) \
|
||||
bool testSPIRAM(void) { \
|
||||
if (bypass) return true; \
|
||||
else return esp_psram_extram_test(); \
|
||||
#define BYPASS_SPIRAM_TEST(bypass) \
|
||||
bool testSPIRAM(void) { \
|
||||
if (bypass) \
|
||||
return true; \
|
||||
else \
|
||||
return esp_psram_extram_test(); \
|
||||
}
|
||||
|
||||
unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L);
|
||||
unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L);
|
||||
|
||||
extern "C" bool getLocalTime(struct tm* info, uint32_t ms = 5000);
|
||||
extern "C" void configTime(long gmtOffset_sec, int daylightOffset_sec,
|
||||
const char* server1, const char* server2 = nullptr, const char* server3 = nullptr);
|
||||
extern "C" void configTzTime(const char* tz,
|
||||
const char* server1, const char* server2 = nullptr, const char* server3 = nullptr);
|
||||
extern "C" bool getLocalTime(struct tm *info, uint32_t ms = 5000);
|
||||
extern "C" void configTime(long gmtOffset_sec, int daylightOffset_sec, const char *server1, const char *server2 = nullptr, const char *server3 = nullptr);
|
||||
extern "C" void configTzTime(const char *tz, const char *server1, const char *server2 = nullptr, const char *server3 = nullptr);
|
||||
|
||||
void setToneChannel(uint8_t channel = 0);
|
||||
void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0);
|
||||
|
@ -37,6 +37,7 @@ public:
|
||||
virtual void stop() = 0;
|
||||
virtual uint8_t connected() = 0;
|
||||
virtual operator bool() = 0;
|
||||
|
||||
protected:
|
||||
uint8_t *rawIPAddress(IPAddress &addr) {
|
||||
return addr.raw_address();
|
||||
|
@ -72,7 +72,7 @@ extern "C" {
|
||||
|
||||
#if CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C3
|
||||
#ifndef REG_SPI_BASE
|
||||
#define REG_SPI_BASE(i) (DR_REG_SPI1_BASE + (((i) > 1) ? (((i)*0x1000) + 0x20000) : (((~(i)) & 1) * 0x1000)))
|
||||
#define REG_SPI_BASE(i) (DR_REG_SPI1_BASE + (((i) > 1) ? (((i) * 0x1000) + 0x20000) : (((~(i)) & 1) * 0x1000)))
|
||||
#endif // REG_SPI_BASE
|
||||
#endif // TARGET
|
||||
|
||||
@ -119,7 +119,6 @@ unsigned long long operator"" _GB(unsigned long long x) {
|
||||
return x * 1024 * 1024 * 1024;
|
||||
}
|
||||
|
||||
|
||||
EspClass ESP;
|
||||
|
||||
void EspClass::deepSleep(uint64_t time_us) {
|
||||
@ -177,7 +176,9 @@ uint32_t EspClass::getMaxAllocPsram(void) {
|
||||
static uint32_t sketchSize(sketchSize_t response) {
|
||||
esp_image_metadata_t data;
|
||||
const esp_partition_t *running = esp_ota_get_running_partition();
|
||||
if (!running) return 0;
|
||||
if (!running) {
|
||||
return 0;
|
||||
}
|
||||
const esp_partition_pos_t running_pos = {
|
||||
.offset = running->address,
|
||||
.size = running->size,
|
||||
@ -260,39 +261,31 @@ const char *EspClass::getChipModel(void) {
|
||||
uint32_t pkg_ver = chip_ver & 0x7;
|
||||
switch (pkg_ver) {
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ6:
|
||||
if (getChipRevision() == 3)
|
||||
if (getChipRevision() == 3) {
|
||||
return "ESP32-D0WDQ6-V3";
|
||||
else
|
||||
} else {
|
||||
return "ESP32-D0WDQ6";
|
||||
}
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ5:
|
||||
if (getChipRevision() == 3)
|
||||
if (getChipRevision() == 3) {
|
||||
return "ESP32-D0WD-V3";
|
||||
else
|
||||
} else {
|
||||
return "ESP32-D0WD";
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D2WDQ5:
|
||||
return "ESP32-D2WD";
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD2:
|
||||
return "ESP32-PICO-D2";
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD4:
|
||||
return "ESP32-PICO-D4";
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32PICOV302:
|
||||
return "ESP32-PICO-V3-02";
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDR2V3:
|
||||
return "ESP32-D0WDR2-V3";
|
||||
default:
|
||||
return "Unknown";
|
||||
}
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D2WDQ5: return "ESP32-D2WD";
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD2: return "ESP32-PICO-D2";
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD4: return "ESP32-PICO-D4";
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32PICOV302: return "ESP32-PICO-V3-02";
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDR2V3: return "ESP32-D0WDR2-V3";
|
||||
default: return "Unknown";
|
||||
}
|
||||
#elif CONFIG_IDF_TARGET_ESP32S2
|
||||
uint32_t pkg_ver = REG_GET_FIELD(EFUSE_RD_MAC_SPI_SYS_3_REG, EFUSE_PKG_VERSION);
|
||||
switch (pkg_ver) {
|
||||
case 0:
|
||||
return "ESP32-S2";
|
||||
case 1:
|
||||
return "ESP32-S2FH16";
|
||||
case 2:
|
||||
return "ESP32-S2FH32";
|
||||
default:
|
||||
return "ESP32-S2 (Unknown)";
|
||||
case 0: return "ESP32-S2";
|
||||
case 1: return "ESP32-S2FH16";
|
||||
case 2: return "ESP32-S2FH32";
|
||||
default: return "ESP32-S2 (Unknown)";
|
||||
}
|
||||
#else
|
||||
esp_chip_info_t chip_info;
|
||||
@ -303,7 +296,7 @@ const char *EspClass::getChipModel(void) {
|
||||
case CHIP_ESP32C2: return "ESP32-C2";
|
||||
case CHIP_ESP32C6: return "ESP32-C6";
|
||||
case CHIP_ESP32H2: return "ESP32-H2";
|
||||
default: return "UNKNOWN";
|
||||
default: return "UNKNOWN";
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@ -414,7 +407,6 @@ uint32_t EspClass::magicFlashChipSpeed(uint8_t byte) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#elif CONFIG_IDF_TARGET_ESP32C6
|
||||
/*
|
||||
FLASH_FREQUENCY = {
|
||||
@ -449,7 +441,6 @@ uint32_t EspClass::magicFlashChipSpeed(uint8_t byte) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#else
|
||||
/*
|
||||
FLASH_FREQUENCY = {
|
||||
@ -470,7 +461,6 @@ uint32_t EspClass::magicFlashChipSpeed(uint8_t byte) {
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
FlashMode_t EspClass::magicFlashChipMode(uint8_t byte) {
|
||||
FlashMode_t mode = (FlashMode_t)byte;
|
||||
if (mode > FM_SLOW_READ) {
|
||||
|
@ -42,7 +42,6 @@ typedef enum {
|
||||
WDTO_8S = 8000 //!< WDTO_8S
|
||||
} WDTO_t;
|
||||
|
||||
|
||||
typedef enum {
|
||||
FM_QIO = 0x00,
|
||||
FM_QOUT = 0x01,
|
||||
|
@ -310,7 +310,8 @@ static int32_t msc_write(uint32_t lba, uint32_t offset, uint8_t *buffer, uint32_
|
||||
return 0;
|
||||
}
|
||||
} else if (msc_update_state == MSC_UPDATE_RUNNING) {
|
||||
if (msc_update_entry && msc_update_entry->file_size && msc_update_bytes_written < msc_update_entry->file_size && (msc_update_bytes_written + bufsize) >= msc_update_entry->file_size) {
|
||||
if (msc_update_entry && msc_update_entry->file_size && msc_update_bytes_written < msc_update_entry->file_size
|
||||
&& (msc_update_bytes_written + bufsize) >= msc_update_entry->file_size) {
|
||||
bufsize = msc_update_entry->file_size - msc_update_bytes_written;
|
||||
}
|
||||
if (msc_update_write(msc_ota_partition, ((lba - msc_update_start_sector) * DISK_SECTOR_SIZE) + offset, buffer, bufsize) == ESP_OK) {
|
||||
@ -369,8 +370,7 @@ static void msc_task(void *pvParameters) {
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
FirmwareMSC::FirmwareMSC()
|
||||
: msc() {}
|
||||
FirmwareMSC::FirmwareMSC() : msc() {}
|
||||
|
||||
FirmwareMSC::~FirmwareMSC() {
|
||||
end();
|
||||
|
@ -9,14 +9,14 @@
|
||||
#include "Arduino.h"
|
||||
|
||||
typedef void (*voidFuncPtr)(void);
|
||||
typedef void (*voidFuncPtrArg)(void*);
|
||||
typedef void (*voidFuncPtrArg)(void *);
|
||||
|
||||
extern "C" {
|
||||
extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc, void* arg, int intr_type, bool functional);
|
||||
extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc, void *arg, int intr_type, bool functional);
|
||||
}
|
||||
|
||||
void ARDUINO_ISR_ATTR interruptFunctional(void* arg) {
|
||||
InterruptArgStructure* localArg = (InterruptArgStructure*)arg;
|
||||
void ARDUINO_ISR_ATTR interruptFunctional(void *arg) {
|
||||
InterruptArgStructure *localArg = (InterruptArgStructure *)arg;
|
||||
if (localArg->interruptFunction) {
|
||||
localArg->interruptFunction();
|
||||
}
|
||||
@ -24,11 +24,11 @@ void ARDUINO_ISR_ATTR interruptFunctional(void* arg) {
|
||||
|
||||
void attachInterrupt(uint8_t pin, std::function<void(void)> intRoutine, int mode) {
|
||||
// use the local interrupt routine which takes the ArgStructure as argument
|
||||
__attachInterruptFunctionalArg(pin, (voidFuncPtrArg)interruptFunctional, new InterruptArgStructure{ intRoutine }, mode, true);
|
||||
__attachInterruptFunctionalArg(pin, (voidFuncPtrArg)interruptFunctional, new InterruptArgStructure{intRoutine}, mode, true);
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
void cleanupFunctional(void* arg) {
|
||||
delete (InterruptArgStructure*)arg;
|
||||
}
|
||||
void cleanupFunctional(void *arg) {
|
||||
delete (InterruptArgStructure *)arg;
|
||||
}
|
||||
}
|
||||
|
@ -21,9 +21,10 @@
|
||||
#include <HEXBuilder.h>
|
||||
|
||||
static uint8_t hex_char_to_byte(uint8_t c) {
|
||||
return (c >= 'a' && c <= 'f') ? (c - ((uint8_t)'a' - 0xa)) : (c >= 'A' && c <= 'F') ? (c - ((uint8_t)'A' - 0xA))
|
||||
: (c >= '0' && c <= '9') ? (c - (uint8_t)'0')
|
||||
: 0x10; // unknown char is 16
|
||||
return (c >= 'a' && c <= 'f') ? (c - ((uint8_t)'a' - 0xa))
|
||||
: (c >= 'A' && c <= 'F') ? (c - ((uint8_t)'A' - 0xA))
|
||||
: (c >= '0' && c <= '9') ? (c - (uint8_t)'0')
|
||||
: 0x10; // unknown char is 16
|
||||
}
|
||||
|
||||
size_t HEXBuilder::hex2bytes(unsigned char *out, size_t maxlen, String &in) {
|
||||
@ -35,15 +36,18 @@ size_t HEXBuilder::hex2bytes(unsigned char *out, size_t maxlen, const char *in)
|
||||
for (; *in; in++) {
|
||||
uint8_t c = hex_char_to_byte(*in);
|
||||
// Silently skip anything unknown.
|
||||
if (c > 15)
|
||||
if (c > 15) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (len & 1) {
|
||||
if (len / 2 < maxlen)
|
||||
if (len / 2 < maxlen) {
|
||||
out[len / 2] |= c;
|
||||
}
|
||||
} else {
|
||||
if (len / 2 < maxlen)
|
||||
if (len / 2 < maxlen) {
|
||||
out[len / 2] = c << 4;
|
||||
}
|
||||
}
|
||||
len++;
|
||||
}
|
||||
@ -62,7 +66,9 @@ size_t HEXBuilder::bytes2hex(char *out, size_t maxlen, const unsigned char *in,
|
||||
String HEXBuilder::bytes2hex(const unsigned char *in, size_t len) {
|
||||
size_t maxlen = len * 2 + 1;
|
||||
char *out = (char *)malloc(maxlen);
|
||||
if (!out) return String();
|
||||
if (!out) {
|
||||
return String();
|
||||
}
|
||||
bytes2hex(out, maxlen, in, len);
|
||||
String ret = String(out);
|
||||
free(out);
|
||||
|
@ -25,10 +25,10 @@
|
||||
|
||||
class HEXBuilder {
|
||||
public:
|
||||
static size_t hex2bytes(unsigned char* out, size_t maxlen, String& in);
|
||||
static size_t hex2bytes(unsigned char* out, size_t maxlen, const char* in);
|
||||
static size_t hex2bytes(unsigned char *out, size_t maxlen, String &in);
|
||||
static size_t hex2bytes(unsigned char *out, size_t maxlen, const char *in);
|
||||
|
||||
static String bytes2hex(const unsigned char* in, size_t len);
|
||||
static size_t bytes2hex(char* out, size_t maxlen, const unsigned char* in, size_t len);
|
||||
static String bytes2hex(const unsigned char *in, size_t len);
|
||||
static size_t bytes2hex(char *out, size_t maxlen, const unsigned char *in, size_t len);
|
||||
};
|
||||
#endif
|
||||
|
@ -35,7 +35,7 @@ ESP_EVENT_DEFINE_BASE(ARDUINO_HW_CDC_EVENTS);
|
||||
|
||||
static RingbufHandle_t tx_ring_buf = NULL;
|
||||
static QueueHandle_t rx_queue = NULL;
|
||||
static uint8_t rx_data_buf[64] = { 0 };
|
||||
static uint8_t rx_data_buf[64] = {0};
|
||||
static intr_handle_t intr_handle = NULL;
|
||||
static SemaphoreHandle_t tx_lock = NULL;
|
||||
static volatile bool connected = false;
|
||||
@ -45,21 +45,19 @@ static uint32_t requested_tx_timeout_ms = 100;
|
||||
|
||||
static esp_event_loop_handle_t arduino_hw_cdc_event_loop_handle = NULL;
|
||||
|
||||
static esp_err_t arduino_hw_cdc_event_post(esp_event_base_t event_base, int32_t event_id, void *event_data, size_t event_data_size, BaseType_t *task_unblocked) {
|
||||
static esp_err_t
|
||||
arduino_hw_cdc_event_post(esp_event_base_t event_base, int32_t event_id, void *event_data, size_t event_data_size, BaseType_t *task_unblocked) {
|
||||
if (arduino_hw_cdc_event_loop_handle == NULL) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
return esp_event_isr_post_to(arduino_hw_cdc_event_loop_handle, event_base, event_id, event_data, event_data_size, task_unblocked);
|
||||
}
|
||||
|
||||
static esp_err_t arduino_hw_cdc_event_handler_register_with(esp_event_base_t event_base, int32_t event_id, esp_event_handler_t event_handler, void *event_handler_arg) {
|
||||
static esp_err_t
|
||||
arduino_hw_cdc_event_handler_register_with(esp_event_base_t event_base, int32_t event_id, esp_event_handler_t event_handler, void *event_handler_arg) {
|
||||
if (!arduino_hw_cdc_event_loop_handle) {
|
||||
esp_event_loop_args_t event_task_args = {
|
||||
.queue_size = 5,
|
||||
.task_name = "arduino_hw_cdc_events",
|
||||
.task_priority = 5,
|
||||
.task_stack_size = 2048,
|
||||
.task_core_id = tskNO_AFFINITY
|
||||
.queue_size = 5, .task_name = "arduino_hw_cdc_events", .task_priority = 5, .task_stack_size = 2048, .task_core_id = tskNO_AFFINITY
|
||||
};
|
||||
if (esp_event_loop_create(&event_task_args, &arduino_hw_cdc_event_loop_handle) != ESP_OK) {
|
||||
log_e("esp_event_loop_create failed");
|
||||
@ -74,7 +72,7 @@ static esp_err_t arduino_hw_cdc_event_handler_register_with(esp_event_base_t eve
|
||||
static void hw_cdc_isr_handler(void *arg) {
|
||||
portBASE_TYPE xTaskWoken = 0;
|
||||
uint32_t usbjtag_intr_status = 0;
|
||||
arduino_hw_cdc_event_data_t event = { 0 };
|
||||
arduino_hw_cdc_event_data_t event = {0};
|
||||
usbjtag_intr_status = usb_serial_jtag_ll_get_intsts_mask();
|
||||
|
||||
if (usbjtag_intr_status & USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY) {
|
||||
@ -99,7 +97,9 @@ static void hw_cdc_isr_handler(void *arg) {
|
||||
usb_serial_jtag_ll_write_txfifo(queued_buff, queued_size);
|
||||
usb_serial_jtag_ll_txfifo_flush();
|
||||
vRingbufferReturnItemFromISR(tx_ring_buf, queued_buff, &xTaskWoken);
|
||||
if (connected) usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
|
||||
if (connected) {
|
||||
usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
|
||||
}
|
||||
//send event?
|
||||
//ets_printf("TX:%u\n", queued_size);
|
||||
event.tx.len = queued_size;
|
||||
@ -204,7 +204,9 @@ void HWCDC::onEvent(arduino_hw_cdc_event_t event, esp_event_handler_t callback)
|
||||
bool HWCDC::deinit(void *busptr) {
|
||||
// avoid any recursion issue with Peripheral Manager perimanSetPinBus() call
|
||||
static bool running = false;
|
||||
if (running) return true;
|
||||
if (running) {
|
||||
return true;
|
||||
}
|
||||
running = true;
|
||||
// Setting USB D+ D- pins
|
||||
bool retCode = true;
|
||||
@ -245,9 +247,13 @@ void HWCDC::begin(unsigned long baud) {
|
||||
|
||||
// Peripheral Manager setting for USB D+ D- pins
|
||||
uint8_t pin = USB_DM_GPIO_NUM;
|
||||
if (!perimanSetPinBus(pin, ESP32_BUS_TYPE_USB_DM, (void *)this, -1, -1)) goto err;
|
||||
if (!perimanSetPinBus(pin, ESP32_BUS_TYPE_USB_DM, (void *)this, -1, -1)) {
|
||||
goto err;
|
||||
}
|
||||
pin = USB_DP_GPIO_NUM;
|
||||
if (!perimanSetPinBus(pin, ESP32_BUS_TYPE_USB_DP, (void *)this, -1, -1)) goto err;
|
||||
if (!perimanSetPinBus(pin, ESP32_BUS_TYPE_USB_DP, (void *)this, -1, -1)) {
|
||||
goto err;
|
||||
}
|
||||
|
||||
// Configure PHY
|
||||
// USB_Serial_JTAG use internal PHY
|
||||
@ -333,7 +339,9 @@ int HWCDC::availableForWrite(void) {
|
||||
}
|
||||
|
||||
static void flushTXBuffer() {
|
||||
if (!tx_ring_buf) return;
|
||||
if (!tx_ring_buf) {
|
||||
return;
|
||||
}
|
||||
UBaseType_t uxItemsWaiting = 0;
|
||||
vRingbufferGetInfo(tx_ring_buf, NULL, NULL, NULL, NULL, &uxItemsWaiting);
|
||||
|
||||
@ -373,7 +381,9 @@ size_t HWCDC::write(const uint8_t *buffer, size_t size) {
|
||||
so_far += space;
|
||||
// Now trigger the ISR to read data from the ring buffer.
|
||||
usb_serial_jtag_ll_txfifo_flush();
|
||||
if (connected) usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
|
||||
if (connected) {
|
||||
usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
|
||||
}
|
||||
|
||||
while (to_send) {
|
||||
space = xRingbufferGetCurFreeSize(tx_ring_buf);
|
||||
@ -389,7 +399,9 @@ size_t HWCDC::write(const uint8_t *buffer, size_t size) {
|
||||
to_send -= space;
|
||||
// Now trigger the ISR to read data from the ring buffer.
|
||||
usb_serial_jtag_ll_txfifo_flush();
|
||||
if (connected) usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
|
||||
if (connected) {
|
||||
usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
|
||||
}
|
||||
}
|
||||
}
|
||||
// CDC is disconnected ==> flush all data from TX buffer
|
||||
@ -423,14 +435,18 @@ void HWCDC::flush(void) {
|
||||
if (uxItemsWaiting) {
|
||||
// Now trigger the ISR to read data from the ring buffer.
|
||||
usb_serial_jtag_ll_txfifo_flush();
|
||||
if (connected) usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
|
||||
if (connected) {
|
||||
usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
|
||||
}
|
||||
}
|
||||
uint8_t tries = 3;
|
||||
while (tries && uxItemsWaiting) {
|
||||
delay(5);
|
||||
UBaseType_t lastUxItemsWaiting = uxItemsWaiting;
|
||||
vRingbufferGetInfo(tx_ring_buf, NULL, NULL, NULL, NULL, &uxItemsWaiting);
|
||||
if (lastUxItemsWaiting == uxItemsWaiting) tries--;
|
||||
if (lastUxItemsWaiting == uxItemsWaiting) {
|
||||
tries--;
|
||||
}
|
||||
}
|
||||
if (tries == 0) { // CDC isn't connected anymore...
|
||||
connected = false;
|
||||
|
@ -59,25 +59,35 @@ void USBSerialEvent(void) {}
|
||||
|
||||
void serialEventRun(void) {
|
||||
#if HWCDC_SERIAL_IS_DEFINED == 1 // Hardware JTAG CDC Event
|
||||
if (HWCDCSerial.available()) HWCDCSerialEvent();
|
||||
if (HWCDCSerial.available()) {
|
||||
HWCDCSerialEvent();
|
||||
}
|
||||
#endif
|
||||
#if USB_SERIAL_IS_DEFINED == 1 // Native USB CDC Event
|
||||
if (USBSerial.available()) USBSerialEvent();
|
||||
if (USBSerial.available()) {
|
||||
USBSerialEvent();
|
||||
}
|
||||
#endif
|
||||
// UART0 is default serialEvent()
|
||||
if (Serial0.available()) serialEvent();
|
||||
if (Serial0.available()) {
|
||||
serialEvent();
|
||||
}
|
||||
#if SOC_UART_NUM > 1
|
||||
if (Serial1.available()) serialEvent1();
|
||||
if (Serial1.available()) {
|
||||
serialEvent1();
|
||||
}
|
||||
#endif
|
||||
#if SOC_UART_NUM > 2
|
||||
if (Serial2.available()) serialEvent2();
|
||||
if (Serial2.available()) {
|
||||
serialEvent2();
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !CONFIG_DISABLE_HAL_LOCKS
|
||||
#define HSERIAL_MUTEX_LOCK() \
|
||||
do { \
|
||||
do { \
|
||||
} while (xSemaphoreTake(_lock, portMAX_DELAY) != pdPASS)
|
||||
#define HSERIAL_MUTEX_UNLOCK() xSemaphoreGive(_lock)
|
||||
#else
|
||||
@ -86,16 +96,8 @@ void serialEventRun(void) {
|
||||
#endif
|
||||
|
||||
HardwareSerial::HardwareSerial(uint8_t uart_nr)
|
||||
: _uart_nr(uart_nr),
|
||||
_uart(NULL),
|
||||
_rxBufferSize(256),
|
||||
_txBufferSize(0),
|
||||
_onReceiveCB(NULL),
|
||||
_onReceiveErrorCB(NULL),
|
||||
_onReceiveTimeout(false),
|
||||
_rxTimeout(2),
|
||||
_rxFIFOFull(0),
|
||||
_eventTask(NULL)
|
||||
: _uart_nr(uart_nr), _uart(NULL), _rxBufferSize(256), _txBufferSize(0), _onReceiveCB(NULL), _onReceiveErrorCB(NULL), _onReceiveTimeout(false), _rxTimeout(2),
|
||||
_rxFIFOFull(0), _eventTask(NULL)
|
||||
#if !CONFIG_DISABLE_HAL_LOCKS
|
||||
,
|
||||
_lock(NULL)
|
||||
@ -123,10 +125,12 @@ HardwareSerial::~HardwareSerial() {
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void HardwareSerial::_createEventTask(void *args) {
|
||||
// Creating UART event Task
|
||||
xTaskCreateUniversal(_uartEventTask, "uart_event_task", ARDUINO_SERIAL_EVENT_TASK_STACK_SIZE, this, ARDUINO_SERIAL_EVENT_TASK_PRIORITY, &_eventTask, ARDUINO_SERIAL_EVENT_TASK_RUNNING_CORE);
|
||||
xTaskCreateUniversal(
|
||||
_uartEventTask, "uart_event_task", ARDUINO_SERIAL_EVENT_TASK_STACK_SIZE, this, ARDUINO_SERIAL_EVENT_TASK_PRIORITY, &_eventTask,
|
||||
ARDUINO_SERIAL_EVENT_TASK_RUNNING_CORE
|
||||
);
|
||||
if (_eventTask == NULL) {
|
||||
log_e(" -- UART%d Event Task not Created!", _uart_nr);
|
||||
}
|
||||
@ -189,7 +193,9 @@ bool HardwareSerial::setRxFIFOFull(uint8_t fifoBytes) {
|
||||
log_w("OnReceive is set to Timeout only, thus FIFO Full is now 120 bytes.");
|
||||
}
|
||||
bool retCode = uartSetRxFIFOFull(_uart, fifoBytes); // Set new timeout
|
||||
if (fifoBytes > 0 && fifoBytes < SOC_UART_FIFO_LEN - 1) _rxFIFOFull = fifoBytes;
|
||||
if (fifoBytes > 0 && fifoBytes < SOC_UART_FIFO_LEN - 1) {
|
||||
_rxFIFOFull = fifoBytes;
|
||||
}
|
||||
HSERIAL_MUTEX_UNLOCK();
|
||||
return retCode;
|
||||
}
|
||||
@ -202,7 +208,9 @@ bool HardwareSerial::setRxTimeout(uint8_t symbols_timeout) {
|
||||
// Zero disables timeout, thus, onReceive callback will only be called when RX FIFO reaches 120 bytes
|
||||
// Any non-zero value will activate onReceive callback based on UART baudrate with about 11 bits per symbol
|
||||
_rxTimeout = symbols_timeout;
|
||||
if (!symbols_timeout) _onReceiveTimeout = false; // only when RX timeout is disabled, we also must disable this flag
|
||||
if (!symbols_timeout) {
|
||||
_onReceiveTimeout = false; // only when RX timeout is disabled, we also must disable this flag
|
||||
}
|
||||
|
||||
bool retCode = uartSetRxTimeout(_uart, _rxTimeout); // Set new timeout
|
||||
|
||||
@ -233,8 +241,9 @@ void HardwareSerial::_uartEventTask(void *args) {
|
||||
hardwareSerial_error_t currentErr = UART_NO_ERROR;
|
||||
switch (event.type) {
|
||||
case UART_DATA:
|
||||
if (uart->_onReceiveCB && uart->available() > 0 && ((uart->_onReceiveTimeout && event.timeout_flag) || !uart->_onReceiveTimeout))
|
||||
if (uart->_onReceiveCB && uart->available() > 0 && ((uart->_onReceiveTimeout && event.timeout_flag) || !uart->_onReceiveTimeout)) {
|
||||
uart->_onReceiveCB();
|
||||
}
|
||||
break;
|
||||
case UART_FIFO_OVF:
|
||||
log_w("UART%d FIFO Overflow. Consider adding Hardware Flow Control to your Application.", uart->_uart_nr);
|
||||
@ -256,12 +265,12 @@ void HardwareSerial::_uartEventTask(void *args) {
|
||||
log_w("UART%d frame error.", uart->_uart_nr);
|
||||
currentErr = UART_FRAME_ERROR;
|
||||
break;
|
||||
default:
|
||||
log_w("UART%d unknown event type %d.", uart->_uart_nr, event.type);
|
||||
break;
|
||||
default: log_w("UART%d unknown event type %d.", uart->_uart_nr, event.type); break;
|
||||
}
|
||||
if (currentErr != UART_NO_ERROR) {
|
||||
if (uart->_onReceiveErrorCB) uart->_onReceiveErrorCB(currentErr);
|
||||
if (uart->_onReceiveErrorCB) {
|
||||
uart->_onReceiveErrorCB(currentErr);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -96,7 +96,6 @@ typedef enum {
|
||||
UART_PARITY_ERROR
|
||||
} hardwareSerial_error_t;
|
||||
|
||||
|
||||
#ifndef ARDUINO_SERIAL_EVENT_TASK_STACK_SIZE
|
||||
#define ARDUINO_SERIAL_EVENT_TASK_STACK_SIZE 2048
|
||||
#endif
|
||||
@ -250,7 +249,10 @@ public:
|
||||
// timeout_ms is used in baudrate detection (ESP32, ESP32S2 only)
|
||||
// invert will invert RX/TX polarity
|
||||
// rxfifo_full_thrhd if the UART Flow Control Threshold in the UART FIFO (max 127)
|
||||
void begin(unsigned long baud, uint32_t config = SERIAL_8N1, int8_t rxPin = -1, int8_t txPin = -1, bool invert = false, unsigned long timeout_ms = 20000UL, uint8_t rxfifo_full_thrhd = 112);
|
||||
void begin(
|
||||
unsigned long baud, uint32_t config = SERIAL_8N1, int8_t rxPin = -1, int8_t txPin = -1, bool invert = false, unsigned long timeout_ms = 20000UL,
|
||||
uint8_t rxfifo_full_thrhd = 112
|
||||
);
|
||||
void end(void);
|
||||
void updateBaudRate(unsigned long baud);
|
||||
int available(void);
|
||||
|
@ -25,23 +25,23 @@ public:
|
||||
virtual ~HashBuilder() {}
|
||||
virtual void begin() = 0;
|
||||
|
||||
virtual void add(const uint8_t* data, size_t len) = 0;
|
||||
virtual void add(const char* data) {
|
||||
add((const uint8_t*)data, strlen(data));
|
||||
virtual void add(const uint8_t *data, size_t len) = 0;
|
||||
virtual void add(const char *data) {
|
||||
add((const uint8_t *)data, strlen(data));
|
||||
}
|
||||
virtual void add(String data) {
|
||||
add(data.c_str());
|
||||
}
|
||||
|
||||
virtual void addHexString(const char* data) = 0;
|
||||
virtual void addHexString(const char *data) = 0;
|
||||
virtual void addHexString(String data) {
|
||||
addHexString(data.c_str());
|
||||
}
|
||||
|
||||
virtual bool addStream(Stream& stream, const size_t maxLen) = 0;
|
||||
virtual bool addStream(Stream &stream, const size_t maxLen) = 0;
|
||||
virtual void calculate() = 0;
|
||||
virtual void getBytes(uint8_t* output) = 0;
|
||||
virtual void getChars(char* output) = 0;
|
||||
virtual void getBytes(uint8_t *output) = 0;
|
||||
virtual void getChars(char *output) = 0;
|
||||
virtual String toString() = 0;
|
||||
};
|
||||
|
||||
|
@ -22,8 +22,7 @@
|
||||
#include "lwip/netif.h"
|
||||
#include "StreamString.h"
|
||||
|
||||
IPAddress::IPAddress()
|
||||
: IPAddress(IPv4) {}
|
||||
IPAddress::IPAddress() : IPAddress(IPv4) {}
|
||||
|
||||
IPAddress::IPAddress(IPType ip_type) {
|
||||
_type = ip_type;
|
||||
@ -41,7 +40,10 @@ IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_oc
|
||||
_address.bytes[IPADDRESS_V4_BYTES_INDEX + 3] = fourth_octet;
|
||||
}
|
||||
|
||||
IPAddress::IPAddress(uint8_t o1, uint8_t o2, uint8_t o3, uint8_t o4, uint8_t o5, uint8_t o6, uint8_t o7, uint8_t o8, uint8_t o9, uint8_t o10, uint8_t o11, uint8_t o12, uint8_t o13, uint8_t o14, uint8_t o15, uint8_t o16, uint8_t z) {
|
||||
IPAddress::IPAddress(
|
||||
uint8_t o1, uint8_t o2, uint8_t o3, uint8_t o4, uint8_t o5, uint8_t o6, uint8_t o7, uint8_t o8, uint8_t o9, uint8_t o10, uint8_t o11, uint8_t o12,
|
||||
uint8_t o13, uint8_t o14, uint8_t o15, uint8_t o16, uint8_t z
|
||||
) {
|
||||
_type = IPv6;
|
||||
_address.bytes[0] = o1;
|
||||
_address.bytes[1] = o2;
|
||||
@ -78,10 +80,9 @@ IPAddress::IPAddress(uint32_t address) {
|
||||
// in that order, will form the integer (uint32_t) 3460758158 .
|
||||
}
|
||||
|
||||
IPAddress::IPAddress(const uint8_t* address)
|
||||
: IPAddress(IPv4, address) {}
|
||||
IPAddress::IPAddress(const uint8_t *address) : IPAddress(IPv4, address) {}
|
||||
|
||||
IPAddress::IPAddress(IPType ip_type, const uint8_t* address, uint8_t z) {
|
||||
IPAddress::IPAddress(IPType ip_type, const uint8_t *address, uint8_t z) {
|
||||
_type = ip_type;
|
||||
if (ip_type == IPv4) {
|
||||
memset(_address.bytes, 0, sizeof(_address.bytes));
|
||||
@ -93,11 +94,11 @@ IPAddress::IPAddress(IPType ip_type, const uint8_t* address, uint8_t z) {
|
||||
}
|
||||
}
|
||||
|
||||
IPAddress::IPAddress(const char* address) {
|
||||
IPAddress::IPAddress(const char *address) {
|
||||
fromString(address);
|
||||
}
|
||||
|
||||
IPAddress::IPAddress(const IPAddress& address) {
|
||||
IPAddress::IPAddress(const IPAddress &address) {
|
||||
*this = address;
|
||||
}
|
||||
|
||||
@ -107,14 +108,14 @@ String IPAddress::toString(bool includeZone) const {
|
||||
return String(s);
|
||||
}
|
||||
|
||||
bool IPAddress::fromString(const char* address) {
|
||||
bool IPAddress::fromString(const char *address) {
|
||||
if (!fromString4(address)) {
|
||||
return fromString6(address);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool IPAddress::fromString4(const char* address) {
|
||||
bool IPAddress::fromString4(const char *address) {
|
||||
// TODO: add support for "a", "a.b", "a.b.c" formats
|
||||
|
||||
int16_t acc = -1; // Accumulator
|
||||
@ -159,19 +160,21 @@ bool IPAddress::fromString4(const char* address) {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool IPAddress::fromString6(const char* address) {
|
||||
bool IPAddress::fromString6(const char *address) {
|
||||
uint32_t acc = 0; // Accumulator
|
||||
int colons = 0, double_colons = -1;
|
||||
|
||||
while (*address) {
|
||||
char c = tolower(*address++);
|
||||
if (isalnum(c) && c <= 'f') {
|
||||
if (c >= 'a')
|
||||
if (c >= 'a') {
|
||||
c -= 'a' - '0' - 10;
|
||||
}
|
||||
acc = acc * 16 + (c - '0');
|
||||
if (acc > 0xffff)
|
||||
if (acc > 0xffff) {
|
||||
// Value out of range
|
||||
return false;
|
||||
}
|
||||
} else if (c == ':') {
|
||||
if (*address == ':') {
|
||||
if (double_colons >= 0) {
|
||||
@ -189,9 +192,10 @@ bool IPAddress::fromString6(const char* address) {
|
||||
// can't end with a single colon
|
||||
return false;
|
||||
}
|
||||
if (colons == 7)
|
||||
if (colons == 7) {
|
||||
// too many separators
|
||||
return false;
|
||||
}
|
||||
_address.bytes[colons * 2] = acc >> 8;
|
||||
_address.bytes[colons * 2 + 1] = acc & 0xff;
|
||||
colons++;
|
||||
@ -201,9 +205,10 @@ bool IPAddress::fromString6(const char* address) {
|
||||
while (*address != '\0') {
|
||||
address++;
|
||||
}
|
||||
} else
|
||||
} else {
|
||||
// Invalid char
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (double_colons == -1 && colons != 7) {
|
||||
@ -219,17 +224,19 @@ bool IPAddress::fromString6(const char* address) {
|
||||
colons++;
|
||||
|
||||
if (double_colons != -1) {
|
||||
for (int i = colons * 2 - double_colons * 2 - 1; i >= 0; i--)
|
||||
for (int i = colons * 2 - double_colons * 2 - 1; i >= 0; i--) {
|
||||
_address.bytes[16 - colons * 2 + double_colons * 2 + i] = _address.bytes[double_colons * 2 + i];
|
||||
for (int i = double_colons * 2; i < 16 - colons * 2 + double_colons * 2; i++)
|
||||
}
|
||||
for (int i = double_colons * 2; i < 16 - colons * 2 + double_colons * 2; i++) {
|
||||
_address.bytes[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
_type = IPv6;
|
||||
return true;
|
||||
}
|
||||
|
||||
IPAddress& IPAddress::operator=(const uint8_t* address) {
|
||||
IPAddress &IPAddress::operator=(const uint8_t *address) {
|
||||
// IPv4 only conversion from byte pointer
|
||||
_type = IPv4;
|
||||
memset(_address.bytes, 0, sizeof(_address.bytes));
|
||||
@ -237,12 +244,12 @@ IPAddress& IPAddress::operator=(const uint8_t* address) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
IPAddress& IPAddress::operator=(const char* address) {
|
||||
IPAddress &IPAddress::operator=(const char *address) {
|
||||
fromString(address);
|
||||
return *this;
|
||||
}
|
||||
|
||||
IPAddress& IPAddress::operator=(uint32_t address) {
|
||||
IPAddress &IPAddress::operator=(uint32_t address) {
|
||||
// IPv4 conversion
|
||||
// See note on conversion/comparison and uint32_t
|
||||
_type = IPv4;
|
||||
@ -251,19 +258,18 @@ IPAddress& IPAddress::operator=(uint32_t address) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
IPAddress& IPAddress::operator=(const IPAddress& address) {
|
||||
IPAddress &IPAddress::operator=(const IPAddress &address) {
|
||||
_type = address.type();
|
||||
_zone = address.zone();
|
||||
memcpy(_address.bytes, address._address.bytes, sizeof(_address.bytes));
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool IPAddress::operator==(const IPAddress& addr) const {
|
||||
return (addr._type == _type)
|
||||
&& (memcmp(addr._address.bytes, _address.bytes, sizeof(_address.bytes)) == 0);
|
||||
bool IPAddress::operator==(const IPAddress &addr) const {
|
||||
return (addr._type == _type) && (memcmp(addr._address.bytes, _address.bytes, sizeof(_address.bytes)) == 0);
|
||||
}
|
||||
|
||||
bool IPAddress::operator==(const uint8_t* addr) const {
|
||||
bool IPAddress::operator==(const uint8_t *addr) const {
|
||||
// IPv4 only comparison to byte pointer
|
||||
// Can't support IPv6 as we know our type, but not the length of the pointer
|
||||
return _type == IPv4 && memcmp(addr, &_address.bytes[IPADDRESS_V4_BYTES_INDEX], sizeof(uint32_t)) == 0;
|
||||
@ -276,18 +282,18 @@ uint8_t IPAddress::operator[](int index) const {
|
||||
return _address.bytes[index];
|
||||
}
|
||||
|
||||
uint8_t& IPAddress::operator[](int index) {
|
||||
uint8_t &IPAddress::operator[](int index) {
|
||||
if (_type == IPv4) {
|
||||
return _address.bytes[IPADDRESS_V4_BYTES_INDEX + index];
|
||||
}
|
||||
return _address.bytes[index];
|
||||
}
|
||||
|
||||
size_t IPAddress::printTo(Print& p) const {
|
||||
size_t IPAddress::printTo(Print &p) const {
|
||||
return printTo(p, false);
|
||||
}
|
||||
|
||||
size_t IPAddress::printTo(Print& p, bool includeZone) const {
|
||||
size_t IPAddress::printTo(Print &p, bool includeZone) const {
|
||||
size_t n = 0;
|
||||
|
||||
if (_type == IPv6) {
|
||||
@ -357,11 +363,11 @@ size_t IPAddress::printTo(Print& p, bool includeZone) const {
|
||||
return n;
|
||||
}
|
||||
|
||||
IPAddress::IPAddress(const ip_addr_t* addr) {
|
||||
IPAddress::IPAddress(const ip_addr_t *addr) {
|
||||
from_ip_addr_t(addr);
|
||||
}
|
||||
|
||||
void IPAddress::to_ip_addr_t(ip_addr_t* addr) const {
|
||||
void IPAddress::to_ip_addr_t(ip_addr_t *addr) const {
|
||||
if (_type == IPv6) {
|
||||
addr->type = IPADDR_TYPE_V6;
|
||||
addr->u_addr.ip6.addr[0] = _address.dword[0];
|
||||
@ -377,7 +383,7 @@ void IPAddress::to_ip_addr_t(ip_addr_t* addr) const {
|
||||
}
|
||||
}
|
||||
|
||||
IPAddress& IPAddress::from_ip_addr_t(const ip_addr_t* addr) {
|
||||
IPAddress &IPAddress::from_ip_addr_t(const ip_addr_t *addr) {
|
||||
if (addr->type == IPADDR_TYPE_V6) {
|
||||
_type = IPv6;
|
||||
_address.dword[0] = addr->u_addr.ip6.addr[0];
|
||||
@ -400,7 +406,7 @@ esp_ip6_addr_type_t IPAddress::addr_type() const {
|
||||
}
|
||||
ip_addr_t addr;
|
||||
to_ip_addr_t(&addr);
|
||||
return esp_netif_ip6_get_addr_type((esp_ip6_addr_t*)(&(addr.u_addr.ip6)));
|
||||
return esp_netif_ip6_get_addr_type((esp_ip6_addr_t *)(&(addr.u_addr.ip6)));
|
||||
}
|
||||
|
||||
const IPAddress IN6ADDR_ANY(IPv6);
|
||||
|
@ -48,7 +48,7 @@ private:
|
||||
// to the internal structure rather than a copy of the address this function should only
|
||||
// be used when you know that the usage of the returned uint8_t* will be transient and not
|
||||
// stored.
|
||||
uint8_t* raw_address() {
|
||||
uint8_t *raw_address() {
|
||||
return _type == IPv4 ? &_address.bytes[IPADDRESS_V4_BYTES_INDEX] : _address.bytes;
|
||||
}
|
||||
|
||||
@ -59,18 +59,21 @@ public:
|
||||
IPAddress();
|
||||
IPAddress(IPType ip_type);
|
||||
IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet);
|
||||
IPAddress(uint8_t o1, uint8_t o2, uint8_t o3, uint8_t o4, uint8_t o5, uint8_t o6, uint8_t o7, uint8_t o8, uint8_t o9, uint8_t o10, uint8_t o11, uint8_t o12, uint8_t o13, uint8_t o14, uint8_t o15, uint8_t o16, uint8_t z = 0);
|
||||
IPAddress(
|
||||
uint8_t o1, uint8_t o2, uint8_t o3, uint8_t o4, uint8_t o5, uint8_t o6, uint8_t o7, uint8_t o8, uint8_t o9, uint8_t o10, uint8_t o11, uint8_t o12,
|
||||
uint8_t o13, uint8_t o14, uint8_t o15, uint8_t o16, uint8_t z = 0
|
||||
);
|
||||
// IPv4; see implementation note
|
||||
IPAddress(uint32_t address);
|
||||
// Default IPv4
|
||||
IPAddress(const uint8_t* address);
|
||||
IPAddress(IPType ip_type, const uint8_t* address, uint8_t z = 0);
|
||||
IPAddress(const uint8_t *address);
|
||||
IPAddress(IPType ip_type, const uint8_t *address, uint8_t z = 0);
|
||||
// If IPv4 fails tries IPv6 see fromString function
|
||||
IPAddress(const char* address);
|
||||
IPAddress(const IPAddress& address);
|
||||
IPAddress(const char *address);
|
||||
IPAddress(const IPAddress &address);
|
||||
|
||||
bool fromString(const char* address);
|
||||
bool fromString(const String& address) {
|
||||
bool fromString(const char *address);
|
||||
bool fromString(const String &address) {
|
||||
return fromString(address.c_str());
|
||||
}
|
||||
|
||||
@ -80,28 +83,28 @@ public:
|
||||
return _type == IPv4 ? _address.dword[IPADDRESS_V4_DWORD_INDEX] : 0;
|
||||
};
|
||||
|
||||
bool operator==(const IPAddress& addr) const;
|
||||
bool operator!=(const IPAddress& addr) const {
|
||||
bool operator==(const IPAddress &addr) const;
|
||||
bool operator!=(const IPAddress &addr) const {
|
||||
return !(*this == addr);
|
||||
};
|
||||
|
||||
// NOTE: IPv4 only; we don't know the length of the pointer
|
||||
bool operator==(const uint8_t* addr) const;
|
||||
bool operator==(const uint8_t *addr) const;
|
||||
|
||||
// Overloaded index operator to allow getting and setting individual octets of the address
|
||||
uint8_t operator[](int index) const;
|
||||
uint8_t& operator[](int index);
|
||||
uint8_t &operator[](int index);
|
||||
|
||||
// Overloaded copy operators to allow initialization of IPAddress objects from other types
|
||||
// NOTE: IPv4 only
|
||||
IPAddress& operator=(const uint8_t* address);
|
||||
IPAddress &operator=(const uint8_t *address);
|
||||
// NOTE: IPv4 only; see implementation note
|
||||
IPAddress& operator=(uint32_t address);
|
||||
IPAddress &operator=(uint32_t address);
|
||||
// If IPv4 fails tries IPv6 see fromString function
|
||||
IPAddress& operator=(const char* address);
|
||||
IPAddress& operator=(const IPAddress& address);
|
||||
IPAddress &operator=(const char *address);
|
||||
IPAddress &operator=(const IPAddress &address);
|
||||
|
||||
virtual size_t printTo(Print& p) const;
|
||||
virtual size_t printTo(Print &p) const;
|
||||
String toString(bool includeZone = false) const;
|
||||
|
||||
IPType type() const {
|
||||
@ -109,22 +112,22 @@ public:
|
||||
}
|
||||
|
||||
// Espresif LwIP conversions
|
||||
IPAddress(const ip_addr_t* addr);
|
||||
void to_ip_addr_t(ip_addr_t* addr) const;
|
||||
IPAddress& from_ip_addr_t(const ip_addr_t* addr);
|
||||
IPAddress(const ip_addr_t *addr);
|
||||
void to_ip_addr_t(ip_addr_t *addr) const;
|
||||
IPAddress &from_ip_addr_t(const ip_addr_t *addr);
|
||||
esp_ip6_addr_type_t addr_type() const;
|
||||
uint8_t zone() const {
|
||||
return (type() == IPv6) ? _zone : 0;
|
||||
}
|
||||
size_t printTo(Print& p, bool includeZone) const;
|
||||
size_t printTo(Print &p, bool includeZone) const;
|
||||
|
||||
friend class UDP;
|
||||
friend class Client;
|
||||
friend class Server;
|
||||
|
||||
protected:
|
||||
bool fromString4(const char* address);
|
||||
bool fromString6(const char* address);
|
||||
bool fromString4(const char *address);
|
||||
bool fromString6(const char *address);
|
||||
};
|
||||
|
||||
extern const IPAddress IN6ADDR_ANY;
|
||||
|
@ -26,13 +26,13 @@ void MD5Builder::begin(void) {
|
||||
esp_rom_md5_init(&_ctx);
|
||||
}
|
||||
|
||||
void MD5Builder::add(const uint8_t* data, size_t len) {
|
||||
void MD5Builder::add(const uint8_t *data, size_t len) {
|
||||
esp_rom_md5_update(&_ctx, data, len);
|
||||
}
|
||||
|
||||
void MD5Builder::addHexString(const char* data) {
|
||||
void MD5Builder::addHexString(const char *data) {
|
||||
size_t len = strlen(data);
|
||||
uint8_t* tmp = (uint8_t*)malloc(len / 2);
|
||||
uint8_t *tmp = (uint8_t *)malloc(len / 2);
|
||||
if (tmp == NULL) {
|
||||
return;
|
||||
}
|
||||
@ -41,10 +41,10 @@ void MD5Builder::addHexString(const char* data) {
|
||||
free(tmp);
|
||||
}
|
||||
|
||||
bool MD5Builder::addStream(Stream& stream, const size_t maxLen) {
|
||||
bool MD5Builder::addStream(Stream &stream, const size_t maxLen) {
|
||||
const int buf_size = 512;
|
||||
int maxLengthLeft = maxLen;
|
||||
uint8_t* buf = (uint8_t*)malloc(buf_size);
|
||||
uint8_t *buf = (uint8_t *)malloc(buf_size);
|
||||
|
||||
if (!buf) {
|
||||
return false;
|
||||
@ -84,11 +84,11 @@ void MD5Builder::calculate(void) {
|
||||
esp_rom_md5_final(_buf, &_ctx);
|
||||
}
|
||||
|
||||
void MD5Builder::getBytes(uint8_t* output) {
|
||||
void MD5Builder::getBytes(uint8_t *output) {
|
||||
memcpy(output, _buf, ESP_ROM_MD5_DIGEST_LEN);
|
||||
}
|
||||
|
||||
void MD5Builder::getChars(char* output) {
|
||||
void MD5Builder::getChars(char *output) {
|
||||
bytes2hex(output, ESP_ROM_MD5_DIGEST_LEN * 2 + 1, _buf, ESP_ROM_MD5_DIGEST_LEN);
|
||||
}
|
||||
|
||||
|
@ -33,19 +33,20 @@ class MD5Builder : public HashBuilder {
|
||||
private:
|
||||
md5_context_t _ctx;
|
||||
uint8_t _buf[ESP_ROM_MD5_DIGEST_LEN];
|
||||
|
||||
public:
|
||||
void begin(void) override;
|
||||
|
||||
using HashBuilder::add;
|
||||
void add(const uint8_t* data, size_t len) override;
|
||||
void add(const uint8_t *data, size_t len) override;
|
||||
|
||||
using HashBuilder::addHexString;
|
||||
void addHexString(const char* data) override;
|
||||
void addHexString(const char *data) override;
|
||||
|
||||
bool addStream(Stream& stream, const size_t maxLen) override;
|
||||
bool addStream(Stream &stream, const size_t maxLen) override;
|
||||
void calculate(void) override;
|
||||
void getBytes(uint8_t* output) override;
|
||||
void getChars(char* output) override;
|
||||
void getBytes(uint8_t *output) override;
|
||||
void getChars(char *output) override;
|
||||
String toString(void) override;
|
||||
};
|
||||
|
||||
|
@ -3,8 +3,7 @@
|
||||
#include <Print.h>
|
||||
|
||||
//Default constructor, blank mac address.
|
||||
MacAddress::MacAddress()
|
||||
: MacAddress(MAC6) {}
|
||||
MacAddress::MacAddress() : MacAddress(MAC6) {}
|
||||
|
||||
MacAddress::MacAddress(MACType mac_type) {
|
||||
_type = mac_type;
|
||||
@ -118,14 +117,12 @@ void MacAddress::toBytes(uint8_t *buf) {
|
||||
//MAC: Buffer must be at least 18 chars
|
||||
int MacAddress::toString(char *buf) {
|
||||
if (_type == MAC6) {
|
||||
return sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
|
||||
_mac.bytes[0], _mac.bytes[1], _mac.bytes[2],
|
||||
_mac.bytes[3], _mac.bytes[4], _mac.bytes[5]);
|
||||
return sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X", _mac.bytes[0], _mac.bytes[1], _mac.bytes[2], _mac.bytes[3], _mac.bytes[4], _mac.bytes[5]);
|
||||
} else {
|
||||
return sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
|
||||
_mac.bytes[0], _mac.bytes[1], _mac.bytes[2],
|
||||
_mac.bytes[3], _mac.bytes[4], _mac.bytes[5],
|
||||
_mac.bytes[6], _mac.bytes[7]);
|
||||
return sprintf(
|
||||
buf, "%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", _mac.bytes[0], _mac.bytes[1], _mac.bytes[2], _mac.bytes[3], _mac.bytes[4], _mac.bytes[5], _mac.bytes[6],
|
||||
_mac.bytes[7]
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@ -133,14 +130,12 @@ String MacAddress::toString() const {
|
||||
uint8_t bytes = (_type == MAC6) ? 18 : 24;
|
||||
char buf[bytes];
|
||||
if (_type == MAC6) {
|
||||
snprintf(buf, sizeof(buf), "%02X:%02X:%02X:%02X:%02X:%02X",
|
||||
_mac.bytes[0], _mac.bytes[1], _mac.bytes[2],
|
||||
_mac.bytes[3], _mac.bytes[4], _mac.bytes[5]);
|
||||
snprintf(buf, sizeof(buf), "%02X:%02X:%02X:%02X:%02X:%02X", _mac.bytes[0], _mac.bytes[1], _mac.bytes[2], _mac.bytes[3], _mac.bytes[4], _mac.bytes[5]);
|
||||
} else {
|
||||
snprintf(buf, sizeof(buf), "%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
|
||||
_mac.bytes[0], _mac.bytes[1], _mac.bytes[2],
|
||||
_mac.bytes[3], _mac.bytes[4], _mac.bytes[5],
|
||||
_mac.bytes[6], _mac.bytes[7]);
|
||||
snprintf(
|
||||
buf, sizeof(buf), "%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", _mac.bytes[0], _mac.bytes[1], _mac.bytes[2], _mac.bytes[3], _mac.bytes[4], _mac.bytes[5],
|
||||
_mac.bytes[6], _mac.bytes[7]
|
||||
);
|
||||
}
|
||||
return String(buf);
|
||||
}
|
||||
|
@ -50,10 +50,8 @@ public:
|
||||
MacAddress(MACType mac_type, const uint8_t *macbytearray);
|
||||
|
||||
//Default MAC6
|
||||
MacAddress(uint64_t mac)
|
||||
: MacAddress(MAC6, mac) {}
|
||||
MacAddress(const uint8_t *macbytearray)
|
||||
: MacAddress(MAC6, macbytearray) {}
|
||||
MacAddress(uint64_t mac) : MacAddress(MAC6, mac) {}
|
||||
MacAddress(const uint8_t *macbytearray) : MacAddress(MAC6, macbytearray) {}
|
||||
|
||||
MacAddress(const char *macstr);
|
||||
MacAddress(const String &macstr);
|
||||
|
@ -38,14 +38,14 @@ private:
|
||||
size_t printNumber(unsigned long, uint8_t);
|
||||
size_t printNumber(unsigned long long, uint8_t);
|
||||
size_t printFloat(double, uint8_t);
|
||||
|
||||
protected:
|
||||
void setWriteError(int err = 1) {
|
||||
write_error = err;
|
||||
}
|
||||
|
||||
public:
|
||||
Print()
|
||||
: write_error(0) {
|
||||
}
|
||||
Print() : write_error(0) {}
|
||||
virtual ~Print() {}
|
||||
int getWriteError() {
|
||||
return write_error;
|
||||
@ -112,8 +112,7 @@ public:
|
||||
size_t println(struct tm *timeinfo, const char *format = NULL);
|
||||
size_t println(void);
|
||||
|
||||
virtual void flush() { /* Empty implementation for backward compatibility */
|
||||
}
|
||||
virtual void flush() { /* Empty implementation for backward compatibility */ }
|
||||
};
|
||||
|
||||
#endif
|
||||
|
@ -33,7 +33,7 @@ class Print;
|
||||
class Printable {
|
||||
public:
|
||||
virtual ~Printable() {}
|
||||
virtual size_t printTo(Print& p) const = 0;
|
||||
virtual size_t printTo(Print &p) const = 0;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
@ -27,36 +27,27 @@
|
||||
|
||||
#ifndef GET_UINT32_BE
|
||||
#define GET_UINT32_BE(n, b, i) \
|
||||
{ \
|
||||
(n) = ((uint32_t)(b)[(i)] << 24) \
|
||||
| ((uint32_t)(b)[(i) + 1] << 16) \
|
||||
| ((uint32_t)(b)[(i) + 2] << 8) \
|
||||
| ((uint32_t)(b)[(i) + 3]); \
|
||||
}
|
||||
{ (n) = ((uint32_t)(b)[(i)] << 24) | ((uint32_t)(b)[(i) + 1] << 16) | ((uint32_t)(b)[(i) + 2] << 8) | ((uint32_t)(b)[(i) + 3]); }
|
||||
#endif
|
||||
|
||||
#ifndef PUT_UINT32_BE
|
||||
#define PUT_UINT32_BE(n, b, i) \
|
||||
{ \
|
||||
(b)[(i)] = (uint8_t)((n) >> 24); \
|
||||
#define PUT_UINT32_BE(n, b, i) \
|
||||
{ \
|
||||
(b)[(i)] = (uint8_t)((n) >> 24); \
|
||||
(b)[(i) + 1] = (uint8_t)((n) >> 16); \
|
||||
(b)[(i) + 2] = (uint8_t)((n) >> 8); \
|
||||
(b)[(i) + 3] = (uint8_t)((n)); \
|
||||
(b)[(i) + 2] = (uint8_t)((n) >> 8); \
|
||||
(b)[(i) + 3] = (uint8_t)((n)); \
|
||||
}
|
||||
#endif
|
||||
|
||||
// Constants
|
||||
|
||||
static const uint8_t sha1_padding[64] = {
|
||||
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
static const uint8_t sha1_padding[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
|
||||
// Private methods
|
||||
|
||||
void SHA1Builder::process(const uint8_t* data) {
|
||||
void SHA1Builder::process(const uint8_t *data) {
|
||||
uint32_t temp, W[16], A, B, C, D, E;
|
||||
|
||||
GET_UINT32_BE(W[0], data, 0);
|
||||
@ -78,15 +69,12 @@ void SHA1Builder::process(const uint8_t* data) {
|
||||
|
||||
#define sha1_S(x, n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
|
||||
|
||||
#define sha1_R(t) \
|
||||
( \
|
||||
temp = W[(t - 3) & 0x0F] ^ W[(t - 8) & 0x0F] ^ W[(t - 14) & 0x0F] ^ W[t & 0x0F], \
|
||||
(W[t & 0x0F] = sha1_S(temp, 1)))
|
||||
#define sha1_R(t) (temp = W[(t - 3) & 0x0F] ^ W[(t - 8) & 0x0F] ^ W[(t - 14) & 0x0F] ^ W[t & 0x0F], (W[t & 0x0F] = sha1_S(temp, 1)))
|
||||
|
||||
#define sha1_P(a, b, c, d, e, x) \
|
||||
{ \
|
||||
#define sha1_P(a, b, c, d, e, x) \
|
||||
{ \
|
||||
e += sha1_S(a, 5) + sha1_F(b, c, d) + sha1_K + x; \
|
||||
b = sha1_S(b, 30); \
|
||||
b = sha1_S(b, 30); \
|
||||
}
|
||||
|
||||
A = state[0];
|
||||
@ -96,7 +84,7 @@ void SHA1Builder::process(const uint8_t* data) {
|
||||
E = state[4];
|
||||
|
||||
#define sha1_F(x, y, z) (z ^ (x & (y ^ z)))
|
||||
#define sha1_K 0x5A827999
|
||||
#define sha1_K 0x5A827999
|
||||
|
||||
sha1_P(A, B, C, D, E, W[0]);
|
||||
sha1_P(E, A, B, C, D, W[1]);
|
||||
@ -123,7 +111,7 @@ void SHA1Builder::process(const uint8_t* data) {
|
||||
#undef sha1_F
|
||||
|
||||
#define sha1_F(x, y, z) (x ^ y ^ z)
|
||||
#define sha1_K 0x6ED9EBA1
|
||||
#define sha1_K 0x6ED9EBA1
|
||||
|
||||
sha1_P(A, B, C, D, E, sha1_R(20));
|
||||
sha1_P(E, A, B, C, D, sha1_R(21));
|
||||
@ -150,7 +138,7 @@ void SHA1Builder::process(const uint8_t* data) {
|
||||
#undef sha1_F
|
||||
|
||||
#define sha1_F(x, y, z) ((x & y) | (z & (x | y)))
|
||||
#define sha1_K 0x8F1BBCDC
|
||||
#define sha1_K 0x8F1BBCDC
|
||||
|
||||
sha1_P(A, B, C, D, E, sha1_R(40));
|
||||
sha1_P(E, A, B, C, D, sha1_R(41));
|
||||
@ -177,7 +165,7 @@ void SHA1Builder::process(const uint8_t* data) {
|
||||
#undef sha1_F
|
||||
|
||||
#define sha1_F(x, y, z) (x ^ y ^ z)
|
||||
#define sha1_K 0xCA62C1D6
|
||||
#define sha1_K 0xCA62C1D6
|
||||
|
||||
sha1_P(A, B, C, D, E, sha1_R(60));
|
||||
sha1_P(E, A, B, C, D, sha1_R(61));
|
||||
@ -226,7 +214,7 @@ void SHA1Builder::begin(void) {
|
||||
memset(hash, 0x00, sizeof(hash));
|
||||
}
|
||||
|
||||
void SHA1Builder::add(const uint8_t* data, size_t len) {
|
||||
void SHA1Builder::add(const uint8_t *data, size_t len) {
|
||||
size_t fill;
|
||||
uint32_t left;
|
||||
|
||||
@ -245,7 +233,7 @@ void SHA1Builder::add(const uint8_t* data, size_t len) {
|
||||
}
|
||||
|
||||
if (left && len >= fill) {
|
||||
memcpy((void*)(buffer + left), data, fill);
|
||||
memcpy((void *)(buffer + left), data, fill);
|
||||
process(buffer);
|
||||
data += fill;
|
||||
len -= fill;
|
||||
@ -259,13 +247,13 @@ void SHA1Builder::add(const uint8_t* data, size_t len) {
|
||||
}
|
||||
|
||||
if (len > 0) {
|
||||
memcpy((void*)(buffer + left), data, len);
|
||||
memcpy((void *)(buffer + left), data, len);
|
||||
}
|
||||
}
|
||||
|
||||
void SHA1Builder::addHexString(const char* data) {
|
||||
void SHA1Builder::addHexString(const char *data) {
|
||||
uint16_t len = strlen(data);
|
||||
uint8_t* tmp = (uint8_t*)malloc(len / 2);
|
||||
uint8_t *tmp = (uint8_t *)malloc(len / 2);
|
||||
if (tmp == NULL) {
|
||||
return;
|
||||
}
|
||||
@ -274,10 +262,10 @@ void SHA1Builder::addHexString(const char* data) {
|
||||
free(tmp);
|
||||
}
|
||||
|
||||
bool SHA1Builder::addStream(Stream& stream, const size_t maxLen) {
|
||||
bool SHA1Builder::addStream(Stream &stream, const size_t maxLen) {
|
||||
const int buf_size = 512;
|
||||
int maxLengthLeft = maxLen;
|
||||
uint8_t* buf = (uint8_t*)malloc(buf_size);
|
||||
uint8_t *buf = (uint8_t *)malloc(buf_size);
|
||||
|
||||
if (!buf) {
|
||||
return false;
|
||||
@ -327,7 +315,7 @@ void SHA1Builder::calculate(void) {
|
||||
last = total[0] & 0x3F;
|
||||
padn = (last < 56) ? (56 - last) : (120 - last);
|
||||
|
||||
add((uint8_t*)sha1_padding, padn);
|
||||
add((uint8_t *)sha1_padding, padn);
|
||||
add(msglen, 8);
|
||||
|
||||
PUT_UINT32_BE(state[0], hash, 0);
|
||||
@ -337,11 +325,11 @@ void SHA1Builder::calculate(void) {
|
||||
PUT_UINT32_BE(state[4], hash, 16);
|
||||
}
|
||||
|
||||
void SHA1Builder::getBytes(uint8_t* output) {
|
||||
void SHA1Builder::getBytes(uint8_t *output) {
|
||||
memcpy(output, hash, SHA1_HASH_SIZE);
|
||||
}
|
||||
|
||||
void SHA1Builder::getChars(char* output) {
|
||||
void SHA1Builder::getChars(char *output) {
|
||||
bytes2hex(output, SHA1_HASH_SIZE * 2 + 1, hash, SHA1_HASH_SIZE);
|
||||
}
|
||||
|
||||
|
@ -29,21 +29,21 @@ private:
|
||||
unsigned char buffer[64]; /* data block being processed */
|
||||
uint8_t hash[SHA1_HASH_SIZE]; /* SHA-1 result */
|
||||
|
||||
void process(const uint8_t* data);
|
||||
void process(const uint8_t *data);
|
||||
|
||||
public:
|
||||
void begin() override;
|
||||
|
||||
using HashBuilder::add;
|
||||
void add(const uint8_t* data, size_t len) override;
|
||||
void add(const uint8_t *data, size_t len) override;
|
||||
|
||||
using HashBuilder::addHexString;
|
||||
void addHexString(const char* data) override;
|
||||
void addHexString(const char *data) override;
|
||||
|
||||
bool addStream(Stream& stream, const size_t maxLen) override;
|
||||
bool addStream(Stream &stream, const size_t maxLen) override;
|
||||
void calculate() override;
|
||||
void getBytes(uint8_t* output) override;
|
||||
void getChars(char* output) override;
|
||||
void getBytes(uint8_t *output) override;
|
||||
void getChars(char *output) override;
|
||||
String toString() override;
|
||||
};
|
||||
|
||||
|
@ -25,7 +25,7 @@
|
||||
#include "esp32-hal.h"
|
||||
|
||||
#define PARSE_TIMEOUT 1000 // default number of milli-seconds to wait
|
||||
#define NO_SKIP_CHAR 1 // a magic char not found in a valid ASCII numeric field
|
||||
#define NO_SKIP_CHAR 1 // a magic char not found in a valid ASCII numeric field
|
||||
|
||||
// private method to read stream with timeout
|
||||
int Stream::timedRead() {
|
||||
@ -104,10 +104,10 @@ bool Stream::findUntil(const char *target, const char *terminator) {
|
||||
// returns true if target string is found, false if terminated or timed out
|
||||
bool Stream::findUntil(const char *target, size_t targetLen, const char *terminator, size_t termLen) {
|
||||
if (terminator == NULL) {
|
||||
MultiTarget t[1] = { { target, targetLen, 0 } };
|
||||
MultiTarget t[1] = {{target, targetLen, 0}};
|
||||
return findMulti(t, 1) == 0 ? true : false;
|
||||
} else {
|
||||
MultiTarget t[2] = { { target, targetLen, 0 }, { terminator, termLen, 0 } };
|
||||
MultiTarget t[2] = {{target, targetLen, 0}, {terminator, termLen, 0}};
|
||||
return findMulti(t, 2) == 0 ? true : false;
|
||||
}
|
||||
}
|
||||
@ -116,37 +116,42 @@ int Stream::findMulti(struct Stream::MultiTarget *targets, int tCount) {
|
||||
// any zero length target string automatically matches and would make
|
||||
// a mess of the rest of the algorithm.
|
||||
for (struct MultiTarget *t = targets; t < targets + tCount; ++t) {
|
||||
if (t->len <= 0)
|
||||
if (t->len <= 0) {
|
||||
return t - targets;
|
||||
}
|
||||
}
|
||||
|
||||
while (1) {
|
||||
int c = timedRead();
|
||||
if (c < 0)
|
||||
if (c < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (struct MultiTarget *t = targets; t < targets + tCount; ++t) {
|
||||
// the simple case is if we match, deal with that first.
|
||||
if (c == t->str[t->index]) {
|
||||
if (++t->index == t->len)
|
||||
if (++t->index == t->len) {
|
||||
return t - targets;
|
||||
else
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// if not we need to walk back and see if we could have matched further
|
||||
// down the stream (ie '1112' doesn't match the first position in '11112'
|
||||
// but it will match the second position so we can't just reset the current
|
||||
// index to 0 when we find a mismatch.
|
||||
if (t->index == 0)
|
||||
if (t->index == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
int origIndex = t->index;
|
||||
do {
|
||||
--t->index;
|
||||
// first check if current char works against the new current index
|
||||
if (c != t->str[t->index])
|
||||
if (c != t->str[t->index]) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// if it's the only char then we're good, nothing more to check
|
||||
if (t->index == 0) {
|
||||
@ -158,8 +163,9 @@ int Stream::findMulti(struct Stream::MultiTarget *targets, int tCount) {
|
||||
int diff = origIndex - t->index;
|
||||
size_t i;
|
||||
for (i = 0; i < t->index; ++i) {
|
||||
if (t->str[i] != t->str[i + diff])
|
||||
if (t->str[i] != t->str[i + diff]) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// if we successfully got through the previous loop then our current
|
||||
|
@ -48,8 +48,7 @@ public:
|
||||
virtual int read() = 0;
|
||||
virtual int peek() = 0;
|
||||
|
||||
Stream()
|
||||
: _startMillis(0) {
|
||||
Stream() : _startMillis(0) {
|
||||
_timeout = 1000;
|
||||
}
|
||||
virtual ~Stream() {}
|
||||
|
@ -61,5 +61,4 @@ int StreamString::peek() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
void StreamString::flush() {
|
||||
}
|
||||
void StreamString::flush() {}
|
||||
|
@ -35,5 +35,4 @@ public:
|
||||
void flush() override;
|
||||
};
|
||||
|
||||
|
||||
#endif /* STREAMSTRING_H_ */
|
||||
|
@ -20,7 +20,7 @@ typedef struct {
|
||||
unsigned long duration;
|
||||
} tone_msg_t;
|
||||
|
||||
static void tone_task(void*) {
|
||||
static void tone_task(void *) {
|
||||
tone_msg_t tone_msg;
|
||||
while (1) {
|
||||
xQueueReceive(_tone_queue, &tone_msg, portMAX_DELAY);
|
||||
@ -51,8 +51,8 @@ static void tone_task(void*) {
|
||||
break;
|
||||
|
||||
default:; // do nothing
|
||||
} // switch
|
||||
} // infinite loop
|
||||
} // switch
|
||||
} // infinite loop
|
||||
}
|
||||
|
||||
static int tone_init() {
|
||||
|
@ -60,9 +60,8 @@ static uint16_t load_dfu_descriptor(uint8_t *dst, uint8_t *itf) {
|
||||
#define DFU_ATTRS (DFU_ATTR_CAN_DOWNLOAD | DFU_ATTR_CAN_UPLOAD | DFU_ATTR_MANIFESTATION_TOLERANT)
|
||||
|
||||
uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB DFU_RT");
|
||||
uint8_t descriptor[TUD_DFU_RT_DESC_LEN] = {
|
||||
// Interface number, string index, attributes, detach timeout, transfer size */
|
||||
TUD_DFU_RT_DESCRIPTOR(*itf, str_index, DFU_ATTRS, 700, 64)
|
||||
uint8_t descriptor[TUD_DFU_RT_DESC_LEN] = {// Interface number, string index, attributes, detach timeout, transfer size */
|
||||
TUD_DFU_RT_DESCRIPTOR(*itf, str_index, DFU_ATTRS, 700, 64)
|
||||
};
|
||||
*itf += 1;
|
||||
memcpy(dst, descriptor, TUD_DFU_RT_DESC_LEN);
|
||||
@ -128,9 +127,12 @@ void tud_resume_cb(void) {
|
||||
}
|
||||
|
||||
ESPUSB::ESPUSB(size_t task_stack_size, uint8_t event_task_priority)
|
||||
: vid(USB_VID), pid(USB_PID), product_name(USB_PRODUCT), manufacturer_name(USB_MANUFACTURER), serial_number(USB_SERIAL), fw_version(0x0100), usb_version(0x0200) // at least 2.1 or 3.x for BOS & webUSB
|
||||
: vid(USB_VID), pid(USB_PID), product_name(USB_PRODUCT), manufacturer_name(USB_MANUFACTURER), serial_number(USB_SERIAL), fw_version(0x0100),
|
||||
usb_version(0x0200) // at least 2.1 or 3.x for BOS & webUSB
|
||||
,
|
||||
usb_class(TUSB_CLASS_MISC), usb_subclass(MISC_SUBCLASS_COMMON), usb_protocol(MISC_PROTOCOL_IAD), usb_attributes(TUSB_DESC_CONFIG_ATT_SELF_POWERED), usb_power_ma(500), webusb_enabled(USB_WEBUSB_ENABLED), webusb_url(USB_WEBUSB_URL), _started(false), _task_stack_size(task_stack_size), _event_task_priority(event_task_priority) {
|
||||
usb_class(TUSB_CLASS_MISC), usb_subclass(MISC_SUBCLASS_COMMON), usb_protocol(MISC_PROTOCOL_IAD), usb_attributes(TUSB_DESC_CONFIG_ATT_SELF_POWERED),
|
||||
usb_power_ma(500), webusb_enabled(USB_WEBUSB_ENABLED), webusb_url(USB_WEBUSB_URL), _started(false), _task_stack_size(task_stack_size),
|
||||
_event_task_priority(event_task_priority) {
|
||||
if (!arduino_usb_event_loop_handle) {
|
||||
esp_event_loop_args_t event_task_args = {
|
||||
.queue_size = 5,
|
||||
|
@ -79,17 +79,17 @@ public:
|
||||
bool webUSB(bool enabled);
|
||||
bool webUSB(void);
|
||||
|
||||
bool productName(const char* name);
|
||||
const char* productName(void);
|
||||
bool productName(const char *name);
|
||||
const char *productName(void);
|
||||
|
||||
bool manufacturerName(const char* name);
|
||||
const char* manufacturerName(void);
|
||||
bool manufacturerName(const char *name);
|
||||
const char *manufacturerName(void);
|
||||
|
||||
bool serialNumber(const char* name);
|
||||
const char* serialNumber(void);
|
||||
bool serialNumber(const char *name);
|
||||
const char *serialNumber(void);
|
||||
|
||||
bool webUSBURL(const char* name);
|
||||
const char* webUSBURL(void);
|
||||
bool webUSBURL(const char *name);
|
||||
const char *webUSBURL(void);
|
||||
|
||||
bool enableDFU();
|
||||
bool begin();
|
||||
@ -118,6 +118,5 @@ private:
|
||||
|
||||
extern ESPUSB USB;
|
||||
|
||||
|
||||
#endif /* CONFIG_TINYUSB_ENABLED */
|
||||
#endif /* SOC_USB_OTG_SUPPORTED */
|
||||
|
@ -18,7 +18,6 @@
|
||||
#include "USB.h"
|
||||
#if CONFIG_TINYUSB_CDC_ENABLED
|
||||
|
||||
|
||||
#include "esp32-hal-tinyusb.h"
|
||||
#include "rom/ets_sys.h"
|
||||
|
||||
@ -27,13 +26,12 @@ esp_err_t arduino_usb_event_post(esp_event_base_t event_base, int32_t event_id,
|
||||
esp_err_t arduino_usb_event_handler_register_with(esp_event_base_t event_base, int32_t event_id, esp_event_handler_t event_handler, void *event_handler_arg);
|
||||
|
||||
#define MAX_USB_CDC_DEVICES 2
|
||||
USBCDC *devices[MAX_USB_CDC_DEVICES] = { NULL, NULL };
|
||||
USBCDC *devices[MAX_USB_CDC_DEVICES] = {NULL, NULL};
|
||||
|
||||
static uint16_t load_cdc_descriptor(uint8_t *dst, uint8_t *itf) {
|
||||
uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB CDC");
|
||||
uint8_t descriptor[TUD_CDC_DESC_LEN] = {
|
||||
// Interface number, string index, EP notification address and size, EP data address (out, in) and size.
|
||||
TUD_CDC_DESCRIPTOR(*itf, str_index, 0x85, 64, 0x03, 0x84, 64)
|
||||
uint8_t descriptor[TUD_CDC_DESC_LEN] = {// Interface number, string index, EP notification address and size, EP data address (out, in) and size.
|
||||
TUD_CDC_DESCRIPTOR(*itf, str_index, 0x85, 64, 0x03, 0x84, 64)
|
||||
};
|
||||
*itf += 2;
|
||||
memcpy(dst, descriptor, TUD_CDC_DESC_LEN);
|
||||
@ -84,7 +82,8 @@ static void usb_unplugged_cb(void *arg, esp_event_base_t event_base, int32_t eve
|
||||
}
|
||||
|
||||
USBCDC::USBCDC(uint8_t itfn)
|
||||
: itf(itfn), bit_rate(0), stop_bits(0), parity(0), data_bits(0), dtr(false), rts(false), connected(false), reboot_enable(true), rx_queue(NULL), tx_lock(NULL), tx_timeout_ms(250) {
|
||||
: itf(itfn), bit_rate(0), stop_bits(0), parity(0), data_bits(0), dtr(false), rts(false), connected(false), reboot_enable(true), rx_queue(NULL), tx_lock(NULL),
|
||||
tx_timeout_ms(250) {
|
||||
tinyusb_enable_interface(USB_INTERFACE_CDC, TUD_CDC_DESC_LEN, load_cdc_descriptor);
|
||||
if (itf < MAX_USB_CDC_DEVICES) {
|
||||
arduino_usb_event_handler_register_with(ARDUINO_USB_EVENTS, ARDUINO_USB_STOPPED_EVENT, usb_unplugged_cb, this);
|
||||
@ -147,7 +146,9 @@ void USBCDC::begin(unsigned long baud) {
|
||||
tx_lock = xSemaphoreCreateMutex();
|
||||
}
|
||||
// if rx_queue was set before begin(), keep it
|
||||
if (!rx_queue) setRxBufferSize(256); //default if not preset
|
||||
if (!rx_queue) {
|
||||
setRxBufferSize(256); //default if not preset
|
||||
}
|
||||
devices[itf] = this;
|
||||
}
|
||||
|
||||
@ -175,10 +176,12 @@ void USBCDC::_onUnplugged(void) {
|
||||
}
|
||||
}
|
||||
|
||||
enum { CDC_LINE_IDLE,
|
||||
CDC_LINE_1,
|
||||
CDC_LINE_2,
|
||||
CDC_LINE_3 };
|
||||
enum {
|
||||
CDC_LINE_IDLE,
|
||||
CDC_LINE_1,
|
||||
CDC_LINE_2,
|
||||
CDC_LINE_3
|
||||
};
|
||||
void USBCDC::_onLineState(bool _dtr, bool _rts) {
|
||||
static uint8_t lineState = CDC_LINE_IDLE;
|
||||
|
||||
|
@ -140,6 +140,5 @@ protected:
|
||||
extern USBCDC USBSerial;
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* CONFIG_TINYUSB_CDC_ENABLED */
|
||||
#endif /* SOC_USB_OTG_SUPPORTED */
|
||||
|
@ -19,13 +19,12 @@
|
||||
|
||||
#include "esp32-hal-tinyusb.h"
|
||||
|
||||
extern "C" uint16_t tusb_msc_load_descriptor(uint8_t* dst, uint8_t* itf) {
|
||||
extern "C" uint16_t tusb_msc_load_descriptor(uint8_t *dst, uint8_t *itf) {
|
||||
uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB MSC");
|
||||
uint8_t ep_num = tinyusb_get_free_duplex_endpoint();
|
||||
TU_VERIFY(ep_num != 0);
|
||||
uint8_t descriptor[TUD_MSC_DESC_LEN] = {
|
||||
// Interface number, string index, EP Out & EP In address, EP size
|
||||
TUD_MSC_DESCRIPTOR(*itf, str_index, ep_num, (uint8_t)(0x80 | ep_num), 64)
|
||||
uint8_t descriptor[TUD_MSC_DESC_LEN] = {// Interface number, string index, EP Out & EP In address, EP size
|
||||
TUD_MSC_DESCRIPTOR(*itf, str_index, ep_num, (uint8_t)(0x80 | ep_num), 64)
|
||||
};
|
||||
*itf += 1;
|
||||
memcpy(dst, descriptor, TUD_MSC_DESC_LEN);
|
||||
@ -40,19 +39,19 @@ typedef struct {
|
||||
uint16_t block_size;
|
||||
uint32_t block_count;
|
||||
bool (*start_stop)(uint8_t power_condition, bool start, bool load_eject);
|
||||
int32_t (*read)(uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize);
|
||||
int32_t (*write)(uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize);
|
||||
int32_t (*read)(uint32_t lba, uint32_t offset, void *buffer, uint32_t bufsize);
|
||||
int32_t (*write)(uint32_t lba, uint32_t offset, uint8_t *buffer, uint32_t bufsize);
|
||||
} msc_lun_t;
|
||||
|
||||
static const uint8_t MSC_MAX_LUN = 3;
|
||||
static uint8_t MSC_ACTIVE_LUN = 0;
|
||||
static msc_lun_t msc_luns[MSC_MAX_LUN];
|
||||
|
||||
static void cplstr(void* dst, const void* src, size_t max_len) {
|
||||
static void cplstr(void *dst, const void *src, size_t max_len) {
|
||||
if (!src || !dst || !max_len) {
|
||||
return;
|
||||
}
|
||||
size_t l = strlen((const char*)src);
|
||||
size_t l = strlen((const char *)src);
|
||||
if (l > max_len) {
|
||||
l = max_len;
|
||||
}
|
||||
@ -83,7 +82,7 @@ bool tud_msc_test_unit_ready_cb(uint8_t lun) {
|
||||
|
||||
// Invoked when received SCSI_CMD_READ_CAPACITY_10 and SCSI_CMD_READ_FORMAT_CAPACITY to determine the disk size
|
||||
// Application update block count and block size
|
||||
void tud_msc_capacity_cb(uint8_t lun, uint32_t* block_count, uint16_t* block_size) {
|
||||
void tud_msc_capacity_cb(uint8_t lun, uint32_t *block_count, uint16_t *block_size) {
|
||||
log_v("[%u]", lun);
|
||||
if (!msc_luns[lun].media_present) {
|
||||
*block_count = 0;
|
||||
@ -108,7 +107,7 @@ bool tud_msc_start_stop_cb(uint8_t lun, uint8_t power_condition, bool start, boo
|
||||
|
||||
// Callback invoked when received READ10 command.
|
||||
// Copy disk's data to buffer (up to bufsize) and return number of copied bytes.
|
||||
int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize) {
|
||||
int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba, uint32_t offset, void *buffer, uint32_t bufsize) {
|
||||
log_v("[%u], lba: %u, offset: %u, bufsize: %u", lun, lba, offset, bufsize);
|
||||
if (!msc_luns[lun].media_present) {
|
||||
return 0;
|
||||
@ -121,7 +120,7 @@ int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba, uint32_t offset, void* buff
|
||||
|
||||
// Callback invoked when received WRITE10 command.
|
||||
// Process data in buffer to disk's storage and return number of written bytes
|
||||
int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize) {
|
||||
int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba, uint32_t offset, uint8_t *buffer, uint32_t bufsize) {
|
||||
log_v("[%u], lba: %u, offset: %u, bufsize: %u", lun, lba, offset, bufsize);
|
||||
if (!msc_luns[lun].media_present) {
|
||||
return 0;
|
||||
@ -135,11 +134,11 @@ int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba, uint32_t offset, uint8_t*
|
||||
// Callback invoked when received an SCSI command not in built-in list below
|
||||
// - READ_CAPACITY10, READ_FORMAT_CAPACITY, INQUIRY, MODE_SENSE6, REQUEST_SENSE
|
||||
// - READ10 and WRITE10 has their own callbacks
|
||||
int32_t tud_msc_scsi_cb(uint8_t lun, uint8_t const scsi_cmd[16], void* buffer, uint16_t bufsize) {
|
||||
int32_t tud_msc_scsi_cb(uint8_t lun, uint8_t const scsi_cmd[16], void *buffer, uint16_t bufsize) {
|
||||
// read10 & write10 has their own callback and MUST not be handled here
|
||||
log_v("[%u] cmd: %u, bufsize: %u", lun, scsi_cmd[0], bufsize);
|
||||
|
||||
void const* response = NULL;
|
||||
void const *response = NULL;
|
||||
uint16_t resplen = 0;
|
||||
|
||||
// most scsi handled is input
|
||||
@ -165,7 +164,9 @@ int32_t tud_msc_scsi_cb(uint8_t lun, uint8_t const scsi_cmd[16], void* buffer, u
|
||||
}
|
||||
|
||||
// return resplen must not larger than bufsize
|
||||
if (resplen > bufsize) resplen = bufsize;
|
||||
if (resplen > bufsize) {
|
||||
resplen = bufsize;
|
||||
}
|
||||
|
||||
if (response && (resplen > 0)) {
|
||||
if (in_xfer) {
|
||||
@ -222,15 +223,15 @@ void USBMSC::end() {
|
||||
msc_luns[_lun].write = NULL;
|
||||
}
|
||||
|
||||
void USBMSC::vendorID(const char* vid) {
|
||||
void USBMSC::vendorID(const char *vid) {
|
||||
cplstr(msc_luns[_lun].vendor_id, vid, 8);
|
||||
}
|
||||
|
||||
void USBMSC::productID(const char* pid) {
|
||||
void USBMSC::productID(const char *pid) {
|
||||
cplstr(msc_luns[_lun].product_id, pid, 16);
|
||||
}
|
||||
|
||||
void USBMSC::productRevision(const char* rev) {
|
||||
void USBMSC::productRevision(const char *rev) {
|
||||
cplstr(msc_luns[_lun].product_rev, rev, 4);
|
||||
}
|
||||
|
||||
|
@ -29,10 +29,10 @@
|
||||
typedef bool (*msc_start_stop_cb)(uint8_t power_condition, bool start, bool load_eject);
|
||||
|
||||
// Copy disk's data to buffer (up to bufsize) and return number of copied bytes.
|
||||
typedef int32_t (*msc_read_cb)(uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize);
|
||||
typedef int32_t (*msc_read_cb)(uint32_t lba, uint32_t offset, void *buffer, uint32_t bufsize);
|
||||
|
||||
// Process data in buffer to disk's storage and return number of written bytes
|
||||
typedef int32_t (*msc_write_cb)(uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize);
|
||||
typedef int32_t (*msc_write_cb)(uint32_t lba, uint32_t offset, uint8_t *buffer, uint32_t bufsize);
|
||||
|
||||
class USBMSC {
|
||||
public:
|
||||
@ -40,13 +40,14 @@ public:
|
||||
~USBMSC();
|
||||
bool begin(uint32_t block_count, uint16_t block_size);
|
||||
void end();
|
||||
void vendorID(const char* vid); //max 8 chars
|
||||
void productID(const char* pid); //max 16 chars
|
||||
void productRevision(const char* ver); //max 4 chars
|
||||
void vendorID(const char *vid); //max 8 chars
|
||||
void productID(const char *pid); //max 16 chars
|
||||
void productRevision(const char *ver); //max 4 chars
|
||||
void mediaPresent(bool media_present);
|
||||
void onStartStop(msc_start_stop_cb cb);
|
||||
void onRead(msc_read_cb cb);
|
||||
void onWrite(msc_write_cb cb);
|
||||
|
||||
private:
|
||||
uint8_t _lun;
|
||||
};
|
||||
|
@ -44,7 +44,7 @@ public:
|
||||
virtual uint8_t begin(uint16_t) = 0; // initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
|
||||
virtual uint8_t beginMulticast(IPAddress, uint16_t) {
|
||||
return 0;
|
||||
} // initialize, start listening on specified multicast IP address and port. Returns 1 if successful, 0 on failure
|
||||
} // initialize, start listening on specified multicast IP address and port. Returns 1 if successful, 0 on failure
|
||||
virtual void stop() = 0; // Finish with the UDP socket
|
||||
|
||||
// Sending UDP packets
|
||||
@ -54,14 +54,14 @@ public:
|
||||
virtual int beginPacket(IPAddress ip, uint16_t port) = 0;
|
||||
// Start building up a packet to send to the remote host specific in host and port
|
||||
// Returns 1 if successful, 0 if there was a problem resolving the hostname or port
|
||||
virtual int beginPacket(const char* host, uint16_t port) = 0;
|
||||
virtual int beginPacket(const char *host, uint16_t port) = 0;
|
||||
// Finish off this packet and send it
|
||||
// Returns 1 if the packet was sent successfully, 0 if there was an error
|
||||
virtual int endPacket() = 0;
|
||||
// Write a single byte into the packet
|
||||
virtual size_t write(uint8_t) = 0;
|
||||
// Write size bytes from buffer into the packet
|
||||
virtual size_t write(const uint8_t* buffer, size_t size) = 0;
|
||||
virtual size_t write(const uint8_t *buffer, size_t size) = 0;
|
||||
|
||||
// Start processing the next available incoming packet
|
||||
// Returns the size of the packet in bytes, or 0 if no packets are available
|
||||
@ -72,10 +72,10 @@ public:
|
||||
virtual int read() = 0;
|
||||
// Read up to len bytes from the current packet and place them into buffer
|
||||
// Returns the number of bytes read, or 0 if none are available
|
||||
virtual int read(unsigned char* buffer, size_t len) = 0;
|
||||
virtual int read(unsigned char *buffer, size_t len) = 0;
|
||||
// Read up to len characters from the current packet and place them into buffer
|
||||
// Returns the number of characters read, or 0 if none are available
|
||||
virtual int read(char* buffer, size_t len) = 0;
|
||||
virtual int read(char *buffer, size_t len) = 0;
|
||||
// Return the next byte from the current packet without moving on to the next byte
|
||||
virtual int peek() = 0;
|
||||
virtual void flush() = 0; // Finish reading the current packet
|
||||
@ -84,8 +84,9 @@ public:
|
||||
virtual IPAddress remoteIP() = 0;
|
||||
// Return the port of the host who sent the current incoming packet
|
||||
virtual uint16_t remotePort() = 0;
|
||||
|
||||
protected:
|
||||
uint8_t* rawIPAddress(IPAddress& addr) {
|
||||
uint8_t *rawIPAddress(IPAddress &addr) {
|
||||
return addr.raw_address();
|
||||
}
|
||||
};
|
||||
|
@ -22,7 +22,7 @@
|
||||
|
||||
#include <ctype.h>
|
||||
#define isascii(__c) ((unsigned)(__c) <= 0177)
|
||||
#define toascii(__c) ((__c)&0177)
|
||||
#define toascii(__c) ((__c) & 0177)
|
||||
|
||||
// WCharacter.h prototypes
|
||||
inline boolean isAlphaNumeric(int c) __attribute__((always_inline));
|
||||
|
@ -32,14 +32,16 @@
|
||||
|
||||
String::String(const char *cstr) {
|
||||
init();
|
||||
if (cstr)
|
||||
if (cstr) {
|
||||
copy(cstr, strlen(cstr));
|
||||
}
|
||||
}
|
||||
|
||||
String::String(const char *cstr, unsigned int length) {
|
||||
init();
|
||||
if (cstr)
|
||||
if (cstr) {
|
||||
copy(cstr, length);
|
||||
}
|
||||
}
|
||||
|
||||
String::String(const String &value) {
|
||||
@ -61,7 +63,7 @@ String::String(StringSumHelper &&rval) {
|
||||
|
||||
String::String(char c) {
|
||||
init();
|
||||
char buf[] = { c, '\0' };
|
||||
char buf[] = {c, '\0'};
|
||||
*this = buf;
|
||||
}
|
||||
|
||||
@ -154,17 +156,20 @@ inline void String::init(void) {
|
||||
}
|
||||
|
||||
void String::invalidate(void) {
|
||||
if (!isSSO() && wbuffer())
|
||||
if (!isSSO() && wbuffer()) {
|
||||
free(wbuffer());
|
||||
}
|
||||
init();
|
||||
}
|
||||
|
||||
bool String::reserve(unsigned int size) {
|
||||
if (buffer() && capacity() >= size)
|
||||
if (buffer() && capacity() >= size) {
|
||||
return true;
|
||||
}
|
||||
if (changeBuffer(size)) {
|
||||
if (len() == 0)
|
||||
if (len() == 0) {
|
||||
wbuffer()[0] = 0;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
@ -262,34 +267,39 @@ void String::move(String &rhs) {
|
||||
#endif
|
||||
|
||||
String &String::operator=(const String &rhs) {
|
||||
if (this == &rhs)
|
||||
if (this == &rhs) {
|
||||
return *this;
|
||||
if (rhs.buffer())
|
||||
}
|
||||
if (rhs.buffer()) {
|
||||
copy(rhs.buffer(), rhs.len());
|
||||
else
|
||||
} else {
|
||||
invalidate();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
String &String::operator=(String &&rval) {
|
||||
if (this != &rval)
|
||||
if (this != &rval) {
|
||||
move(rval);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
String &String::operator=(StringSumHelper &&rval) {
|
||||
if (this != &rval)
|
||||
if (this != &rval) {
|
||||
move(rval);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
|
||||
String &String::operator=(const char *cstr) {
|
||||
if (cstr)
|
||||
if (cstr) {
|
||||
copy(cstr, strlen(cstr));
|
||||
else
|
||||
} else {
|
||||
invalidate();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -302,12 +312,15 @@ bool String::concat(const String &s) {
|
||||
// realloc'ing the buffer and moving s.buffer in the method called
|
||||
if (&s == this) {
|
||||
unsigned int newlen = 2 * len();
|
||||
if (!s.buffer())
|
||||
if (!s.buffer()) {
|
||||
return false;
|
||||
if (s.len() == 0)
|
||||
}
|
||||
if (s.len() == 0) {
|
||||
return true;
|
||||
if (!reserve(newlen))
|
||||
}
|
||||
if (!reserve(newlen)) {
|
||||
return false;
|
||||
}
|
||||
memmove(wbuffer() + len(), buffer(), len());
|
||||
setLen(newlen);
|
||||
wbuffer()[len()] = 0;
|
||||
@ -319,30 +332,35 @@ bool String::concat(const String &s) {
|
||||
|
||||
bool String::concat(const char *cstr, unsigned int length) {
|
||||
unsigned int newlen = len() + length;
|
||||
if (!cstr)
|
||||
if (!cstr) {
|
||||
return false;
|
||||
if (length == 0)
|
||||
}
|
||||
if (length == 0) {
|
||||
return true;
|
||||
if (!reserve(newlen))
|
||||
}
|
||||
if (!reserve(newlen)) {
|
||||
return false;
|
||||
if (cstr >= wbuffer() && cstr < wbuffer() + len())
|
||||
}
|
||||
if (cstr >= wbuffer() && cstr < wbuffer() + len()) {
|
||||
// compatible with SSO in ram #6155 (case "x += x.c_str()")
|
||||
memmove(wbuffer() + len(), cstr, length + 1);
|
||||
else
|
||||
} else {
|
||||
// compatible with source in flash #6367
|
||||
memcpy_P(wbuffer() + len(), cstr, length + 1);
|
||||
}
|
||||
setLen(newlen);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool String::concat(const char *cstr) {
|
||||
if (!cstr)
|
||||
if (!cstr) {
|
||||
return false;
|
||||
}
|
||||
return concat(cstr, strlen(cstr));
|
||||
}
|
||||
|
||||
bool String::concat(char c) {
|
||||
char buf[] = { c, '\0' };
|
||||
char buf[] = {c, '\0'};
|
||||
return concat(buf, 1);
|
||||
}
|
||||
|
||||
@ -406,85 +424,97 @@ bool String::concat(double num) {
|
||||
|
||||
StringSumHelper &operator+(const StringSumHelper &lhs, const String &rhs) {
|
||||
StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
|
||||
if (!a.concat(rhs.buffer(), rhs.len()))
|
||||
if (!a.concat(rhs.buffer(), rhs.len())) {
|
||||
a.invalidate();
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
StringSumHelper &operator+(const StringSumHelper &lhs, const char *cstr) {
|
||||
StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
|
||||
if (!cstr || !a.concat(cstr, strlen(cstr)))
|
||||
if (!cstr || !a.concat(cstr, strlen(cstr))) {
|
||||
a.invalidate();
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
StringSumHelper &operator+(const StringSumHelper &lhs, char c) {
|
||||
StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
|
||||
if (!a.concat(c))
|
||||
if (!a.concat(c)) {
|
||||
a.invalidate();
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
StringSumHelper &operator+(const StringSumHelper &lhs, unsigned char num) {
|
||||
StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
|
||||
if (!a.concat(num))
|
||||
if (!a.concat(num)) {
|
||||
a.invalidate();
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
StringSumHelper &operator+(const StringSumHelper &lhs, int num) {
|
||||
StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
|
||||
if (!a.concat(num))
|
||||
if (!a.concat(num)) {
|
||||
a.invalidate();
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
StringSumHelper &operator+(const StringSumHelper &lhs, unsigned int num) {
|
||||
StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
|
||||
if (!a.concat(num))
|
||||
if (!a.concat(num)) {
|
||||
a.invalidate();
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
StringSumHelper &operator+(const StringSumHelper &lhs, long num) {
|
||||
StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
|
||||
if (!a.concat(num))
|
||||
if (!a.concat(num)) {
|
||||
a.invalidate();
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
StringSumHelper &operator+(const StringSumHelper &lhs, unsigned long num) {
|
||||
StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
|
||||
if (!a.concat(num))
|
||||
if (!a.concat(num)) {
|
||||
a.invalidate();
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
StringSumHelper &operator+(const StringSumHelper &lhs, float num) {
|
||||
StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
|
||||
if (!a.concat(num))
|
||||
if (!a.concat(num)) {
|
||||
a.invalidate();
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
StringSumHelper &operator+(const StringSumHelper &lhs, double num) {
|
||||
StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
|
||||
if (!a.concat(num))
|
||||
if (!a.concat(num)) {
|
||||
a.invalidate();
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
StringSumHelper &operator+(const StringSumHelper &lhs, long long num) {
|
||||
StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
|
||||
if (!a.concat(num))
|
||||
if (!a.concat(num)) {
|
||||
a.invalidate();
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
StringSumHelper &operator+(const StringSumHelper &lhs, unsigned long long num) {
|
||||
StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
|
||||
if (!a.concat(num))
|
||||
if (!a.concat(num)) {
|
||||
a.invalidate();
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
@ -494,10 +524,12 @@ StringSumHelper &operator+(const StringSumHelper &lhs, unsigned long long num) {
|
||||
|
||||
int String::compareTo(const String &s) const {
|
||||
if (!buffer() || !s.buffer()) {
|
||||
if (s.buffer() && s.len() > 0)
|
||||
if (s.buffer() && s.len() > 0) {
|
||||
return 0 - *(unsigned char *)s.buffer();
|
||||
if (buffer() && len() > 0)
|
||||
}
|
||||
if (buffer() && len() > 0) {
|
||||
return *(unsigned char *)buffer();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
return strcmp(buffer(), s.buffer());
|
||||
@ -508,10 +540,12 @@ bool String::equals(const String &s2) const {
|
||||
}
|
||||
|
||||
bool String::equals(const char *cstr) const {
|
||||
if (len() == 0)
|
||||
if (len() == 0) {
|
||||
return (cstr == NULL || *cstr == 0);
|
||||
if (cstr == NULL)
|
||||
}
|
||||
if (cstr == NULL) {
|
||||
return buffer()[0] == 0;
|
||||
}
|
||||
return strcmp(buffer(), cstr) == 0;
|
||||
}
|
||||
|
||||
@ -532,17 +566,21 @@ bool String::operator>=(const String &rhs) const {
|
||||
}
|
||||
|
||||
bool String::equalsIgnoreCase(const String &s2) const {
|
||||
if (this == &s2)
|
||||
if (this == &s2) {
|
||||
return true;
|
||||
if (len() != s2.len())
|
||||
}
|
||||
if (len() != s2.len()) {
|
||||
return false;
|
||||
if (len() == 0)
|
||||
}
|
||||
if (len() == 0) {
|
||||
return true;
|
||||
}
|
||||
const char *p1 = buffer();
|
||||
const char *p2 = s2.buffer();
|
||||
while (*p1) {
|
||||
if (tolower(*p1++) != tolower(*p2++))
|
||||
if (tolower(*p1++) != tolower(*p2++)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
@ -550,21 +588,24 @@ bool String::equalsIgnoreCase(const String &s2) const {
|
||||
unsigned char String::equalsConstantTime(const String &s2) const {
|
||||
// To avoid possible time-based attacks present function
|
||||
// compares given strings in a constant time.
|
||||
if (len() != s2.len())
|
||||
if (len() != s2.len()) {
|
||||
return 0;
|
||||
}
|
||||
//at this point lengths are the same
|
||||
if (len() == 0)
|
||||
if (len() == 0) {
|
||||
return 1;
|
||||
}
|
||||
//at this point lengths are the same and non-zero
|
||||
const char *p1 = buffer();
|
||||
const char *p2 = s2.buffer();
|
||||
unsigned int equalchars = 0;
|
||||
unsigned int diffchars = 0;
|
||||
while (*p1) {
|
||||
if (*p1 == *p2)
|
||||
if (*p1 == *p2) {
|
||||
++equalchars;
|
||||
else
|
||||
} else {
|
||||
++diffchars;
|
||||
}
|
||||
++p1;
|
||||
++p2;
|
||||
}
|
||||
@ -575,20 +616,23 @@ unsigned char String::equalsConstantTime(const String &s2) const {
|
||||
}
|
||||
|
||||
bool String::startsWith(const String &s2) const {
|
||||
if (len() < s2.len())
|
||||
if (len() < s2.len()) {
|
||||
return false;
|
||||
}
|
||||
return startsWith(s2, 0);
|
||||
}
|
||||
|
||||
bool String::startsWith(const String &s2, unsigned int offset) const {
|
||||
if (offset > (unsigned)(len() - s2.len()) || !buffer() || !s2.buffer())
|
||||
if (offset > (unsigned)(len() - s2.len()) || !buffer() || !s2.buffer()) {
|
||||
return false;
|
||||
}
|
||||
return strncmp(&buffer()[offset], s2.buffer(), s2.len()) == 0;
|
||||
}
|
||||
|
||||
bool String::endsWith(const String &s2) const {
|
||||
if (len() < s2.len() || !buffer() || !s2.buffer())
|
||||
if (len() < s2.len() || !buffer() || !s2.buffer()) {
|
||||
return false;
|
||||
}
|
||||
return strcmp(&buffer()[len() - s2.len()], s2.buffer()) == 0;
|
||||
}
|
||||
|
||||
@ -601,8 +645,9 @@ char String::charAt(unsigned int loc) const {
|
||||
}
|
||||
|
||||
void String::setCharAt(unsigned int loc, char c) {
|
||||
if (loc < len())
|
||||
if (loc < len()) {
|
||||
wbuffer()[loc] = c;
|
||||
}
|
||||
}
|
||||
|
||||
char &String::operator[](unsigned int index) {
|
||||
@ -615,21 +660,24 @@ char &String::operator[](unsigned int index) {
|
||||
}
|
||||
|
||||
char String::operator[](unsigned int index) const {
|
||||
if (index >= len() || !buffer())
|
||||
if (index >= len() || !buffer()) {
|
||||
return 0;
|
||||
}
|
||||
return buffer()[index];
|
||||
}
|
||||
|
||||
void String::getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index) const {
|
||||
if (!bufsize || !buf)
|
||||
if (!bufsize || !buf) {
|
||||
return;
|
||||
}
|
||||
if (index >= len()) {
|
||||
buf[0] = 0;
|
||||
return;
|
||||
}
|
||||
unsigned int n = bufsize - 1;
|
||||
if (n > len() - index)
|
||||
if (n > len() - index) {
|
||||
n = len() - index;
|
||||
}
|
||||
strncpy((char *)buf, buffer() + index, n);
|
||||
buf[n] = 0;
|
||||
}
|
||||
@ -643,11 +691,13 @@ int String::indexOf(char c) const {
|
||||
}
|
||||
|
||||
int String::indexOf(char ch, unsigned int fromIndex) const {
|
||||
if (fromIndex >= len())
|
||||
if (fromIndex >= len()) {
|
||||
return -1;
|
||||
}
|
||||
const char *temp = strchr(buffer() + fromIndex, ch);
|
||||
if (temp == NULL)
|
||||
if (temp == NULL) {
|
||||
return -1;
|
||||
}
|
||||
return temp - buffer();
|
||||
}
|
||||
|
||||
@ -656,11 +706,13 @@ int String::indexOf(const String &s2) const {
|
||||
}
|
||||
|
||||
int String::indexOf(const String &s2, unsigned int fromIndex) const {
|
||||
if (fromIndex >= len())
|
||||
if (fromIndex >= len()) {
|
||||
return -1;
|
||||
}
|
||||
const char *found = strstr(buffer() + fromIndex, s2.buffer());
|
||||
if (found == NULL)
|
||||
if (found == NULL) {
|
||||
return -1;
|
||||
}
|
||||
return found - buffer();
|
||||
}
|
||||
|
||||
@ -669,17 +721,20 @@ int String::lastIndexOf(char theChar) const {
|
||||
}
|
||||
|
||||
int String::lastIndexOf(char ch, unsigned int fromIndex) const {
|
||||
if (fromIndex >= len())
|
||||
if (fromIndex >= len()) {
|
||||
return -1;
|
||||
}
|
||||
char tempchar = buffer()[fromIndex + 1];
|
||||
wbuffer()[fromIndex + 1] = '\0';
|
||||
char *temp = strrchr(wbuffer(), ch);
|
||||
wbuffer()[fromIndex + 1] = tempchar;
|
||||
if (temp == NULL)
|
||||
if (temp == NULL) {
|
||||
return -1;
|
||||
}
|
||||
const int rv = temp - buffer();
|
||||
if (rv >= len())
|
||||
if (rv >= len()) {
|
||||
return -1;
|
||||
}
|
||||
return rv;
|
||||
}
|
||||
|
||||
@ -688,17 +743,21 @@ int String::lastIndexOf(const String &s2) const {
|
||||
}
|
||||
|
||||
int String::lastIndexOf(const String &s2, unsigned int fromIndex) const {
|
||||
if (s2.len() == 0 || len() == 0 || s2.len() > len())
|
||||
if (s2.len() == 0 || len() == 0 || s2.len() > len()) {
|
||||
return -1;
|
||||
if (fromIndex >= len())
|
||||
}
|
||||
if (fromIndex >= len()) {
|
||||
fromIndex = len() - 1;
|
||||
}
|
||||
int found = -1;
|
||||
for (char *p = wbuffer(); p <= wbuffer() + fromIndex; p++) {
|
||||
p = strstr(p, s2.buffer());
|
||||
if (!p)
|
||||
if (!p) {
|
||||
break;
|
||||
if ((unsigned int)(p - wbuffer()) <= fromIndex)
|
||||
}
|
||||
if ((unsigned int)(p - wbuffer()) <= fromIndex) {
|
||||
found = p - buffer();
|
||||
}
|
||||
}
|
||||
return found;
|
||||
}
|
||||
@ -710,10 +769,12 @@ String String::substring(unsigned int left, unsigned int right) const {
|
||||
left = temp;
|
||||
}
|
||||
String out;
|
||||
if (left >= len())
|
||||
if (left >= len()) {
|
||||
return out;
|
||||
if (right > len())
|
||||
}
|
||||
if (right > len()) {
|
||||
right = len();
|
||||
}
|
||||
out.copy(buffer() + left, right - left);
|
||||
return out;
|
||||
}
|
||||
@ -723,17 +784,20 @@ String String::substring(unsigned int left, unsigned int right) const {
|
||||
/*********************************************/
|
||||
|
||||
void String::replace(char find, char replace) {
|
||||
if (!buffer())
|
||||
if (!buffer()) {
|
||||
return;
|
||||
}
|
||||
for (char *p = wbuffer(); *p; p++) {
|
||||
if (*p == find)
|
||||
if (*p == find) {
|
||||
*p = replace;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void String::replace(const String &find, const String &replace) {
|
||||
if (len() == 0 || find.len() == 0)
|
||||
if (len() == 0 || find.len() == 0) {
|
||||
return;
|
||||
}
|
||||
int diff = replace.len() - find.len();
|
||||
char *readFrom = wbuffer();
|
||||
char *foundAt;
|
||||
@ -762,8 +826,9 @@ void String::replace(const String &find, const String &replace) {
|
||||
readFrom = foundAt + find.len();
|
||||
size += diff;
|
||||
}
|
||||
if (size == len())
|
||||
if (size == len()) {
|
||||
return;
|
||||
}
|
||||
if (size > capacity() && !changeBuffer(size)) {
|
||||
log_w("String.Replace() Insufficient space to replace string");
|
||||
return;
|
||||
@ -806,33 +871,39 @@ void String::remove(unsigned int index, unsigned int count) {
|
||||
}
|
||||
|
||||
void String::toLowerCase(void) {
|
||||
if (!buffer())
|
||||
if (!buffer()) {
|
||||
return;
|
||||
}
|
||||
for (char *p = wbuffer(); *p; p++) {
|
||||
*p = tolower(*p);
|
||||
}
|
||||
}
|
||||
|
||||
void String::toUpperCase(void) {
|
||||
if (!buffer())
|
||||
if (!buffer()) {
|
||||
return;
|
||||
}
|
||||
for (char *p = wbuffer(); *p; p++) {
|
||||
*p = toupper(*p);
|
||||
}
|
||||
}
|
||||
|
||||
void String::trim(void) {
|
||||
if (!buffer() || len() == 0)
|
||||
if (!buffer() || len() == 0) {
|
||||
return;
|
||||
}
|
||||
char *begin = wbuffer();
|
||||
while (isspace(*begin))
|
||||
while (isspace(*begin)) {
|
||||
begin++;
|
||||
}
|
||||
char *end = wbuffer() + len() - 1;
|
||||
while (isspace(*end) && end >= begin)
|
||||
while (isspace(*end) && end >= begin) {
|
||||
end--;
|
||||
}
|
||||
unsigned int newlen = end + 1 - begin;
|
||||
if (begin > buffer())
|
||||
if (begin > buffer()) {
|
||||
memmove(wbuffer(), begin, newlen);
|
||||
}
|
||||
setLen(newlen);
|
||||
wbuffer()[newlen] = 0;
|
||||
}
|
||||
@ -842,20 +913,23 @@ void String::trim(void) {
|
||||
/*********************************************/
|
||||
|
||||
long String::toInt(void) const {
|
||||
if (buffer())
|
||||
if (buffer()) {
|
||||
return atol(buffer());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
float String::toFloat(void) const {
|
||||
if (buffer())
|
||||
if (buffer()) {
|
||||
return atof(buffer());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
double String::toDouble(void) const {
|
||||
if (buffer())
|
||||
if (buffer()) {
|
||||
return atof(buffer());
|
||||
}
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
|
@ -30,12 +30,11 @@
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
|
||||
|
||||
// A pure abstract class forward used as a means to proide a unique pointer type
|
||||
// but really is never defined.
|
||||
class __FlashStringHelper;
|
||||
#define FPSTR(str_pointer) (reinterpret_cast<const __FlashStringHelper *>(str_pointer))
|
||||
#define F(string_literal) (FPSTR(PSTR(string_literal)))
|
||||
#define F(string_literal) (FPSTR(PSTR(string_literal)))
|
||||
|
||||
// An inherited class for holding the result of a concatenation. These
|
||||
// result objects are assumed to be writable by subsequent concatenations.
|
||||
@ -47,8 +46,7 @@ class String {
|
||||
// complications of an operator bool(). for more information, see:
|
||||
// http://www.artima.com/cppsource/safebool.html
|
||||
typedef void (String::*StringIfHelperType)() const;
|
||||
void StringIfHelper() const {
|
||||
}
|
||||
void StringIfHelper() const {}
|
||||
|
||||
public:
|
||||
// constructors
|
||||
@ -59,12 +57,10 @@ public:
|
||||
String(const char *cstr = "");
|
||||
String(const char *cstr, unsigned int length);
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
String(const uint8_t *cstr, unsigned int length)
|
||||
: String(reinterpret_cast<const char *>(cstr), length) {}
|
||||
String(const uint8_t *cstr, unsigned int length) : String(reinterpret_cast<const char *>(cstr), length) {}
|
||||
#endif
|
||||
String(const String &str);
|
||||
String(const __FlashStringHelper *str)
|
||||
: String(reinterpret_cast<const char *>(str)) {}
|
||||
String(const __FlashStringHelper *str) : String(reinterpret_cast<const char *>(str)) {}
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
String(String &&rval);
|
||||
String(StringSumHelper &&rval);
|
||||
@ -322,16 +318,22 @@ protected:
|
||||
uint32_t len;
|
||||
};
|
||||
// This allows strings up up to 11 (10 + \0 termination) without any extra space.
|
||||
enum { SSOSIZE = sizeof(struct _ptr) + 4 - 1 }; // Characters to allocate space for SSO, must be 12 or more
|
||||
enum {
|
||||
SSOSIZE = sizeof(struct _ptr) + 4 - 1
|
||||
}; // Characters to allocate space for SSO, must be 12 or more
|
||||
struct _sso {
|
||||
char buff[SSOSIZE];
|
||||
unsigned char len : 7; // Ensure only one byte is allocated by GCC for the bitfields
|
||||
unsigned char len : 7; // Ensure only one byte is allocated by GCC for the bitfields
|
||||
unsigned char isSSO : 1;
|
||||
} __attribute__((packed)); // Ensure that GCC doesn't expand the flag byte to a 32-bit word for alignment issues
|
||||
#ifdef BOARD_HAS_PSRAM
|
||||
enum { CAPACITY_MAX = 3145728 };
|
||||
enum {
|
||||
CAPACITY_MAX = 3145728
|
||||
};
|
||||
#else
|
||||
enum { CAPACITY_MAX = 65535 };
|
||||
enum {
|
||||
CAPACITY_MAX = 65535
|
||||
};
|
||||
#endif
|
||||
union {
|
||||
struct _ptr ptr;
|
||||
@ -362,10 +364,14 @@ protected:
|
||||
}
|
||||
}
|
||||
inline void setCapacity(int cap) {
|
||||
if (!isSSO()) ptr.cap = cap;
|
||||
if (!isSSO()) {
|
||||
ptr.cap = cap;
|
||||
}
|
||||
}
|
||||
inline void setBuffer(char *buff) {
|
||||
if (!isSSO()) ptr.buff = buff;
|
||||
if (!isSSO()) {
|
||||
ptr.buff = buff;
|
||||
}
|
||||
}
|
||||
// Buffer accessor functions
|
||||
inline const char *buffer() const {
|
||||
@ -392,42 +398,18 @@ protected:
|
||||
|
||||
class StringSumHelper : public String {
|
||||
public:
|
||||
StringSumHelper(const String &s)
|
||||
: String(s) {
|
||||
}
|
||||
StringSumHelper(const char *p)
|
||||
: String(p) {
|
||||
}
|
||||
StringSumHelper(char c)
|
||||
: String(c) {
|
||||
}
|
||||
StringSumHelper(unsigned char num)
|
||||
: String(num) {
|
||||
}
|
||||
StringSumHelper(int num)
|
||||
: String(num) {
|
||||
}
|
||||
StringSumHelper(unsigned int num)
|
||||
: String(num) {
|
||||
}
|
||||
StringSumHelper(long num)
|
||||
: String(num) {
|
||||
}
|
||||
StringSumHelper(unsigned long num)
|
||||
: String(num) {
|
||||
}
|
||||
StringSumHelper(float num)
|
||||
: String(num) {
|
||||
}
|
||||
StringSumHelper(double num)
|
||||
: String(num) {
|
||||
}
|
||||
StringSumHelper(long long num)
|
||||
: String(num) {
|
||||
}
|
||||
StringSumHelper(unsigned long long num)
|
||||
: String(num) {
|
||||
}
|
||||
StringSumHelper(const String &s) : String(s) {}
|
||||
StringSumHelper(const char *p) : String(p) {}
|
||||
StringSumHelper(char c) : String(c) {}
|
||||
StringSumHelper(unsigned char num) : String(num) {}
|
||||
StringSumHelper(int num) : String(num) {}
|
||||
StringSumHelper(unsigned int num) : String(num) {}
|
||||
StringSumHelper(long num) : String(num) {}
|
||||
StringSumHelper(unsigned long num) : String(num) {}
|
||||
StringSumHelper(float num) : String(num) {}
|
||||
StringSumHelper(double num) : String(num) {}
|
||||
StringSumHelper(long long num) : String(num) {}
|
||||
StringSumHelper(unsigned long long num) : String(num) {}
|
||||
};
|
||||
|
||||
inline StringSumHelper &operator+(const StringSumHelper &lhs, const __FlashStringHelper *rhs) {
|
||||
|
@ -3,10 +3,10 @@
|
||||
|
||||
class base64 {
|
||||
public:
|
||||
static String encode(const uint8_t* data, size_t length);
|
||||
static String encode(const String& text);
|
||||
static String encode(const uint8_t *data, size_t length);
|
||||
static String encode(const String &text);
|
||||
|
||||
private:
|
||||
};
|
||||
|
||||
|
||||
#endif /* CORE_BASE64_H_ */
|
||||
|
@ -27,28 +27,30 @@
|
||||
#define CBUF_MUTEX_UNLOCK()
|
||||
#define CBUF_MUTEX_DELETE()
|
||||
#else
|
||||
#define CBUF_MUTEX_CREATE() \
|
||||
if (_lock == NULL) { \
|
||||
_lock = xSemaphoreCreateMutex(); \
|
||||
if (_lock == NULL) { log_e("failed to create mutex"); } \
|
||||
#define CBUF_MUTEX_CREATE() \
|
||||
if (_lock == NULL) { \
|
||||
_lock = xSemaphoreCreateMutex(); \
|
||||
if (_lock == NULL) { \
|
||||
log_e("failed to create mutex"); \
|
||||
} \
|
||||
}
|
||||
#define CBUF_MUTEX_LOCK() \
|
||||
if (_lock != NULL) { xSemaphoreTakeRecursive(_lock, portMAX_DELAY); }
|
||||
#define CBUF_MUTEX_UNLOCK() \
|
||||
if (_lock != NULL) { xSemaphoreGiveRecursive(_lock); }
|
||||
#define CBUF_MUTEX_DELETE() \
|
||||
if (_lock != NULL) { \
|
||||
#define CBUF_MUTEX_LOCK() \
|
||||
if (_lock != NULL) { \
|
||||
xSemaphoreTakeRecursive(_lock, portMAX_DELAY); \
|
||||
}
|
||||
#define CBUF_MUTEX_UNLOCK() \
|
||||
if (_lock != NULL) { \
|
||||
xSemaphoreGiveRecursive(_lock); \
|
||||
}
|
||||
#define CBUF_MUTEX_DELETE() \
|
||||
if (_lock != NULL) { \
|
||||
SemaphoreHandle_t l = _lock; \
|
||||
_lock = NULL; \
|
||||
vSemaphoreDelete(l); \
|
||||
_lock = NULL; \
|
||||
vSemaphoreDelete(l); \
|
||||
}
|
||||
#endif
|
||||
|
||||
cbuf::cbuf(size_t size)
|
||||
: next(NULL),
|
||||
has_peek(false),
|
||||
peek_byte(0),
|
||||
_buf(xRingbufferCreate(size, RINGBUF_TYPE_BYTEBUF)) {
|
||||
cbuf::cbuf(size_t size) : next(NULL), has_peek(false), peek_byte(0), _buf(xRingbufferCreate(size, RINGBUF_TYPE_BYTEBUF)) {
|
||||
if (_buf == NULL) {
|
||||
log_e("failed to allocate ring buffer");
|
||||
}
|
||||
@ -136,7 +138,9 @@ size_t cbuf::available() const {
|
||||
if (_buf != NULL) {
|
||||
vRingbufferGetInfo(_buf, NULL, NULL, NULL, NULL, (UBaseType_t *)&available);
|
||||
}
|
||||
if (has_peek) available++;
|
||||
if (has_peek) {
|
||||
available++;
|
||||
}
|
||||
return available;
|
||||
}
|
||||
|
||||
|
@ -45,15 +45,15 @@ public:
|
||||
int peek();
|
||||
|
||||
int read();
|
||||
size_t read(char* dst, size_t size);
|
||||
size_t read(char *dst, size_t size);
|
||||
|
||||
size_t write(char c);
|
||||
size_t write(const char* src, size_t size);
|
||||
size_t write(const char *src, size_t size);
|
||||
|
||||
void flush();
|
||||
size_t remove(size_t size);
|
||||
|
||||
cbuf* next;
|
||||
cbuf *next;
|
||||
bool has_peek;
|
||||
uint8_t peek_byte;
|
||||
|
||||
|
@ -20,9 +20,9 @@
|
||||
#define chip_report_printf log_printf
|
||||
|
||||
#define printMemCapsInfo(caps) _printMemCapsInfo(MALLOC_CAP_##caps, #caps)
|
||||
#define b2kb(b) ((float)b / 1024.0)
|
||||
#define b2mb(b) ((float)b / (1024.0 * 1024.0))
|
||||
static void _printMemCapsInfo(uint32_t caps, const char* caps_str) {
|
||||
#define b2kb(b) ((float)b / 1024.0)
|
||||
#define b2mb(b) ((float)b / (1024.0 * 1024.0))
|
||||
static void _printMemCapsInfo(uint32_t caps, const char *caps_str) {
|
||||
multi_heap_info_t info;
|
||||
size_t total = heap_caps_get_total_size(caps);
|
||||
heap_caps_get_info(&info, caps);
|
||||
@ -41,18 +41,18 @@ static void printPkgVersion(void) {
|
||||
uint32_t pkg_ver = REG_GET_FIELD(EFUSE_BLK0_RDATA3_REG, EFUSE_RD_CHIP_PACKAGE);
|
||||
switch (pkg_ver) {
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDR2V3: chip_report_printf("D0WD-R2-V3"); break;
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ6: chip_report_printf("D0WD-Q6"); break;
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ5: chip_report_printf("D0WD-Q5"); break;
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D2WDQ5: chip_report_printf("D2WD-Q5"); break;
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32U4WDH: chip_report_printf("U4WD-H"); break;
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD4: chip_report_printf("PICO-D4"); break;
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ6: chip_report_printf("D0WD-Q6"); break;
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ5: chip_report_printf("D0WD-Q5"); break;
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32D2WDQ5: chip_report_printf("D2WD-Q5"); break;
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32U4WDH: chip_report_printf("U4WD-H"); break;
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD4: chip_report_printf("PICO-D4"); break;
|
||||
case EFUSE_RD_CHIP_VER_PKG_ESP32PICOV302: chip_report_printf("PICO-V3-02"); break;
|
||||
}
|
||||
#elif CONFIG_IDF_TARGET_ESP32S2
|
||||
uint32_t pkg_ver = REG_GET_FIELD(EFUSE_RD_MAC_SPI_SYS_3_REG, EFUSE_PKG_VERSION);
|
||||
switch (pkg_ver) {
|
||||
case 1: chip_report_printf("FH16"); break;
|
||||
case 2: chip_report_printf("FH32"); break;
|
||||
case 1: chip_report_printf("FH16"); break;
|
||||
case 2: chip_report_printf("FH32"); break;
|
||||
default: chip_report_printf("%lu", pkg_ver); break;
|
||||
}
|
||||
#elif CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6
|
||||
@ -77,14 +77,14 @@ static void printChipInfo(void) {
|
||||
chip_report_printf("------------------------------------------\n");
|
||||
chip_report_printf(" Model : ");
|
||||
switch (info.model) {
|
||||
case CHIP_ESP32: chip_report_printf("ESP32\n"); break;
|
||||
case CHIP_ESP32: chip_report_printf("ESP32\n"); break;
|
||||
case CHIP_ESP32S2: chip_report_printf("ESP32-S2\n"); break;
|
||||
case CHIP_ESP32S3: chip_report_printf("ESP32-S3\n"); break;
|
||||
case CHIP_ESP32C2: chip_report_printf("ESP32-C2\n"); break;
|
||||
case CHIP_ESP32C3: chip_report_printf("ESP32-C3\n"); break;
|
||||
case CHIP_ESP32C6: chip_report_printf("ESP32-C6\n"); break;
|
||||
case CHIP_ESP32H2: chip_report_printf("ESP32-H2\n"); break;
|
||||
default: chip_report_printf("Unknown %d\n", info.model); break;
|
||||
default: chip_report_printf("Unknown %d\n", info.model); break;
|
||||
}
|
||||
printPkgVersion();
|
||||
chip_report_printf(" Revision : ");
|
||||
@ -114,7 +114,7 @@ static void printFlashInfo(void) {
|
||||
// REG_SPI_BASE is not defined for S3/C3 ??
|
||||
#if CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C3
|
||||
#ifndef REG_SPI_BASE
|
||||
#define REG_SPI_BASE(i) (DR_REG_SPI1_BASE + (((i) > 1) ? (((i)*0x1000) + 0x20000) : (((~(i)) & 1) * 0x1000)))
|
||||
#define REG_SPI_BASE(i) (DR_REG_SPI1_BASE + (((i) > 1) ? (((i) * 0x1000) + 0x20000) : (((~(i)) & 1) * 0x1000)))
|
||||
#endif // REG_SPI_BASE
|
||||
#endif // TARGET
|
||||
|
||||
@ -126,7 +126,7 @@ static void printFlashInfo(void) {
|
||||
chip_report_printf(" Sector Size : %8lu B (%6.1f KB)\n", g_rom_flashchip.sector_size, b2kb(g_rom_flashchip.sector_size));
|
||||
chip_report_printf(" Page Size : %8lu B (%6.1f KB)\n", g_rom_flashchip.page_size, b2kb(g_rom_flashchip.page_size));
|
||||
esp_image_header_t fhdr;
|
||||
esp_flash_read(esp_flash_default_chip, (void*)&fhdr, ESP_FLASH_IMAGE_BASE, sizeof(esp_image_header_t));
|
||||
esp_flash_read(esp_flash_default_chip, (void *)&fhdr, ESP_FLASH_IMAGE_BASE, sizeof(esp_image_header_t));
|
||||
if (fhdr.magic == ESP_IMAGE_HEADER_MAGIC) {
|
||||
uint32_t f_freq = 0;
|
||||
switch (fhdr.spi_speed) {
|
||||
@ -165,7 +165,7 @@ static void printPartitionsInfo(void) {
|
||||
if (iterator != NULL) {
|
||||
esp_partition_iterator_t it = iterator;
|
||||
while (it != NULL) {
|
||||
const esp_partition_t* partition = esp_partition_get(it);
|
||||
const esp_partition_t *partition = esp_partition_get(it);
|
||||
if (partition) {
|
||||
chip_report_printf(" %17s : addr: 0x%08X, size: %7.1f KB", partition->label, partition->address, b2kb(partition->size));
|
||||
if (partition->type == ESP_PARTITION_TYPE_APP) {
|
||||
@ -183,18 +183,18 @@ static void printPartitionsInfo(void) {
|
||||
chip_report_printf(", type: DATA");
|
||||
chip_report_printf(", subtype: ");
|
||||
switch (partition->subtype) {
|
||||
case ESP_PARTITION_SUBTYPE_DATA_OTA: chip_report_printf("OTA"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_PHY: chip_report_printf("PHY"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_NVS: chip_report_printf("NVS"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_COREDUMP: chip_report_printf("COREDUMP"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_NVS_KEYS: chip_report_printf("NVS_KEYS"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_EFUSE_EM: chip_report_printf("EFUSE_EM"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_OTA: chip_report_printf("OTA"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_PHY: chip_report_printf("PHY"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_NVS: chip_report_printf("NVS"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_COREDUMP: chip_report_printf("COREDUMP"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_NVS_KEYS: chip_report_printf("NVS_KEYS"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_EFUSE_EM: chip_report_printf("EFUSE_EM"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_UNDEFINED: chip_report_printf("UNDEFINED"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_ESPHTTPD: chip_report_printf("ESPHTTPD"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_FAT: chip_report_printf("FAT"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_SPIFFS: chip_report_printf("SPIFFS"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_LITTLEFS: chip_report_printf("LITTLEFS"); break;
|
||||
default: chip_report_printf("0x%02X", partition->subtype); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_ESPHTTPD: chip_report_printf("ESPHTTPD"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_FAT: chip_report_printf("FAT"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_SPIFFS: chip_report_printf("SPIFFS"); break;
|
||||
case ESP_PARTITION_SUBTYPE_DATA_LITTLEFS: chip_report_printf("LITTLEFS"); break;
|
||||
default: chip_report_printf("0x%02X", partition->subtype); break;
|
||||
}
|
||||
}
|
||||
chip_report_printf("\n");
|
||||
@ -267,7 +267,7 @@ static void printPerimanInfo(void) {
|
||||
#else
|
||||
chip_report_printf(" %4u : ", i);
|
||||
#endif
|
||||
const char* extra_type = perimanGetPinBusExtraType(i);
|
||||
const char *extra_type = perimanGetPinBusExtraType(i);
|
||||
if (extra_type) {
|
||||
chip_report_printf("%s", extra_type);
|
||||
} else {
|
||||
@ -290,7 +290,9 @@ void printBeforeSetupInfo(void) {
|
||||
Serial.begin(0);
|
||||
Serial.setDebugOutput(true);
|
||||
uint8_t t = 0;
|
||||
while (!Serial && (t++ < 200)) delay(10); //wait up to 2 seconds for the IDE to connect
|
||||
while (!Serial && (t++ < 200)) {
|
||||
delay(10); //wait up to 2 seconds for the IDE to connect
|
||||
}
|
||||
#endif
|
||||
chip_report_printf("=========== Before Setup Start ===========\n");
|
||||
printChipInfo();
|
||||
|
@ -347,13 +347,13 @@ extern void analogSetWidth(uint8_t bits) __attribute__((weak, alias("__analogSet
|
||||
*/
|
||||
|
||||
#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2
|
||||
#define ADC_OUTPUT_TYPE ADC_DIGI_OUTPUT_FORMAT_TYPE1
|
||||
#define ADC_OUTPUT_TYPE ADC_DIGI_OUTPUT_FORMAT_TYPE1
|
||||
#define ADC_GET_CHANNEL(p_data) ((p_data)->type1.channel)
|
||||
#define ADC_GET_DATA(p_data) ((p_data)->type1.data)
|
||||
#define ADC_GET_DATA(p_data) ((p_data)->type1.data)
|
||||
#else
|
||||
#define ADC_OUTPUT_TYPE ADC_DIGI_OUTPUT_FORMAT_TYPE2
|
||||
#define ADC_OUTPUT_TYPE ADC_DIGI_OUTPUT_FORMAT_TYPE2
|
||||
#define ADC_GET_CHANNEL(p_data) ((p_data)->type2.channel)
|
||||
#define ADC_GET_DATA(p_data) ((p_data)->type2.data)
|
||||
#define ADC_GET_DATA(p_data) ((p_data)->type2.data)
|
||||
#endif
|
||||
|
||||
static uint8_t __adcContinuousAtten = ADC_11db;
|
||||
@ -436,7 +436,7 @@ esp_err_t __analogContinuousInit(adc_channel_t *channel, uint8_t channel_num, ad
|
||||
.conv_mode = ADC_CONV_SINGLE_UNIT_1,
|
||||
.format = ADC_OUTPUT_TYPE,
|
||||
};
|
||||
adc_digi_pattern_config_t adc_pattern[SOC_ADC_PATT_LEN_MAX] = { 0 };
|
||||
adc_digi_pattern_config_t adc_pattern[SOC_ADC_PATT_LEN_MAX] = {0};
|
||||
dig_cfg.pattern_num = channel_num;
|
||||
for (int i = 0; i < channel_num; i++) {
|
||||
adc_pattern[i].atten = __adcContinuousAtten;
|
||||
@ -456,7 +456,6 @@ esp_err_t __analogContinuousInit(adc_channel_t *channel, uint8_t channel_num, ad
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
|
||||
bool analogContinuous(uint8_t pins[], size_t pins_count, uint32_t conversions_per_pin, uint32_t sampling_freq_hz, void (*userFunc)(void)) {
|
||||
adc_channel_t channel[pins_count];
|
||||
adc_unit_t adc_unit;
|
||||
|
@ -28,104 +28,103 @@ extern "C" {
|
||||
|
||||
#include "esp32-hal.h"
|
||||
|
||||
typedef enum {
|
||||
ADC_0db,
|
||||
ADC_2_5db,
|
||||
ADC_6db,
|
||||
ADC_11db,
|
||||
ADC_ATTENDB_MAX
|
||||
} adc_attenuation_t;
|
||||
typedef enum {
|
||||
ADC_0db,
|
||||
ADC_2_5db,
|
||||
ADC_6db,
|
||||
ADC_11db,
|
||||
ADC_ATTENDB_MAX
|
||||
} adc_attenuation_t;
|
||||
|
||||
/*
|
||||
/*
|
||||
* Get ADC value for pin
|
||||
* */
|
||||
uint16_t analogRead(uint8_t pin);
|
||||
uint16_t analogRead(uint8_t pin);
|
||||
|
||||
/*
|
||||
/*
|
||||
* Get MilliVolts value for pin
|
||||
* */
|
||||
uint32_t analogReadMilliVolts(uint8_t pin);
|
||||
uint32_t analogReadMilliVolts(uint8_t pin);
|
||||
|
||||
/*
|
||||
/*
|
||||
* Set the resolution of analogRead return values. Default is 12 bits (range from 0 to 4096).
|
||||
* If between 9 and 12, it will equal the set hardware resolution, else value will be shifted.
|
||||
* Range is 1 - 16
|
||||
*
|
||||
* Note: compatibility with Arduino SAM
|
||||
*/
|
||||
void analogReadResolution(uint8_t bits);
|
||||
void analogReadResolution(uint8_t bits);
|
||||
|
||||
/*
|
||||
/*
|
||||
* Set the attenuation for all channels
|
||||
* Default is 11db
|
||||
* */
|
||||
void analogSetAttenuation(adc_attenuation_t attenuation);
|
||||
void analogSetAttenuation(adc_attenuation_t attenuation);
|
||||
|
||||
/*
|
||||
/*
|
||||
* Set the attenuation for particular pin
|
||||
* Default is 11db
|
||||
* */
|
||||
void analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation);
|
||||
void analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation);
|
||||
|
||||
#if CONFIG_IDF_TARGET_ESP32
|
||||
/*
|
||||
/*
|
||||
* Sets the sample bits and read resolution
|
||||
* Default is 12bit (0 - 4095)
|
||||
* Range is 9 - 12
|
||||
* */
|
||||
void analogSetWidth(uint8_t bits);
|
||||
void analogSetWidth(uint8_t bits);
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
/*
|
||||
* Analog Continuous mode
|
||||
* */
|
||||
|
||||
typedef struct {
|
||||
uint8_t pin; /*!<ADC pin */
|
||||
uint8_t channel; /*!<ADC channel */
|
||||
int avg_read_raw; /*!<ADC average raw data */
|
||||
int avg_read_mvolts; /*!<ADC average voltage in mV */
|
||||
} adc_continuous_data_t;
|
||||
typedef struct {
|
||||
uint8_t pin; /*!<ADC pin */
|
||||
uint8_t channel; /*!<ADC channel */
|
||||
int avg_read_raw; /*!<ADC average raw data */
|
||||
int avg_read_mvolts; /*!<ADC average voltage in mV */
|
||||
} adc_continuous_data_t;
|
||||
|
||||
/*
|
||||
/*
|
||||
* Setup ADC continuous peripheral
|
||||
* */
|
||||
bool analogContinuous(uint8_t pins[], size_t pins_count, uint32_t conversions_per_pin, uint32_t sampling_freq_hz, void (*userFunc)(void));
|
||||
bool analogContinuous(uint8_t pins[], size_t pins_count, uint32_t conversions_per_pin, uint32_t sampling_freq_hz, void (*userFunc)(void));
|
||||
|
||||
/*
|
||||
/*
|
||||
* Read ADC continuous conversion data
|
||||
* */
|
||||
bool analogContinuousRead(adc_continuous_data_t** buffer, uint32_t timeout_ms);
|
||||
bool analogContinuousRead(adc_continuous_data_t **buffer, uint32_t timeout_ms);
|
||||
|
||||
/*
|
||||
/*
|
||||
* Start ADC continuous conversions
|
||||
* */
|
||||
bool analogContinuousStart();
|
||||
bool analogContinuousStart();
|
||||
|
||||
/*
|
||||
/*
|
||||
* Stop ADC continuous conversions
|
||||
* */
|
||||
bool analogContinuousStop();
|
||||
bool analogContinuousStop();
|
||||
|
||||
/*
|
||||
/*
|
||||
* Deinitialize ADC continuous peripheral
|
||||
* */
|
||||
bool analogContinuousDeinit();
|
||||
bool analogContinuousDeinit();
|
||||
|
||||
/*
|
||||
/*
|
||||
* Sets the attenuation for continuous mode reading
|
||||
* Default is 11db
|
||||
* */
|
||||
void analogContinuousSetAtten(adc_attenuation_t attenuation);
|
||||
void analogContinuousSetAtten(adc_attenuation_t attenuation);
|
||||
|
||||
/*
|
||||
/*
|
||||
* Sets the read resolution for continuous mode
|
||||
* Default is 12bit (0 - 4095)
|
||||
* Range is 9 - 12
|
||||
* */
|
||||
void analogContinuousSetWidth(uint8_t bits);
|
||||
|
||||
void analogContinuousSetWidth(uint8_t bits);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -51,18 +51,10 @@ bool btStartMode(bt_mode mode) {
|
||||
esp_bt_controller_config_t cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
|
||||
#if CONFIG_IDF_TARGET_ESP32
|
||||
switch (mode) {
|
||||
case BT_MODE_BLE:
|
||||
esp_bt_mode = ESP_BT_MODE_BLE;
|
||||
break;
|
||||
case BT_MODE_CLASSIC_BT:
|
||||
esp_bt_mode = ESP_BT_MODE_CLASSIC_BT;
|
||||
break;
|
||||
case BT_MODE_BTDM:
|
||||
esp_bt_mode = ESP_BT_MODE_BTDM;
|
||||
break;
|
||||
default:
|
||||
esp_bt_mode = BT_MODE;
|
||||
break;
|
||||
case BT_MODE_BLE: esp_bt_mode = ESP_BT_MODE_BLE; break;
|
||||
case BT_MODE_CLASSIC_BT: esp_bt_mode = ESP_BT_MODE_CLASSIC_BT; break;
|
||||
case BT_MODE_BTDM: esp_bt_mode = ESP_BT_MODE_BTDM; break;
|
||||
default: esp_bt_mode = BT_MODE; break;
|
||||
}
|
||||
// esp_bt_controller_enable(MODE) This mode must be equal as the mode in “cfg” of esp_bt_controller_init().
|
||||
cfg.mode = esp_bt_mode;
|
||||
@ -107,8 +99,7 @@ bool btStop() {
|
||||
log_e("BT Disable failed");
|
||||
return false;
|
||||
}
|
||||
while (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_ENABLED)
|
||||
;
|
||||
while (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_ENABLED);
|
||||
}
|
||||
if (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_INITED) {
|
||||
if (esp_bt_controller_deinit()) {
|
||||
|
@ -24,15 +24,17 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum { BT_MODE_DEFAULT,
|
||||
BT_MODE_BLE,
|
||||
BT_MODE_CLASSIC_BT,
|
||||
BT_MODE_BTDM } bt_mode;
|
||||
typedef enum {
|
||||
BT_MODE_DEFAULT,
|
||||
BT_MODE_BLE,
|
||||
BT_MODE_CLASSIC_BT,
|
||||
BT_MODE_BTDM
|
||||
} bt_mode;
|
||||
|
||||
bool btStarted();
|
||||
bool btStart();
|
||||
bool btStartMode(bt_mode mode);
|
||||
bool btStop();
|
||||
bool btStarted();
|
||||
bool btStart();
|
||||
bool btStartMode(bt_mode mode);
|
||||
bool btStop();
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -54,14 +54,13 @@
|
||||
#endif
|
||||
|
||||
typedef struct apb_change_cb_s {
|
||||
struct apb_change_cb_s* prev;
|
||||
struct apb_change_cb_s* next;
|
||||
void* arg;
|
||||
struct apb_change_cb_s *prev;
|
||||
struct apb_change_cb_s *next;
|
||||
void *arg;
|
||||
apb_change_cb_t cb;
|
||||
} apb_change_t;
|
||||
|
||||
|
||||
static apb_change_t* apb_change_callbacks = NULL;
|
||||
static apb_change_t *apb_change_callbacks = NULL;
|
||||
static SemaphoreHandle_t apb_change_lock = NULL;
|
||||
|
||||
static void initApbChangeCallback() {
|
||||
@ -78,15 +77,17 @@ static void initApbChangeCallback() {
|
||||
static void triggerApbChangeCallback(apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb) {
|
||||
initApbChangeCallback();
|
||||
xSemaphoreTake(apb_change_lock, portMAX_DELAY);
|
||||
apb_change_t* r = apb_change_callbacks;
|
||||
apb_change_t *r = apb_change_callbacks;
|
||||
if (r != NULL) {
|
||||
if (ev_type == APB_BEFORE_CHANGE)
|
||||
if (ev_type == APB_BEFORE_CHANGE) {
|
||||
while (r != NULL) {
|
||||
r->cb(r->arg, ev_type, old_apb, new_apb);
|
||||
r = r->next;
|
||||
}
|
||||
else { // run backwards through chain
|
||||
while (r->next != NULL) r = r->next; // find first added
|
||||
} else { // run backwards through chain
|
||||
while (r->next != NULL) {
|
||||
r = r->next; // find first added
|
||||
}
|
||||
while (r != NULL) {
|
||||
r->cb(r->arg, ev_type, old_apb, new_apb);
|
||||
r = r->prev;
|
||||
@ -96,9 +97,9 @@ static void triggerApbChangeCallback(apb_change_ev_t ev_type, uint32_t old_apb,
|
||||
xSemaphoreGive(apb_change_lock);
|
||||
}
|
||||
|
||||
bool addApbChangeCallback(void* arg, apb_change_cb_t cb) {
|
||||
bool addApbChangeCallback(void *arg, apb_change_cb_t cb) {
|
||||
initApbChangeCallback();
|
||||
apb_change_t* c = (apb_change_t*)malloc(sizeof(apb_change_t));
|
||||
apb_change_t *c = (apb_change_t *)malloc(sizeof(apb_change_t));
|
||||
if (!c) {
|
||||
log_e("Callback Object Malloc Failed");
|
||||
return false;
|
||||
@ -111,9 +112,11 @@ bool addApbChangeCallback(void* arg, apb_change_cb_t cb) {
|
||||
if (apb_change_callbacks == NULL) {
|
||||
apb_change_callbacks = c;
|
||||
} else {
|
||||
apb_change_t* r = apb_change_callbacks;
|
||||
apb_change_t *r = apb_change_callbacks;
|
||||
// look for duplicate callbacks
|
||||
while ((r != NULL) && !((r->cb == cb) && (r->arg == arg))) r = r->next;
|
||||
while ((r != NULL) && !((r->cb == cb) && (r->arg == arg))) {
|
||||
r = r->next;
|
||||
}
|
||||
if (r) {
|
||||
log_e("duplicate func=%8p arg=%8p", c->cb, c->arg);
|
||||
free(c);
|
||||
@ -129,30 +132,35 @@ bool addApbChangeCallback(void* arg, apb_change_cb_t cb) {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool removeApbChangeCallback(void* arg, apb_change_cb_t cb) {
|
||||
bool removeApbChangeCallback(void *arg, apb_change_cb_t cb) {
|
||||
initApbChangeCallback();
|
||||
xSemaphoreTake(apb_change_lock, portMAX_DELAY);
|
||||
apb_change_t* r = apb_change_callbacks;
|
||||
apb_change_t *r = apb_change_callbacks;
|
||||
// look for matching callback
|
||||
while ((r != NULL) && !((r->cb == cb) && (r->arg == arg))) r = r->next;
|
||||
while ((r != NULL) && !((r->cb == cb) && (r->arg == arg))) {
|
||||
r = r->next;
|
||||
}
|
||||
if (r == NULL) {
|
||||
log_e("not found func=%8p arg=%8p", cb, arg);
|
||||
xSemaphoreGive(apb_change_lock);
|
||||
return false;
|
||||
} else {
|
||||
// patch links
|
||||
if (r->prev) r->prev->next = r->next;
|
||||
else { // this is first link
|
||||
if (r->prev) {
|
||||
r->prev->next = r->next;
|
||||
} else { // this is first link
|
||||
apb_change_callbacks = r->next;
|
||||
}
|
||||
if (r->next) r->next->prev = r->prev;
|
||||
if (r->next) {
|
||||
r->next->prev = r->prev;
|
||||
}
|
||||
free(r);
|
||||
}
|
||||
xSemaphoreGive(apb_change_lock);
|
||||
return true;
|
||||
}
|
||||
|
||||
static uint32_t calculateApb(rtc_cpu_freq_config_t* conf) {
|
||||
static uint32_t calculateApb(rtc_cpu_freq_config_t *conf) {
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32H2
|
||||
return APB_CLK_FREQ;
|
||||
#else
|
||||
@ -253,9 +261,17 @@ bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz) {
|
||||
triggerApbChangeCallback(APB_AFTER_CHANGE, capb, apb);
|
||||
}
|
||||
#ifdef SOC_CLK_APLL_SUPPORTED
|
||||
log_d("%s: %u / %u = %u Mhz, APB: %u Hz", (conf.source == RTC_CPU_FREQ_SRC_PLL) ? "PLL" : ((conf.source == RTC_CPU_FREQ_SRC_APLL) ? "APLL" : ((conf.source == RTC_CPU_FREQ_SRC_XTAL) ? "XTAL" : "8M")), conf.source_freq_mhz, conf.div, conf.freq_mhz, apb);
|
||||
log_d(
|
||||
"%s: %u / %u = %u Mhz, APB: %u Hz",
|
||||
(conf.source == RTC_CPU_FREQ_SRC_PLL) ? "PLL"
|
||||
: ((conf.source == RTC_CPU_FREQ_SRC_APLL) ? "APLL" : ((conf.source == RTC_CPU_FREQ_SRC_XTAL) ? "XTAL" : "8M")),
|
||||
conf.source_freq_mhz, conf.div, conf.freq_mhz, apb
|
||||
);
|
||||
#else
|
||||
log_d("%s: %u / %u = %u Mhz, APB: %u Hz", (conf.source == RTC_CPU_FREQ_SRC_PLL) ? "PLL" : ((conf.source == RTC_CPU_FREQ_SRC_XTAL) ? "XTAL" : "17.5M"), conf.source_freq_mhz, conf.div, conf.freq_mhz, apb);
|
||||
log_d(
|
||||
"%s: %u / %u = %u Mhz, APB: %u Hz", (conf.source == RTC_CPU_FREQ_SRC_PLL) ? "PLL" : ((conf.source == RTC_CPU_FREQ_SRC_XTAL) ? "XTAL" : "17.5M"),
|
||||
conf.source_freq_mhz, conf.div, conf.freq_mhz, apb
|
||||
);
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
@ -23,24 +23,26 @@ extern "C" {
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef enum { APB_BEFORE_CHANGE,
|
||||
APB_AFTER_CHANGE } apb_change_ev_t;
|
||||
typedef enum {
|
||||
APB_BEFORE_CHANGE,
|
||||
APB_AFTER_CHANGE
|
||||
} apb_change_ev_t;
|
||||
|
||||
typedef void (*apb_change_cb_t)(void* arg, apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb);
|
||||
typedef void (*apb_change_cb_t)(void *arg, apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb);
|
||||
|
||||
bool addApbChangeCallback(void* arg, apb_change_cb_t cb);
|
||||
bool removeApbChangeCallback(void* arg, apb_change_cb_t cb);
|
||||
bool addApbChangeCallback(void *arg, apb_change_cb_t cb);
|
||||
bool removeApbChangeCallback(void *arg, apb_change_cb_t cb);
|
||||
|
||||
//function takes the following frequencies as valid values:
|
||||
// 240, 160, 80 <<< For all XTAL types
|
||||
// 40, 20, 10 <<< For 40MHz XTAL
|
||||
// 26, 13 <<< For 26MHz XTAL
|
||||
// 24, 12 <<< For 24MHz XTAL
|
||||
bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz);
|
||||
//function takes the following frequencies as valid values:
|
||||
// 240, 160, 80 <<< For all XTAL types
|
||||
// 40, 20, 10 <<< For 40MHz XTAL
|
||||
// 26, 13 <<< For 26MHz XTAL
|
||||
// 24, 12 <<< For 24MHz XTAL
|
||||
bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz);
|
||||
|
||||
uint32_t getCpuFrequencyMhz(); // In MHz
|
||||
uint32_t getXtalFrequencyMhz(); // In MHz
|
||||
uint32_t getApbFrequency(); // In Hz
|
||||
uint32_t getCpuFrequencyMhz(); // In MHz
|
||||
uint32_t getXtalFrequencyMhz(); // In MHz
|
||||
uint32_t getApbFrequency(); // In Hz
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -35,9 +35,7 @@ bool __dacWrite(uint8_t pin, uint8_t value) {
|
||||
return false;
|
||||
}
|
||||
dac_channel_t channel = (pin == DAC_CHAN0_GPIO_NUM) ? DAC_CHAN_0 : DAC_CHAN_1;
|
||||
dac_oneshot_config_t config = {
|
||||
.chan_id = channel
|
||||
};
|
||||
dac_oneshot_config_t config = {.chan_id = channel};
|
||||
err = dac_oneshot_new_channel(&config, &bus);
|
||||
if (err != ESP_OK) {
|
||||
log_e("dac_oneshot_new_channel failed with error: %d", err);
|
||||
|
@ -16,8 +16,8 @@ extern "C" {
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
bool dacWrite(uint8_t pin, uint8_t value);
|
||||
bool dacDisable(uint8_t pin);
|
||||
bool dacWrite(uint8_t pin, uint8_t value);
|
||||
bool dacDisable(uint8_t pin);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -75,10 +75,10 @@ int8_t analogChannelToDigitalPin(uint8_t channel) {
|
||||
#endif
|
||||
|
||||
typedef void (*voidFuncPtr)(void);
|
||||
typedef void (*voidFuncPtrArg)(void*);
|
||||
typedef void (*voidFuncPtrArg)(void *);
|
||||
typedef struct {
|
||||
voidFuncPtr fn;
|
||||
void* arg;
|
||||
void *arg;
|
||||
bool functional;
|
||||
} InterruptHandle_t;
|
||||
static InterruptHandle_t __pinInterruptHandlers[SOC_GPIO_PIN_COUNT] = {
|
||||
@ -87,7 +87,7 @@ static InterruptHandle_t __pinInterruptHandlers[SOC_GPIO_PIN_COUNT] = {
|
||||
|
||||
#include "driver/rtc_io.h"
|
||||
|
||||
static bool gpioDetachBus(void* bus) {
|
||||
static bool gpioDetachBus(void *bus) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -139,7 +139,7 @@ extern void ARDUINO_ISR_ATTR __pinMode(uint8_t pin, uint8_t mode) {
|
||||
return;
|
||||
}
|
||||
if (perimanGetPinBus(pin, ESP32_BUS_TYPE_GPIO) == NULL) {
|
||||
if (!perimanSetPinBus(pin, ESP32_BUS_TYPE_GPIO, (void*)(pin + 1), -1, -1)) {
|
||||
if (!perimanSetPinBus(pin, ESP32_BUS_TYPE_GPIO, (void *)(pin + 1), -1, -1)) {
|
||||
//gpioDetachBus((void *)(pin+1));
|
||||
return;
|
||||
}
|
||||
@ -182,8 +182,8 @@ extern int ARDUINO_ISR_ATTR __digitalRead(uint8_t pin) {
|
||||
}
|
||||
}
|
||||
|
||||
static void ARDUINO_ISR_ATTR __onPinInterrupt(void* arg) {
|
||||
InterruptHandle_t* isr = (InterruptHandle_t*)arg;
|
||||
static void ARDUINO_ISR_ATTR __onPinInterrupt(void *arg) {
|
||||
InterruptHandle_t *isr = (InterruptHandle_t *)arg;
|
||||
if (isr->fn) {
|
||||
if (isr->arg) {
|
||||
((voidFuncPtrArg)isr->fn)(isr->arg);
|
||||
@ -193,13 +193,15 @@ static void ARDUINO_ISR_ATTR __onPinInterrupt(void* arg) {
|
||||
}
|
||||
}
|
||||
|
||||
extern void cleanupFunctional(void* arg);
|
||||
extern void cleanupFunctional(void *arg);
|
||||
|
||||
extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc, void* arg, int intr_type, bool functional) {
|
||||
extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc, void *arg, int intr_type, bool functional) {
|
||||
static bool interrupt_initialized = false;
|
||||
|
||||
// makes sure that pin -1 (255) will never work -- this follows Arduino standard
|
||||
if (pin >= SOC_GPIO_PIN_COUNT) return;
|
||||
if (pin >= SOC_GPIO_PIN_COUNT) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!interrupt_initialized) {
|
||||
esp_err_t err = gpio_install_isr_service((int)ARDUINO_ISR_FLAG);
|
||||
@ -224,7 +226,6 @@ extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc,
|
||||
}
|
||||
gpio_isr_handler_add((gpio_num_t)pin, __onPinInterrupt, &__pinInterruptHandlers[pin]);
|
||||
|
||||
|
||||
//FIX interrupts on peripherals outputs (eg. LEDC,...)
|
||||
//Enable input in GPIO register
|
||||
gpio_hal_context_t gpiohal;
|
||||
@ -232,7 +233,7 @@ extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc,
|
||||
gpio_hal_input_enable(&gpiohal, pin);
|
||||
}
|
||||
|
||||
extern void __attachInterruptArg(uint8_t pin, voidFuncPtrArg userFunc, void* arg, int intr_type) {
|
||||
extern void __attachInterruptArg(uint8_t pin, voidFuncPtrArg userFunc, void *arg, int intr_type) {
|
||||
__attachInterruptFunctionalArg(pin, userFunc, arg, intr_type, false);
|
||||
}
|
||||
|
||||
@ -262,10 +263,9 @@ extern void disableInterrupt(uint8_t pin) {
|
||||
gpio_intr_disable((gpio_num_t)pin);
|
||||
}
|
||||
|
||||
|
||||
extern void pinMode(uint8_t pin, uint8_t mode) __attribute__((weak, alias("__pinMode")));
|
||||
extern void digitalWrite(uint8_t pin, uint8_t val) __attribute__((weak, alias("__digitalWrite")));
|
||||
extern int digitalRead(uint8_t pin) __attribute__((weak, alias("__digitalRead")));
|
||||
extern void attachInterrupt(uint8_t pin, voidFuncPtr handler, int mode) __attribute__((weak, alias("__attachInterrupt")));
|
||||
extern void attachInterruptArg(uint8_t pin, voidFuncPtrArg handler, void* arg, int mode) __attribute__((weak, alias("__attachInterruptArg")));
|
||||
extern void attachInterruptArg(uint8_t pin, voidFuncPtrArg handler, void *arg, int mode) __attribute__((weak, alias("__attachInterruptArg")));
|
||||
extern void detachInterrupt(uint8_t pin) __attribute__((weak, alias("__detachInterrupt")));
|
||||
|
@ -30,61 +30,59 @@ extern "C" {
|
||||
|
||||
#if (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
|
||||
#define NUM_OUPUT_PINS 46
|
||||
#define PIN_DAC1 17
|
||||
#define PIN_DAC2 18
|
||||
#define PIN_DAC1 17
|
||||
#define PIN_DAC2 18
|
||||
#else
|
||||
#define NUM_OUPUT_PINS 34
|
||||
#define PIN_DAC1 25
|
||||
#define PIN_DAC2 26
|
||||
#define PIN_DAC1 25
|
||||
#define PIN_DAC2 26
|
||||
#endif
|
||||
|
||||
#define LOW 0x0
|
||||
#define LOW 0x0
|
||||
#define HIGH 0x1
|
||||
|
||||
//GPIO FUNCTIONS
|
||||
#define INPUT 0x01
|
||||
// Changed OUTPUT from 0x02 to behave the same as Arduino pinMode(pin,OUTPUT)
|
||||
// where you can read the state of pin even when it is set as OUTPUT
|
||||
#define OUTPUT 0x03
|
||||
#define PULLUP 0x04
|
||||
#define INPUT_PULLUP 0x05
|
||||
#define PULLDOWN 0x08
|
||||
#define INPUT_PULLDOWN 0x09
|
||||
#define OPEN_DRAIN 0x10
|
||||
#define OUTPUT 0x03
|
||||
#define PULLUP 0x04
|
||||
#define INPUT_PULLUP 0x05
|
||||
#define PULLDOWN 0x08
|
||||
#define INPUT_PULLDOWN 0x09
|
||||
#define OPEN_DRAIN 0x10
|
||||
#define OUTPUT_OPEN_DRAIN 0x13
|
||||
#define ANALOG 0xC0
|
||||
#define ANALOG 0xC0
|
||||
|
||||
//Interrupt Modes
|
||||
#define DISABLED 0x00
|
||||
#define RISING 0x01
|
||||
#define FALLING 0x02
|
||||
#define CHANGE 0x03
|
||||
#define ONLOW 0x04
|
||||
#define ONHIGH 0x05
|
||||
#define ONLOW_WE 0x0C
|
||||
#define DISABLED 0x00
|
||||
#define RISING 0x01
|
||||
#define FALLING 0x02
|
||||
#define CHANGE 0x03
|
||||
#define ONLOW 0x04
|
||||
#define ONHIGH 0x05
|
||||
#define ONLOW_WE 0x0C
|
||||
#define ONHIGH_WE 0x0D
|
||||
|
||||
|
||||
#define digitalPinIsValid(pin) GPIO_IS_VALID_GPIO(pin)
|
||||
#define digitalPinIsValid(pin) GPIO_IS_VALID_GPIO(pin)
|
||||
#define digitalPinCanOutput(pin) GPIO_IS_VALID_OUTPUT_GPIO(pin)
|
||||
|
||||
#define digitalPinToRtcPin(pin) ((RTC_GPIO_IS_VALID_GPIO(pin)) ? rtc_io_number_get(pin) : -1)
|
||||
#define digitalPinToDacChannel(pin) (((pin) == DAC_CHANNEL_1_GPIO_NUM) ? 0 : ((pin) == DAC_CHANNEL_2_GPIO_NUM) ? 1 \
|
||||
: -1)
|
||||
#define digitalPinToRtcPin(pin) ((RTC_GPIO_IS_VALID_GPIO(pin)) ? rtc_io_number_get(pin) : -1)
|
||||
#define digitalPinToDacChannel(pin) (((pin) == DAC_CHANNEL_1_GPIO_NUM) ? 0 : ((pin) == DAC_CHANNEL_2_GPIO_NUM) ? 1 : -1)
|
||||
|
||||
void pinMode(uint8_t pin, uint8_t mode);
|
||||
void digitalWrite(uint8_t pin, uint8_t val);
|
||||
int digitalRead(uint8_t pin);
|
||||
void pinMode(uint8_t pin, uint8_t mode);
|
||||
void digitalWrite(uint8_t pin, uint8_t val);
|
||||
int digitalRead(uint8_t pin);
|
||||
|
||||
void attachInterrupt(uint8_t pin, void (*)(void), int mode);
|
||||
void attachInterruptArg(uint8_t pin, void (*)(void*), void* arg, int mode);
|
||||
void detachInterrupt(uint8_t pin);
|
||||
void enableInterrupt(uint8_t pin);
|
||||
void disableInterrupt(uint8_t pin);
|
||||
void attachInterrupt(uint8_t pin, void (*)(void), int mode);
|
||||
void attachInterruptArg(uint8_t pin, void (*)(void *), void *arg, int mode);
|
||||
void detachInterrupt(uint8_t pin);
|
||||
void enableInterrupt(uint8_t pin);
|
||||
void disableInterrupt(uint8_t pin);
|
||||
|
||||
int8_t digitalPinToTouchChannel(uint8_t pin);
|
||||
int8_t digitalPinToAnalogChannel(uint8_t pin);
|
||||
int8_t analogChannelToDigitalPin(uint8_t channel);
|
||||
int8_t digitalPinToTouchChannel(uint8_t pin);
|
||||
int8_t digitalPinToAnalogChannel(uint8_t pin);
|
||||
int8_t analogChannelToDigitalPin(uint8_t channel);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -93,24 +93,24 @@ typedef struct i2c_slave_struct_t {
|
||||
typedef union {
|
||||
struct {
|
||||
uint32_t event : 2;
|
||||
uint32_t stop : 1;
|
||||
uint32_t stop : 1;
|
||||
uint32_t param : 29;
|
||||
};
|
||||
uint32_t val;
|
||||
} i2c_slave_queue_event_t;
|
||||
|
||||
static i2c_slave_struct_t _i2c_bus_array[SOC_I2C_NUM] = {
|
||||
{ &I2C0, 0, -1, -1, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0
|
||||
{&I2C0, 0, -1, -1, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0
|
||||
#if !CONFIG_DISABLE_HAL_LOCKS
|
||||
,
|
||||
NULL
|
||||
,
|
||||
NULL
|
||||
#endif
|
||||
},
|
||||
#if SOC_I2C_NUM > 1
|
||||
{ &I2C1, 1, -1, -1, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0
|
||||
{&I2C1, 1, -1, -1, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0
|
||||
#if !CONFIG_DISABLE_HAL_LOCKS
|
||||
,
|
||||
NULL
|
||||
,
|
||||
NULL
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
@ -120,10 +120,14 @@ static i2c_slave_struct_t _i2c_bus_array[SOC_I2C_NUM] = {
|
||||
#define I2C_SLAVE_MUTEX_LOCK()
|
||||
#define I2C_SLAVE_MUTEX_UNLOCK()
|
||||
#else
|
||||
#define I2C_SLAVE_MUTEX_LOCK() \
|
||||
if (i2c->lock) { xSemaphoreTake(i2c->lock, portMAX_DELAY); }
|
||||
#define I2C_SLAVE_MUTEX_LOCK() \
|
||||
if (i2c->lock) { \
|
||||
xSemaphoreTake(i2c->lock, portMAX_DELAY); \
|
||||
}
|
||||
#define I2C_SLAVE_MUTEX_UNLOCK() \
|
||||
if (i2c->lock) { xSemaphoreGive(i2c->lock); }
|
||||
if (i2c->lock) { \
|
||||
xSemaphoreGive(i2c->lock); \
|
||||
}
|
||||
#endif
|
||||
|
||||
//-------------------------------------- HAL_LL (Missing Functions) ------------------------------------------------
|
||||
@ -356,7 +360,8 @@ esp_err_t i2cSlaveInit(uint8_t num, int sda, int scl, uint16_t slaveID, uint32_t
|
||||
i2c_ll_slave_enable_rx_it(i2c->dev);
|
||||
i2c_ll_set_stretch(i2c->dev, 0x3FF);
|
||||
i2c_ll_update(i2c->dev);
|
||||
if (!perimanSetPinBus(sda, ESP32_BUS_TYPE_I2C_SLAVE_SDA, (void *)(i2c->num + 1), i2c->num, -1) || !perimanSetPinBus(scl, ESP32_BUS_TYPE_I2C_SLAVE_SCL, (void *)(i2c->num + 1), i2c->num, -1)) {
|
||||
if (!perimanSetPinBus(sda, ESP32_BUS_TYPE_I2C_SLAVE_SDA, (void *)(i2c->num + 1), i2c->num, -1)
|
||||
|| !perimanSetPinBus(scl, ESP32_BUS_TYPE_I2C_SLAVE_SCL, (void *)(i2c->num + 1), i2c->num, -1)) {
|
||||
i2cSlaveDetachBus((void *)(i2c->num + 1));
|
||||
ret = ESP_FAIL;
|
||||
}
|
||||
@ -528,21 +533,15 @@ static void i2c_slave_delay_us(uint64_t us) {
|
||||
if (us) {
|
||||
uint64_t e = (m + us);
|
||||
if (m > e) { //overflow
|
||||
while ((uint64_t)esp_timer_get_time() > e)
|
||||
;
|
||||
while ((uint64_t)esp_timer_get_time() > e);
|
||||
}
|
||||
while ((uint64_t)esp_timer_get_time() < e)
|
||||
;
|
||||
while ((uint64_t)esp_timer_get_time() < e);
|
||||
}
|
||||
}
|
||||
|
||||
static void i2c_slave_gpio_mode(int8_t pin, gpio_mode_t mode) {
|
||||
gpio_config_t conf = {
|
||||
.pin_bit_mask = 1LL << pin,
|
||||
.mode = mode,
|
||||
.pull_up_en = GPIO_PULLUP_ENABLE,
|
||||
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
||||
.intr_type = GPIO_INTR_DISABLE
|
||||
.pin_bit_mask = 1LL << pin, .mode = mode, .pull_up_en = GPIO_PULLUP_ENABLE, .pull_down_en = GPIO_PULLDOWN_DISABLE, .intr_type = GPIO_INTR_DISABLE
|
||||
};
|
||||
gpio_config(&conf);
|
||||
}
|
||||
@ -735,8 +734,7 @@ static void i2c_slave_isr_handler(void *arg) {
|
||||
//reset TX data
|
||||
i2c_ll_txfifo_rst(i2c->dev);
|
||||
uint8_t d;
|
||||
while (xQueueReceiveFromISR(i2c->tx_queue, &d, (BaseType_t *const)&pxHigherPriorityTaskWoken) == pdTRUE)
|
||||
; //flush partial write
|
||||
while (xQueueReceiveFromISR(i2c->tx_queue, &d, (BaseType_t *const)&pxHigherPriorityTaskWoken) == pdTRUE); //flush partial write
|
||||
#endif
|
||||
}
|
||||
}
|
||||
@ -794,10 +792,7 @@ static size_t i2c_slave_read_rx(i2c_slave_struct_t *i2c, uint8_t *data, size_t l
|
||||
}
|
||||
return (data) ? len : 0;
|
||||
#else
|
||||
size_t dlen = 0,
|
||||
to_read = len,
|
||||
so_far = 0,
|
||||
available = 0;
|
||||
size_t dlen = 0, to_read = len, so_far = 0, available = 0;
|
||||
uint8_t *rx_data = NULL;
|
||||
|
||||
vRingbufferGetInfo(i2c->rx_ring_buf, NULL, NULL, NULL, NULL, &available);
|
||||
|
@ -25,13 +25,13 @@ extern "C" {
|
||||
#include "stddef.h"
|
||||
#include "esp_err.h"
|
||||
|
||||
typedef void (*i2c_slave_request_cb_t)(uint8_t num, void *arg);
|
||||
typedef void (*i2c_slave_receive_cb_t)(uint8_t num, uint8_t *data, size_t len, bool stop, void *arg);
|
||||
esp_err_t i2cSlaveAttachCallbacks(uint8_t num, i2c_slave_request_cb_t request_callback, i2c_slave_receive_cb_t receive_callback, void *arg);
|
||||
typedef void (*i2c_slave_request_cb_t)(uint8_t num, void *arg);
|
||||
typedef void (*i2c_slave_receive_cb_t)(uint8_t num, uint8_t *data, size_t len, bool stop, void *arg);
|
||||
esp_err_t i2cSlaveAttachCallbacks(uint8_t num, i2c_slave_request_cb_t request_callback, i2c_slave_receive_cb_t receive_callback, void *arg);
|
||||
|
||||
esp_err_t i2cSlaveInit(uint8_t num, int sda, int scl, uint16_t slaveID, uint32_t frequency, size_t rx_len, size_t tx_len);
|
||||
esp_err_t i2cSlaveDeinit(uint8_t num);
|
||||
size_t i2cSlaveWrite(uint8_t num, const uint8_t *buf, uint32_t len, uint32_t timeout_ms);
|
||||
esp_err_t i2cSlaveInit(uint8_t num, int sda, int scl, uint16_t slaveID, uint32_t frequency, size_t rx_len, size_t tx_len);
|
||||
esp_err_t i2cSlaveDeinit(uint8_t num);
|
||||
size_t i2cSlaveWrite(uint8_t num, const uint8_t *buf, uint32_t len, uint32_t timeout_ms);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -131,7 +131,8 @@ esp_err_t i2cInit(uint8_t i2c_num, int8_t sda, int8_t scl, uint32_t frequency) {
|
||||
bus[i2c_num].sda = sda;
|
||||
//Clock Stretching Timeout: 20b:esp32, 5b:esp32-c3, 24b:esp32-s2
|
||||
i2c_set_timeout((i2c_port_t)i2c_num, I2C_LL_MAX_TIMEOUT);
|
||||
if (!perimanSetPinBus(sda, ESP32_BUS_TYPE_I2C_MASTER_SDA, (void *)(i2c_num + 1), i2c_num, -1) || !perimanSetPinBus(scl, ESP32_BUS_TYPE_I2C_MASTER_SCL, (void *)(i2c_num + 1), i2c_num, -1)) {
|
||||
if (!perimanSetPinBus(sda, ESP32_BUS_TYPE_I2C_MASTER_SDA, (void *)(i2c_num + 1), i2c_num, -1)
|
||||
|| !perimanSetPinBus(scl, ESP32_BUS_TYPE_I2C_MASTER_SCL, (void *)(i2c_num + 1), i2c_num, -1)) {
|
||||
i2cDetachBus((void *)(i2c_num + 1));
|
||||
return false;
|
||||
}
|
||||
@ -197,7 +198,7 @@ esp_err_t i2cWrite(uint8_t i2c_num, uint16_t address, const uint8_t *buff, size_
|
||||
//ret = i2c_master_write_to_device((i2c_port_t)i2c_num, address, buff, size, timeOutMillis / portTICK_PERIOD_MS);
|
||||
|
||||
ret = ESP_OK;
|
||||
uint8_t cmd_buff[I2C_LINK_RECOMMENDED_SIZE(1)] = { 0 };
|
||||
uint8_t cmd_buff[I2C_LINK_RECOMMENDED_SIZE(1)] = {0};
|
||||
cmd = i2c_cmd_link_create_static(cmd_buff, I2C_LINK_RECOMMENDED_SIZE(1));
|
||||
ret = i2c_master_start(cmd);
|
||||
if (ret != ESP_OK) {
|
||||
@ -259,7 +260,9 @@ esp_err_t i2cRead(uint8_t i2c_num, uint16_t address, uint8_t *buff, size_t size,
|
||||
return ret;
|
||||
}
|
||||
|
||||
esp_err_t i2cWriteReadNonStop(uint8_t i2c_num, uint16_t address, const uint8_t *wbuff, size_t wsize, uint8_t *rbuff, size_t rsize, uint32_t timeOutMillis, size_t *readCount) {
|
||||
esp_err_t i2cWriteReadNonStop(
|
||||
uint8_t i2c_num, uint16_t address, const uint8_t *wbuff, size_t wsize, uint8_t *rbuff, size_t rsize, uint32_t timeOutMillis, size_t *readCount
|
||||
) {
|
||||
esp_err_t ret = ESP_FAIL;
|
||||
if (i2c_num >= SOC_I2C_NUM) {
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
@ -338,18 +341,18 @@ esp_err_t i2cSetClock(uint8_t i2c_num, uint32_t frequency) {
|
||||
|
||||
// i2c clock characteristic, The order is the same as i2c_sclk_t.
|
||||
i2c_clk_alloc_t i2c_clk_alloc[I2C_SCLK_MAX] = {
|
||||
{ 0, 0 },
|
||||
{0, 0},
|
||||
#if SOC_I2C_SUPPORT_APB
|
||||
{ SOC_MOD_CLK_APB, esp_clk_apb_freq() }, /*!< I2C APB clock characteristic*/
|
||||
{SOC_MOD_CLK_APB, esp_clk_apb_freq()}, /*!< I2C APB clock characteristic*/
|
||||
#endif
|
||||
#if SOC_I2C_SUPPORT_XTAL
|
||||
{ SOC_MOD_CLK_XTAL, esp_clk_xtal_freq() }, /*!< I2C XTAL characteristic*/
|
||||
{SOC_MOD_CLK_XTAL, esp_clk_xtal_freq()}, /*!< I2C XTAL characteristic*/
|
||||
#endif
|
||||
#if SOC_I2C_SUPPORT_RTC
|
||||
{ SOC_MOD_CLK_RC_FAST, periph_rtc_dig_clk8m_get_freq() }, /*!< I2C 20M RTC characteristic*/
|
||||
{SOC_MOD_CLK_RC_FAST, periph_rtc_dig_clk8m_get_freq()}, /*!< I2C 20M RTC characteristic*/
|
||||
#endif
|
||||
#if SOC_I2C_SUPPORT_REF_TICK
|
||||
{ SOC_MOD_CLK_REF_TICK, REF_CLK_FREQ }, /*!< I2C REF_TICK characteristic*/
|
||||
{SOC_MOD_CLK_REF_TICK, REF_CLK_FREQ}, /*!< I2C REF_TICK characteristic*/
|
||||
#endif
|
||||
};
|
||||
|
||||
|
@ -28,14 +28,16 @@ extern "C" {
|
||||
#include <stdbool.h>
|
||||
#include <esp_err.h>
|
||||
|
||||
esp_err_t i2cInit(uint8_t i2c_num, int8_t sda, int8_t scl, uint32_t clk_speed);
|
||||
esp_err_t i2cDeinit(uint8_t i2c_num);
|
||||
esp_err_t i2cSetClock(uint8_t i2c_num, uint32_t frequency);
|
||||
esp_err_t i2cGetClock(uint8_t i2c_num, uint32_t* frequency);
|
||||
esp_err_t i2cWrite(uint8_t i2c_num, uint16_t address, const uint8_t* buff, size_t size, uint32_t timeOutMillis);
|
||||
esp_err_t i2cRead(uint8_t i2c_num, uint16_t address, uint8_t* buff, size_t size, uint32_t timeOutMillis, size_t* readCount);
|
||||
esp_err_t i2cWriteReadNonStop(uint8_t i2c_num, uint16_t address, const uint8_t* wbuff, size_t wsize, uint8_t* rbuff, size_t rsize, uint32_t timeOutMillis, size_t* readCount);
|
||||
bool i2cIsInit(uint8_t i2c_num);
|
||||
esp_err_t i2cInit(uint8_t i2c_num, int8_t sda, int8_t scl, uint32_t clk_speed);
|
||||
esp_err_t i2cDeinit(uint8_t i2c_num);
|
||||
esp_err_t i2cSetClock(uint8_t i2c_num, uint32_t frequency);
|
||||
esp_err_t i2cGetClock(uint8_t i2c_num, uint32_t *frequency);
|
||||
esp_err_t i2cWrite(uint8_t i2c_num, uint16_t address, const uint8_t *buff, size_t size, uint32_t timeOutMillis);
|
||||
esp_err_t i2cRead(uint8_t i2c_num, uint16_t address, uint8_t *buff, size_t size, uint32_t timeOutMillis, size_t *readCount);
|
||||
esp_err_t i2cWriteReadNonStop(
|
||||
uint8_t i2c_num, uint16_t address, const uint8_t *wbuff, size_t wsize, uint8_t *rbuff, size_t rsize, uint32_t timeOutMillis, size_t *readCount
|
||||
);
|
||||
bool i2cIsInit(uint8_t i2c_num);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -42,7 +42,7 @@ typedef struct {
|
||||
int used_channels : LEDC_CHANNELS; // Used channels as a bits
|
||||
} ledc_periph_t;
|
||||
|
||||
ledc_periph_t ledc_handle = { 0 };
|
||||
ledc_periph_t ledc_handle = {0};
|
||||
|
||||
static bool fade_initialized = false;
|
||||
|
||||
@ -86,13 +86,7 @@ bool ledcAttachChannel(uint8_t pin, uint32_t freq, uint8_t resolution, uint8_t c
|
||||
|
||||
uint8_t group = (channel / 8), timer = ((channel / 2) % 4);
|
||||
|
||||
ledc_timer_config_t ledc_timer = {
|
||||
.speed_mode = group,
|
||||
.timer_num = timer,
|
||||
.duty_resolution = resolution,
|
||||
.freq_hz = freq,
|
||||
.clk_cfg = LEDC_DEFAULT_CLK
|
||||
};
|
||||
ledc_timer_config_t ledc_timer = {.speed_mode = group, .timer_num = timer, .duty_resolution = resolution, .freq_hz = freq, .clk_cfg = LEDC_DEFAULT_CLK};
|
||||
if (ledc_timer_config(&ledc_timer) != ESP_OK) {
|
||||
log_e("ledc setup failed!");
|
||||
return false;
|
||||
@ -101,13 +95,7 @@ bool ledcAttachChannel(uint8_t pin, uint32_t freq, uint8_t resolution, uint8_t c
|
||||
uint32_t duty = ledc_get_duty(group, channel);
|
||||
|
||||
ledc_channel_config_t ledc_channel = {
|
||||
.speed_mode = group,
|
||||
.channel = (channel % 8),
|
||||
.timer_sel = timer,
|
||||
.intr_type = LEDC_INTR_DISABLE,
|
||||
.gpio_num = pin,
|
||||
.duty = duty,
|
||||
.hpoint = 0
|
||||
.speed_mode = group, .channel = (channel % 8), .timer_sel = timer, .intr_type = LEDC_INTR_DISABLE, .gpio_num = pin, .duty = duty, .hpoint = 0
|
||||
};
|
||||
ledc_channel_config(&ledc_channel);
|
||||
|
||||
@ -184,7 +172,6 @@ uint32_t ledcReadFreq(uint8_t pin) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
uint32_t ledcWriteTone(uint8_t pin, uint32_t freq) {
|
||||
ledc_channel_handle_t *bus = (ledc_channel_handle_t *)perimanGetPinBus(pin, ESP32_BUS_TYPE_LEDC);
|
||||
if (bus != NULL) {
|
||||
@ -196,13 +183,7 @@ uint32_t ledcWriteTone(uint8_t pin, uint32_t freq) {
|
||||
|
||||
uint8_t group = (bus->channel / 8), timer = ((bus->channel / 2) % 4);
|
||||
|
||||
ledc_timer_config_t ledc_timer = {
|
||||
.speed_mode = group,
|
||||
.timer_num = timer,
|
||||
.duty_resolution = 10,
|
||||
.freq_hz = freq,
|
||||
.clk_cfg = LEDC_DEFAULT_CLK
|
||||
};
|
||||
ledc_timer_config_t ledc_timer = {.speed_mode = group, .timer_num = timer, .duty_resolution = 10, .freq_hz = freq, .clk_cfg = LEDC_DEFAULT_CLK};
|
||||
|
||||
if (ledc_timer_config(&ledc_timer) != ESP_OK) {
|
||||
log_e("ledcWriteTone configuration failed!");
|
||||
@ -218,9 +199,8 @@ uint32_t ledcWriteTone(uint8_t pin, uint32_t freq) {
|
||||
}
|
||||
|
||||
uint32_t ledcWriteNote(uint8_t pin, note_t note, uint8_t octave) {
|
||||
const uint16_t noteFrequencyBase[12] = {
|
||||
// C C# D Eb E F F# G G# A Bb B
|
||||
4186, 4435, 4699, 4978, 5274, 5588, 5920, 6272, 6645, 7040, 7459, 7902
|
||||
const uint16_t noteFrequencyBase[12] = {// C C# D Eb E F F# G G# A Bb B
|
||||
4186, 4435, 4699, 4978, 5274, 5588, 5920, 6272, 6645, 7040, 7459, 7902
|
||||
};
|
||||
|
||||
if (octave > 8 || note >= NOTE_MAX) {
|
||||
@ -254,13 +234,7 @@ uint32_t ledcChangeFrequency(uint8_t pin, uint32_t freq, uint8_t resolution) {
|
||||
}
|
||||
uint8_t group = (bus->channel / 8), timer = ((bus->channel / 2) % 4);
|
||||
|
||||
ledc_timer_config_t ledc_timer = {
|
||||
.speed_mode = group,
|
||||
.timer_num = timer,
|
||||
.duty_resolution = resolution,
|
||||
.freq_hz = freq,
|
||||
.clk_cfg = LEDC_DEFAULT_CLK
|
||||
};
|
||||
ledc_timer_config_t ledc_timer = {.speed_mode = group, .timer_num = timer, .duty_resolution = resolution, .freq_hz = freq, .clk_cfg = LEDC_DEFAULT_CLK};
|
||||
|
||||
if (ledc_timer_config(&ledc_timer) != ESP_OK) {
|
||||
log_e("ledcChangeFrequency failed!");
|
||||
@ -336,9 +310,7 @@ static bool ledcFadeConfig(uint8_t pin, uint32_t start_duty, uint32_t target_dut
|
||||
bus->fn = (voidFuncPtr)userFunc;
|
||||
bus->arg = arg;
|
||||
|
||||
ledc_cbs_t callbacks = {
|
||||
.fade_cb = ledcFnWrapper
|
||||
};
|
||||
ledc_cbs_t callbacks = {.fade_cb = ledcFnWrapper};
|
||||
ledc_cb_register(group, channel, &callbacks, (void *)bus);
|
||||
|
||||
//Fixing if all bits in resolution is set = LEDC FULL ON
|
||||
@ -359,8 +331,7 @@ static bool ledcFadeConfig(uint8_t pin, uint32_t start_duty, uint32_t target_dut
|
||||
return false;
|
||||
}
|
||||
// Wait for LEDCs next PWM cycle to update duty (~ 1-2 ms)
|
||||
while (ledc_get_duty(group, channel) != start_duty)
|
||||
;
|
||||
while (ledc_get_duty(group, channel) != start_duty);
|
||||
|
||||
if (ledc_set_fade_time_and_start(group, channel, target_duty, max_fade_time_ms, LEDC_FADE_NO_WAIT) != ESP_OK) {
|
||||
log_e("ledc_set_fade_time_and_start failed");
|
||||
|
@ -27,37 +27,37 @@ extern "C" {
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/semphr.h"
|
||||
|
||||
typedef enum {
|
||||
NOTE_C,
|
||||
NOTE_Cs,
|
||||
NOTE_D,
|
||||
NOTE_Eb,
|
||||
NOTE_E,
|
||||
NOTE_F,
|
||||
NOTE_Fs,
|
||||
NOTE_G,
|
||||
NOTE_Gs,
|
||||
NOTE_A,
|
||||
NOTE_Bb,
|
||||
NOTE_B,
|
||||
NOTE_MAX
|
||||
} note_t;
|
||||
typedef enum {
|
||||
NOTE_C,
|
||||
NOTE_Cs,
|
||||
NOTE_D,
|
||||
NOTE_Eb,
|
||||
NOTE_E,
|
||||
NOTE_F,
|
||||
NOTE_Fs,
|
||||
NOTE_G,
|
||||
NOTE_Gs,
|
||||
NOTE_A,
|
||||
NOTE_Bb,
|
||||
NOTE_B,
|
||||
NOTE_MAX
|
||||
} note_t;
|
||||
|
||||
typedef void (*voidFuncPtr)(void);
|
||||
typedef void (*voidFuncPtrArg)(void*);
|
||||
typedef void (*voidFuncPtr)(void);
|
||||
typedef void (*voidFuncPtrArg)(void *);
|
||||
|
||||
typedef struct {
|
||||
uint8_t pin; // Pin assigned to channel
|
||||
uint8_t channel; // Channel number
|
||||
uint8_t channel_resolution; // Resolution of channel
|
||||
voidFuncPtr fn;
|
||||
void* arg;
|
||||
typedef struct {
|
||||
uint8_t pin; // Pin assigned to channel
|
||||
uint8_t channel; // Channel number
|
||||
uint8_t channel_resolution; // Resolution of channel
|
||||
voidFuncPtr fn;
|
||||
void *arg;
|
||||
#ifndef SOC_LEDC_SUPPORT_FADE_STOP
|
||||
SemaphoreHandle_t lock; //xSemaphoreCreateBinary
|
||||
SemaphoreHandle_t lock; //xSemaphoreCreateBinary
|
||||
#endif
|
||||
} ledc_channel_handle_t;
|
||||
} ledc_channel_handle_t;
|
||||
|
||||
/**
|
||||
/**
|
||||
* @brief Attach a pin to the LEDC driver, with a given frequency and resolution.
|
||||
* Channel is automatically assigned.
|
||||
*
|
||||
@ -67,9 +67,9 @@ extern "C" {
|
||||
*
|
||||
* @return true if configuration is successful and pin was successfully attached, false otherwise.
|
||||
*/
|
||||
bool ledcAttach(uint8_t pin, uint32_t freq, uint8_t resolution);
|
||||
bool ledcAttach(uint8_t pin, uint32_t freq, uint8_t resolution);
|
||||
|
||||
/**
|
||||
/**
|
||||
* @brief Attach a pin to the LEDC driver, with a given frequency, resolution and channel.
|
||||
*
|
||||
* @param pin GPIO pin
|
||||
@ -79,9 +79,9 @@ extern "C" {
|
||||
*
|
||||
* @return true if configuration is successful and pin was successfully attached, false otherwise.
|
||||
*/
|
||||
bool ledcAttachChannel(uint8_t pin, uint32_t freq, uint8_t resolution, uint8_t channel);
|
||||
bool ledcAttachChannel(uint8_t pin, uint32_t freq, uint8_t resolution, uint8_t channel);
|
||||
|
||||
/**
|
||||
/**
|
||||
* @brief Set the duty cycle of a given pin.
|
||||
*
|
||||
* @param pin GPIO pin
|
||||
@ -89,9 +89,9 @@ extern "C" {
|
||||
*
|
||||
* @return true if duty cycle was successfully set, false otherwise.
|
||||
*/
|
||||
bool ledcWrite(uint8_t pin, uint32_t duty);
|
||||
bool ledcWrite(uint8_t pin, uint32_t duty);
|
||||
|
||||
/**
|
||||
/**
|
||||
* @brief Sets the duty to 50 % PWM tone on selected frequency.
|
||||
*
|
||||
* @param pin GPIO pin
|
||||
@ -100,9 +100,9 @@ extern "C" {
|
||||
* @return frequency if tone was successfully set.
|
||||
* If ``0`` is returned, error occurs and LEDC pin was not configured.
|
||||
*/
|
||||
uint32_t ledcWriteTone(uint8_t pin, uint32_t freq);
|
||||
uint32_t ledcWriteTone(uint8_t pin, uint32_t freq);
|
||||
|
||||
/**
|
||||
/**
|
||||
* @brief Sets the LEDC pin to specific note.
|
||||
*
|
||||
* @param pin GPIO pin
|
||||
@ -112,36 +112,36 @@ extern "C" {
|
||||
* @return frequency if note was successfully set.
|
||||
* If ``0`` is returned, error occurs and LEDC pin was not configured.
|
||||
*/
|
||||
uint32_t ledcWriteNote(uint8_t pin, note_t note, uint8_t octave);
|
||||
uint32_t ledcWriteNote(uint8_t pin, note_t note, uint8_t octave);
|
||||
|
||||
/**
|
||||
/**
|
||||
* @brief Read the duty cycle of a given LEDC pin.
|
||||
*
|
||||
* @param pin GPIO pin
|
||||
*
|
||||
* @return duty cycle of selected LEDC pin.
|
||||
*/
|
||||
uint32_t ledcRead(uint8_t pin);
|
||||
uint32_t ledcRead(uint8_t pin);
|
||||
|
||||
/**
|
||||
/**
|
||||
* @brief Read the frequency of a given LEDC pin.
|
||||
*
|
||||
* @param pin GPIO pin
|
||||
*
|
||||
* @return frequency of selected LEDC pin.
|
||||
*/
|
||||
uint32_t ledcReadFreq(uint8_t pin);
|
||||
uint32_t ledcReadFreq(uint8_t pin);
|
||||
|
||||
/**
|
||||
/**
|
||||
* @brief Detach a pin from the LEDC driver.
|
||||
*
|
||||
* @param pin GPIO pin
|
||||
*
|
||||
* @return true if pin was successfully detached, false otherwise.
|
||||
*/
|
||||
bool ledcDetach(uint8_t pin);
|
||||
bool ledcDetach(uint8_t pin);
|
||||
|
||||
/**
|
||||
/**
|
||||
* @brief Change the frequency and resolution of a given LEDC pin.
|
||||
*
|
||||
* @param pin GPIO pin
|
||||
@ -151,9 +151,9 @@ extern "C" {
|
||||
* @return frequency configured for the LEDC channel.
|
||||
* If ``0`` is returned, error occurs and LEDC pin was not configured.
|
||||
*/
|
||||
uint32_t ledcChangeFrequency(uint8_t pin, uint32_t freq, uint8_t resolution);
|
||||
uint32_t ledcChangeFrequency(uint8_t pin, uint32_t freq, uint8_t resolution);
|
||||
|
||||
/**
|
||||
/**
|
||||
* @brief Sets inverting of the output signal for a given LEDC pin.
|
||||
*
|
||||
* @param pin GPIO pin
|
||||
@ -161,10 +161,10 @@ extern "C" {
|
||||
*
|
||||
* @return true if output inverting was successfully set, false otherwise.
|
||||
*/
|
||||
bool ledcOutputInvert(uint8_t pin, bool out_invert);
|
||||
bool ledcOutputInvert(uint8_t pin, bool out_invert);
|
||||
|
||||
//Fade functions
|
||||
/**
|
||||
//Fade functions
|
||||
/**
|
||||
* @brief Setup and start a fade on a given LEDC pin.
|
||||
*
|
||||
* @param pin GPIO pin
|
||||
@ -174,9 +174,9 @@ extern "C" {
|
||||
*
|
||||
* @return true if fade was successfully set and started, false otherwise.
|
||||
*/
|
||||
bool ledcFade(uint8_t pin, uint32_t start_duty, uint32_t target_duty, int max_fade_time_ms);
|
||||
bool ledcFade(uint8_t pin, uint32_t start_duty, uint32_t target_duty, int max_fade_time_ms);
|
||||
|
||||
/**
|
||||
/**
|
||||
* @brief Setup and start a fade on a given LEDC pin with a callback function.
|
||||
*
|
||||
* @param pin GPIO pin
|
||||
@ -187,9 +187,9 @@ extern "C" {
|
||||
*
|
||||
* @return true if fade was successfully set and started, false otherwise.
|
||||
*/
|
||||
bool ledcFadeWithInterrupt(uint8_t pin, uint32_t start_duty, uint32_t target_duty, int max_fade_time_ms, void (*userFunc)(void));
|
||||
bool ledcFadeWithInterrupt(uint8_t pin, uint32_t start_duty, uint32_t target_duty, int max_fade_time_ms, void (*userFunc)(void));
|
||||
|
||||
/**
|
||||
/**
|
||||
* @brief Setup and start a fade on a given LEDC pin with a callback function and argument.
|
||||
*
|
||||
* @param pin GPIO pin
|
||||
@ -201,7 +201,7 @@ extern "C" {
|
||||
*
|
||||
* @return true if fade was successfully set and started, false otherwise.
|
||||
*/
|
||||
bool ledcFadeWithInterruptArg(uint8_t pin, uint32_t start_duty, uint32_t target_duty, int max_fade_time_ms, void (*userFunc)(void*), void* arg);
|
||||
bool ledcFadeWithInterruptArg(uint8_t pin, uint32_t start_duty, uint32_t target_duty, int max_fade_time_ms, void (*userFunc)(void *), void *arg);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -21,11 +21,11 @@ extern "C" {
|
||||
#include "sdkconfig.h"
|
||||
#include "esp_timer.h"
|
||||
|
||||
#define ARDUHAL_LOG_LEVEL_NONE (0)
|
||||
#define ARDUHAL_LOG_LEVEL_ERROR (1)
|
||||
#define ARDUHAL_LOG_LEVEL_WARN (2)
|
||||
#define ARDUHAL_LOG_LEVEL_INFO (3)
|
||||
#define ARDUHAL_LOG_LEVEL_DEBUG (4)
|
||||
#define ARDUHAL_LOG_LEVEL_NONE (0)
|
||||
#define ARDUHAL_LOG_LEVEL_ERROR (1)
|
||||
#define ARDUHAL_LOG_LEVEL_WARN (2)
|
||||
#define ARDUHAL_LOG_LEVEL_INFO (3)
|
||||
#define ARDUHAL_LOG_LEVEL_DEBUG (4)
|
||||
#define ARDUHAL_LOG_LEVEL_VERBOSE (5)
|
||||
|
||||
#ifndef CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL
|
||||
@ -48,27 +48,27 @@ extern "C" {
|
||||
#endif
|
||||
|
||||
#if CONFIG_ARDUHAL_LOG_COLORS
|
||||
#define ARDUHAL_LOG_COLOR_BLACK "30"
|
||||
#define ARDUHAL_LOG_COLOR_RED "31" //ERROR
|
||||
#define ARDUHAL_LOG_COLOR_GREEN "32" //INFO
|
||||
#define ARDUHAL_LOG_COLOR_YELLOW "33" //WARNING
|
||||
#define ARDUHAL_LOG_COLOR_BLUE "34"
|
||||
#define ARDUHAL_LOG_COLOR_BLACK "30"
|
||||
#define ARDUHAL_LOG_COLOR_RED "31" //ERROR
|
||||
#define ARDUHAL_LOG_COLOR_GREEN "32" //INFO
|
||||
#define ARDUHAL_LOG_COLOR_YELLOW "33" //WARNING
|
||||
#define ARDUHAL_LOG_COLOR_BLUE "34"
|
||||
#define ARDUHAL_LOG_COLOR_MAGENTA "35"
|
||||
#define ARDUHAL_LOG_COLOR_CYAN "36" //DEBUG
|
||||
#define ARDUHAL_LOG_COLOR_GRAY "37" //VERBOSE
|
||||
#define ARDUHAL_LOG_COLOR_WHITE "38"
|
||||
#define ARDUHAL_LOG_COLOR_CYAN "36" //DEBUG
|
||||
#define ARDUHAL_LOG_COLOR_GRAY "37" //VERBOSE
|
||||
#define ARDUHAL_LOG_COLOR_WHITE "38"
|
||||
|
||||
#define ARDUHAL_LOG_COLOR(COLOR) "\033[0;" COLOR "m"
|
||||
#define ARDUHAL_LOG_BOLD(COLOR) "\033[1;" COLOR "m"
|
||||
#define ARDUHAL_LOG_RESET_COLOR "\033[0m"
|
||||
#define ARDUHAL_LOG_BOLD(COLOR) "\033[1;" COLOR "m"
|
||||
#define ARDUHAL_LOG_RESET_COLOR "\033[0m"
|
||||
|
||||
#define ARDUHAL_LOG_COLOR_E ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_RED)
|
||||
#define ARDUHAL_LOG_COLOR_W ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_YELLOW)
|
||||
#define ARDUHAL_LOG_COLOR_I ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_GREEN)
|
||||
#define ARDUHAL_LOG_COLOR_D ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_CYAN)
|
||||
#define ARDUHAL_LOG_COLOR_V ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_GRAY)
|
||||
#define ARDUHAL_LOG_COLOR_E ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_RED)
|
||||
#define ARDUHAL_LOG_COLOR_W ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_YELLOW)
|
||||
#define ARDUHAL_LOG_COLOR_I ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_GREEN)
|
||||
#define ARDUHAL_LOG_COLOR_D ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_CYAN)
|
||||
#define ARDUHAL_LOG_COLOR_V ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_GRAY)
|
||||
#define ARDUHAL_LOG_COLOR_PRINT(letter) log_printf(ARDUHAL_LOG_COLOR_##letter)
|
||||
#define ARDUHAL_LOG_COLOR_PRINT_END log_printf(ARDUHAL_LOG_RESET_COLOR)
|
||||
#define ARDUHAL_LOG_COLOR_PRINT_END log_printf(ARDUHAL_LOG_RESET_COLOR)
|
||||
#else
|
||||
#define ARDUHAL_LOG_COLOR_E
|
||||
#define ARDUHAL_LOG_COLOR_W
|
||||
@ -80,194 +80,230 @@ extern "C" {
|
||||
#define ARDUHAL_LOG_COLOR_PRINT_END
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
const char *pathToFileName(const char *path);
|
||||
int log_printf(const char *fmt, ...);
|
||||
void log_print_buf(const uint8_t *b, size_t len);
|
||||
const char *pathToFileName(const char *path);
|
||||
int log_printf(const char *fmt, ...);
|
||||
void log_print_buf(const uint8_t *b, size_t len);
|
||||
|
||||
#define ARDUHAL_SHORT_LOG_FORMAT(letter, format) ARDUHAL_LOG_COLOR_##letter format ARDUHAL_LOG_RESET_COLOR "\r\n"
|
||||
#define ARDUHAL_LOG_FORMAT(letter, format) ARDUHAL_LOG_COLOR_##letter "[%6u][" #letter "][%s:%u] %s(): " format ARDUHAL_LOG_RESET_COLOR "\r\n", (unsigned long)(esp_timer_get_time() / 1000ULL), pathToFileName(__FILE__), __LINE__, __FUNCTION__
|
||||
#define ARDUHAL_LOG_FORMAT(letter, format) \
|
||||
ARDUHAL_LOG_COLOR_##letter "[%6u][" #letter "][%s:%u] %s(): " format ARDUHAL_LOG_RESET_COLOR "\r\n", (unsigned long)(esp_timer_get_time() / 1000ULL), \
|
||||
pathToFileName(__FILE__), __LINE__, __FUNCTION__
|
||||
|
||||
//esp_rom_printf(DRAM_STR("ST:%d\n"), frame_pos);
|
||||
//esp_rom_printf(DRAM_STR("ST:%d\n"), frame_pos);
|
||||
|
||||
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_VERBOSE
|
||||
#ifndef USE_ESP_IDF_LOG
|
||||
#define log_v(format, ...) log_printf(ARDUHAL_LOG_FORMAT(V, format), ##__VA_ARGS__)
|
||||
#define log_v(format, ...) log_printf(ARDUHAL_LOG_FORMAT(V, format), ##__VA_ARGS__)
|
||||
#define isr_log_v(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(V, format), ##__VA_ARGS__)
|
||||
#define log_buf_v(b, l) \
|
||||
do { \
|
||||
ARDUHAL_LOG_COLOR_PRINT(V); \
|
||||
log_print_buf(b, l); \
|
||||
#define log_buf_v(b, l) \
|
||||
do { \
|
||||
ARDUHAL_LOG_COLOR_PRINT(V); \
|
||||
log_print_buf(b, l); \
|
||||
ARDUHAL_LOG_COLOR_PRINT_END; \
|
||||
} while (0)
|
||||
#else
|
||||
#define log_v(format, ...) \
|
||||
do { ESP_LOG_LEVEL_LOCAL(ESP_LOG_VERBOSE, TAG, format, ##__VA_ARGS__); } while (0)
|
||||
#define isr_log_v(format, ...) \
|
||||
do { ets_printf(LOG_FORMAT(V, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); } while (0)
|
||||
#define log_buf_v(b, l) \
|
||||
do { ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_VERBOSE); } while (0)
|
||||
#define log_v(format, ...) \
|
||||
do { \
|
||||
ESP_LOG_LEVEL_LOCAL(ESP_LOG_VERBOSE, TAG, format, ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
#define isr_log_v(format, ...) \
|
||||
do { \
|
||||
ets_printf(LOG_FORMAT(V, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
#define log_buf_v(b, l) \
|
||||
do { \
|
||||
ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_VERBOSE); \
|
||||
} while (0)
|
||||
#endif
|
||||
#else
|
||||
#define log_v(format, ...) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#define isr_log_v(format, ...) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#define log_buf_v(b, l) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#endif
|
||||
|
||||
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG
|
||||
#ifndef USE_ESP_IDF_LOG
|
||||
#define log_d(format, ...) log_printf(ARDUHAL_LOG_FORMAT(D, format), ##__VA_ARGS__)
|
||||
#define log_d(format, ...) log_printf(ARDUHAL_LOG_FORMAT(D, format), ##__VA_ARGS__)
|
||||
#define isr_log_d(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(D, format), ##__VA_ARGS__)
|
||||
#define log_buf_d(b, l) \
|
||||
do { \
|
||||
ARDUHAL_LOG_COLOR_PRINT(D); \
|
||||
log_print_buf(b, l); \
|
||||
#define log_buf_d(b, l) \
|
||||
do { \
|
||||
ARDUHAL_LOG_COLOR_PRINT(D); \
|
||||
log_print_buf(b, l); \
|
||||
ARDUHAL_LOG_COLOR_PRINT_END; \
|
||||
} while (0)
|
||||
#else
|
||||
#define log_d(format, ...) \
|
||||
do { ESP_LOG_LEVEL_LOCAL(ESP_LOG_DEBUG, TAG, format, ##__VA_ARGS__); } while (0)
|
||||
#define isr_log_d(format, ...) \
|
||||
do { ets_printf(LOG_FORMAT(D, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); } while (0)
|
||||
#define log_buf_d(b, l) \
|
||||
do { ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_DEBUG); } while (0)
|
||||
#define log_d(format, ...) \
|
||||
do { \
|
||||
ESP_LOG_LEVEL_LOCAL(ESP_LOG_DEBUG, TAG, format, ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
#define isr_log_d(format, ...) \
|
||||
do { \
|
||||
ets_printf(LOG_FORMAT(D, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
#define log_buf_d(b, l) \
|
||||
do { \
|
||||
ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_DEBUG); \
|
||||
} while (0)
|
||||
#endif
|
||||
#else
|
||||
#define log_d(format, ...) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#define isr_log_d(format, ...) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#define log_buf_d(b, l) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#endif
|
||||
|
||||
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO
|
||||
#ifndef USE_ESP_IDF_LOG
|
||||
#define log_i(format, ...) log_printf(ARDUHAL_LOG_FORMAT(I, format), ##__VA_ARGS__)
|
||||
#define log_i(format, ...) log_printf(ARDUHAL_LOG_FORMAT(I, format), ##__VA_ARGS__)
|
||||
#define isr_log_i(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(I, format), ##__VA_ARGS__)
|
||||
#define log_buf_i(b, l) \
|
||||
do { \
|
||||
ARDUHAL_LOG_COLOR_PRINT(I); \
|
||||
log_print_buf(b, l); \
|
||||
#define log_buf_i(b, l) \
|
||||
do { \
|
||||
ARDUHAL_LOG_COLOR_PRINT(I); \
|
||||
log_print_buf(b, l); \
|
||||
ARDUHAL_LOG_COLOR_PRINT_END; \
|
||||
} while (0)
|
||||
#else
|
||||
#define log_i(format, ...) \
|
||||
do { ESP_LOG_LEVEL_LOCAL(ESP_LOG_INFO, TAG, format, ##__VA_ARGS__); } while (0)
|
||||
#define isr_log_i(format, ...) \
|
||||
do { ets_printf(LOG_FORMAT(I, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); } while (0)
|
||||
#define log_buf_i(b, l) \
|
||||
do { ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_INFO); } while (0)
|
||||
#define log_i(format, ...) \
|
||||
do { \
|
||||
ESP_LOG_LEVEL_LOCAL(ESP_LOG_INFO, TAG, format, ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
#define isr_log_i(format, ...) \
|
||||
do { \
|
||||
ets_printf(LOG_FORMAT(I, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
#define log_buf_i(b, l) \
|
||||
do { \
|
||||
ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_INFO); \
|
||||
} while (0)
|
||||
#endif
|
||||
#else
|
||||
#define log_i(format, ...) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#define isr_log_i(format, ...) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#define log_buf_i(b, l) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#endif
|
||||
|
||||
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_WARN
|
||||
#ifndef USE_ESP_IDF_LOG
|
||||
#define log_w(format, ...) log_printf(ARDUHAL_LOG_FORMAT(W, format), ##__VA_ARGS__)
|
||||
#define log_w(format, ...) log_printf(ARDUHAL_LOG_FORMAT(W, format), ##__VA_ARGS__)
|
||||
#define isr_log_w(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(W, format), ##__VA_ARGS__)
|
||||
#define log_buf_w(b, l) \
|
||||
do { \
|
||||
ARDUHAL_LOG_COLOR_PRINT(W); \
|
||||
log_print_buf(b, l); \
|
||||
#define log_buf_w(b, l) \
|
||||
do { \
|
||||
ARDUHAL_LOG_COLOR_PRINT(W); \
|
||||
log_print_buf(b, l); \
|
||||
ARDUHAL_LOG_COLOR_PRINT_END; \
|
||||
} while (0)
|
||||
#else
|
||||
#define log_w(format, ...) \
|
||||
do { ESP_LOG_LEVEL_LOCAL(ESP_LOG_WARN, TAG, format, ##__VA_ARGS__); } while (0)
|
||||
#define isr_log_w(format, ...) \
|
||||
do { ets_printf(LOG_FORMAT(W, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); } while (0)
|
||||
#define log_buf_w(b, l) \
|
||||
do { ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_WARN); } while (0)
|
||||
#define log_w(format, ...) \
|
||||
do { \
|
||||
ESP_LOG_LEVEL_LOCAL(ESP_LOG_WARN, TAG, format, ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
#define isr_log_w(format, ...) \
|
||||
do { \
|
||||
ets_printf(LOG_FORMAT(W, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
#define log_buf_w(b, l) \
|
||||
do { \
|
||||
ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_WARN); \
|
||||
} while (0)
|
||||
#endif
|
||||
#else
|
||||
#define log_w(format, ...) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#define isr_log_w(format, ...) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#define log_buf_w(b, l) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#endif
|
||||
|
||||
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_ERROR
|
||||
#ifndef USE_ESP_IDF_LOG
|
||||
#define log_e(format, ...) log_printf(ARDUHAL_LOG_FORMAT(E, format), ##__VA_ARGS__)
|
||||
#define log_e(format, ...) log_printf(ARDUHAL_LOG_FORMAT(E, format), ##__VA_ARGS__)
|
||||
#define isr_log_e(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(E, format), ##__VA_ARGS__)
|
||||
#define log_buf_e(b, l) \
|
||||
do { \
|
||||
ARDUHAL_LOG_COLOR_PRINT(E); \
|
||||
log_print_buf(b, l); \
|
||||
#define log_buf_e(b, l) \
|
||||
do { \
|
||||
ARDUHAL_LOG_COLOR_PRINT(E); \
|
||||
log_print_buf(b, l); \
|
||||
ARDUHAL_LOG_COLOR_PRINT_END; \
|
||||
} while (0)
|
||||
#else
|
||||
#define log_e(format, ...) \
|
||||
do { ESP_LOG_LEVEL_LOCAL(ESP_LOG_ERROR, TAG, format, ##__VA_ARGS__); } while (0)
|
||||
#define isr_log_e(format, ...) \
|
||||
do { ets_printf(LOG_FORMAT(E, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); } while (0)
|
||||
#define log_buf_e(b, l) \
|
||||
do { ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_ERROR); } while (0)
|
||||
#define log_e(format, ...) \
|
||||
do { \
|
||||
ESP_LOG_LEVEL_LOCAL(ESP_LOG_ERROR, TAG, format, ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
#define isr_log_e(format, ...) \
|
||||
do { \
|
||||
ets_printf(LOG_FORMAT(E, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
#define log_buf_e(b, l) \
|
||||
do { \
|
||||
ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_ERROR); \
|
||||
} while (0)
|
||||
#endif
|
||||
#else
|
||||
#define log_e(format, ...) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#define isr_log_e(format, ...) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#define log_buf_e(b, l) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#endif
|
||||
|
||||
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_NONE
|
||||
#ifndef USE_ESP_IDF_LOG
|
||||
#define log_n(format, ...) log_printf(ARDUHAL_LOG_FORMAT(E, format), ##__VA_ARGS__)
|
||||
#define log_n(format, ...) log_printf(ARDUHAL_LOG_FORMAT(E, format), ##__VA_ARGS__)
|
||||
#define isr_log_n(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(E, format), ##__VA_ARGS__)
|
||||
#define log_buf_n(b, l) \
|
||||
do { \
|
||||
ARDUHAL_LOG_COLOR_PRINT(E); \
|
||||
log_print_buf(b, l); \
|
||||
#define log_buf_n(b, l) \
|
||||
do { \
|
||||
ARDUHAL_LOG_COLOR_PRINT(E); \
|
||||
log_print_buf(b, l); \
|
||||
ARDUHAL_LOG_COLOR_PRINT_END; \
|
||||
} while (0)
|
||||
#else
|
||||
#define log_n(format, ...) \
|
||||
do { ESP_LOG_LEVEL_LOCAL(ESP_LOG_ERROR, TAG, format, ##__VA_ARGS__); } while (0)
|
||||
#define isr_log_n(format, ...) \
|
||||
do { ets_printf(LOG_FORMAT(E, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); } while (0)
|
||||
#define log_buf_n(b, l) \
|
||||
do { ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_ERROR); } while (0)
|
||||
#define log_n(format, ...) \
|
||||
do { \
|
||||
ESP_LOG_LEVEL_LOCAL(ESP_LOG_ERROR, TAG, format, ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
#define isr_log_n(format, ...) \
|
||||
do { \
|
||||
ets_printf(LOG_FORMAT(E, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
#define log_buf_n(b, l) \
|
||||
do { \
|
||||
ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_ERROR); \
|
||||
} while (0)
|
||||
#endif
|
||||
#else
|
||||
#define log_n(format, ...) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#define isr_log_n(format, ...) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#define log_buf_n(b, l) \
|
||||
do { \
|
||||
do { \
|
||||
} while (0)
|
||||
#endif
|
||||
|
||||
@ -291,11 +327,11 @@ extern "C" {
|
||||
#undef ESP_EARLY_LOGD
|
||||
#undef ESP_EARLY_LOGV
|
||||
|
||||
#define ESP_LOGE(tag, format, ...) log_e("[%s] " format, tag, ##__VA_ARGS__)
|
||||
#define ESP_LOGW(tag, format, ...) log_w("[%s] " format, tag, ##__VA_ARGS__)
|
||||
#define ESP_LOGI(tag, format, ...) log_i("[%s] " format, tag, ##__VA_ARGS__)
|
||||
#define ESP_LOGD(tag, format, ...) log_d("[%s] " format, tag, ##__VA_ARGS__)
|
||||
#define ESP_LOGV(tag, format, ...) log_v("[%s] " format, tag, ##__VA_ARGS__)
|
||||
#define ESP_LOGE(tag, format, ...) log_e("[%s] " format, tag, ##__VA_ARGS__)
|
||||
#define ESP_LOGW(tag, format, ...) log_w("[%s] " format, tag, ##__VA_ARGS__)
|
||||
#define ESP_LOGI(tag, format, ...) log_i("[%s] " format, tag, ##__VA_ARGS__)
|
||||
#define ESP_LOGD(tag, format, ...) log_d("[%s] " format, tag, ##__VA_ARGS__)
|
||||
#define ESP_LOGV(tag, format, ...) log_v("[%s] " format, tag, ##__VA_ARGS__)
|
||||
#define ESP_EARLY_LOGE(tag, format, ...) isr_log_e("[%s] " format, tag, ##__VA_ARGS__)
|
||||
#define ESP_EARLY_LOGW(tag, format, ...) isr_log_w("[%s] " format, tag, ##__VA_ARGS__)
|
||||
#define ESP_EARLY_LOGI(tag, format, ...) isr_log_i("[%s] " format, tag, ##__VA_ARGS__)
|
||||
|
@ -38,10 +38,9 @@
|
||||
#else // ESP32 Before IDF 4.0
|
||||
#include "rom/gpio.h"
|
||||
#define GPIO_MATRIX_CONST_ZERO_INPUT GPIO_FUNC_IN_LOW
|
||||
#define GPIO_MATRIX_CONST_ONE_INPUT GPIO_FUNC_IN_HIGH
|
||||
#define GPIO_MATRIX_CONST_ONE_INPUT GPIO_FUNC_IN_HIGH
|
||||
#endif
|
||||
|
||||
|
||||
void ARDUINO_ISR_ATTR pinMatrixOutAttach(uint8_t pin, uint8_t function, bool invertOut, bool invertEnable) {
|
||||
gpio_matrix_out(pin, function, invertOut, invertEnable);
|
||||
}
|
||||
|
@ -15,7 +15,6 @@
|
||||
#ifndef _ESP32_HAL_MATRIX_H_
|
||||
#define _ESP32_HAL_MATRIX_H_
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
@ -23,10 +22,10 @@ extern "C" {
|
||||
#include "esp32-hal.h"
|
||||
#include "soc/gpio_sig_map.h"
|
||||
|
||||
void pinMatrixOutAttach(uint8_t pin, uint8_t function, bool invertOut, bool invertEnable);
|
||||
void pinMatrixOutDetach(uint8_t pin, bool invertOut, bool invertEnable);
|
||||
void pinMatrixInAttach(uint8_t pin, uint8_t signal, bool inverted);
|
||||
void pinMatrixInDetach(uint8_t signal, bool high, bool inverted);
|
||||
void pinMatrixOutAttach(uint8_t pin, uint8_t function, bool invertOut, bool invertEnable);
|
||||
void pinMatrixOutDetach(uint8_t pin, bool invertOut, bool invertEnable);
|
||||
void pinMatrixInAttach(uint8_t pin, uint8_t signal, bool inverted);
|
||||
void pinMatrixInDetach(uint8_t signal, bool high, bool inverted);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -176,13 +176,10 @@ void disableCore1WDT() {
|
||||
}
|
||||
#endif
|
||||
|
||||
BaseType_t xTaskCreateUniversal(TaskFunction_t pxTaskCode,
|
||||
const char *const pcName,
|
||||
const uint32_t usStackDepth,
|
||||
void *const pvParameters,
|
||||
UBaseType_t uxPriority,
|
||||
TaskHandle_t *const pxCreatedTask,
|
||||
const BaseType_t xCoreID) {
|
||||
BaseType_t xTaskCreateUniversal(
|
||||
TaskFunction_t pxTaskCode, const char *const pcName, const uint32_t usStackDepth, void *const pvParameters, UBaseType_t uxPriority,
|
||||
TaskHandle_t *const pxCreatedTask, const BaseType_t xCoreID
|
||||
) {
|
||||
#ifndef CONFIG_FREERTOS_UNICORE
|
||||
if (xCoreID >= 0 && xCoreID < 2) {
|
||||
return xTaskCreatePinnedToCore(pxTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask, xCoreID);
|
||||
@ -356,7 +353,7 @@ static void handle_custom_backtrace(panic_info_t *info) {
|
||||
|
||||
#if CONFIG_IDF_TARGET_ARCH_XTENSA
|
||||
XtExcFrame *xt_frame = (XtExcFrame *)info->frame;
|
||||
esp_backtrace_frame_t stk_frame = { .pc = xt_frame->pc, .sp = xt_frame->a1, .next_pc = xt_frame->a0, .exc_frame = xt_frame };
|
||||
esp_backtrace_frame_t stk_frame = {.pc = xt_frame->pc, .sp = xt_frame->a1, .next_pc = xt_frame->a0, .exc_frame = xt_frame};
|
||||
uint32_t i = 100, pc_ptr = esp_cpu_process_stack_pc(stk_frame.pc);
|
||||
p_info.backtrace[p_info.backtrace_len++] = pc_ptr;
|
||||
|
||||
|
@ -10,8 +10,8 @@
|
||||
|
||||
typedef struct ATTR_PACKED {
|
||||
peripheral_bus_type_t type;
|
||||
const char* extra_type;
|
||||
void* bus;
|
||||
const char *extra_type;
|
||||
void *bus;
|
||||
int8_t bus_num;
|
||||
int8_t bus_channel;
|
||||
} peripheral_pin_item_t;
|
||||
@ -21,12 +21,12 @@ static peripheral_pin_item_t pins[SOC_GPIO_PIN_COUNT];
|
||||
|
||||
#define GPIO_NOT_VALID(p) ((p >= SOC_GPIO_PIN_COUNT) || ((SOC_GPIO_VALID_GPIO_MASK & (1ULL << p)) == 0))
|
||||
|
||||
const char* perimanGetTypeName(peripheral_bus_type_t type) {
|
||||
const char *perimanGetTypeName(peripheral_bus_type_t type) {
|
||||
switch (type) {
|
||||
case ESP32_BUS_TYPE_INIT: return "INIT";
|
||||
case ESP32_BUS_TYPE_GPIO: return "GPIO";
|
||||
case ESP32_BUS_TYPE_UART_RX: return "UART_RX";
|
||||
case ESP32_BUS_TYPE_UART_TX: return "UART_TX";
|
||||
case ESP32_BUS_TYPE_INIT: return "INIT";
|
||||
case ESP32_BUS_TYPE_GPIO: return "GPIO";
|
||||
case ESP32_BUS_TYPE_UART_RX: return "UART_RX";
|
||||
case ESP32_BUS_TYPE_UART_TX: return "UART_TX";
|
||||
case ESP32_BUS_TYPE_UART_CTS: return "UART_CTS";
|
||||
case ESP32_BUS_TYPE_UART_RTS: return "UART_RTS";
|
||||
#if SOC_SDM_SUPPORTED
|
||||
@ -34,12 +34,12 @@ const char* perimanGetTypeName(peripheral_bus_type_t type) {
|
||||
#endif
|
||||
#if SOC_ADC_SUPPORTED
|
||||
case ESP32_BUS_TYPE_ADC_ONESHOT: return "ADC_ONESHOT";
|
||||
case ESP32_BUS_TYPE_ADC_CONT: return "ADC_CONT";
|
||||
case ESP32_BUS_TYPE_ADC_CONT: return "ADC_CONT";
|
||||
#endif
|
||||
#if SOC_DAC_SUPPORTED
|
||||
case ESP32_BUS_TYPE_DAC_ONESHOT: return "DAC_ONESHOT";
|
||||
case ESP32_BUS_TYPE_DAC_CONT: return "DAC_CONT";
|
||||
case ESP32_BUS_TYPE_DAC_COSINE: return "DAC_COSINE";
|
||||
case ESP32_BUS_TYPE_DAC_CONT: return "DAC_CONT";
|
||||
case ESP32_BUS_TYPE_DAC_COSINE: return "DAC_COSINE";
|
||||
#endif
|
||||
#if SOC_LEDC_SUPPORTED
|
||||
case ESP32_BUS_TYPE_LEDC: return "LEDC";
|
||||
@ -49,44 +49,44 @@ const char* perimanGetTypeName(peripheral_bus_type_t type) {
|
||||
case ESP32_BUS_TYPE_RMT_RX: return "RMT_RX";
|
||||
#endif
|
||||
#if SOC_I2S_SUPPORTED
|
||||
case ESP32_BUS_TYPE_I2S_STD_MCLK: return "I2S_STD_MCLK";
|
||||
case ESP32_BUS_TYPE_I2S_STD_BCLK: return "I2S_STD_BCLK";
|
||||
case ESP32_BUS_TYPE_I2S_STD_WS: return "I2S_STD_WS";
|
||||
case ESP32_BUS_TYPE_I2S_STD_DOUT: return "I2S_STD_DOUT";
|
||||
case ESP32_BUS_TYPE_I2S_STD_DIN: return "I2S_STD_DIN";
|
||||
case ESP32_BUS_TYPE_I2S_TDM_MCLK: return "I2S_TDM_MCLK";
|
||||
case ESP32_BUS_TYPE_I2S_TDM_BCLK: return "I2S_TDM_BCLK";
|
||||
case ESP32_BUS_TYPE_I2S_TDM_WS: return "I2S_TDM_WS";
|
||||
case ESP32_BUS_TYPE_I2S_TDM_DOUT: return "I2S_TDM_DOUT";
|
||||
case ESP32_BUS_TYPE_I2S_TDM_DIN: return "I2S_TDM_DIN";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_TX_CLK: return "I2S_PDM_TX_CLK";
|
||||
case ESP32_BUS_TYPE_I2S_STD_MCLK: return "I2S_STD_MCLK";
|
||||
case ESP32_BUS_TYPE_I2S_STD_BCLK: return "I2S_STD_BCLK";
|
||||
case ESP32_BUS_TYPE_I2S_STD_WS: return "I2S_STD_WS";
|
||||
case ESP32_BUS_TYPE_I2S_STD_DOUT: return "I2S_STD_DOUT";
|
||||
case ESP32_BUS_TYPE_I2S_STD_DIN: return "I2S_STD_DIN";
|
||||
case ESP32_BUS_TYPE_I2S_TDM_MCLK: return "I2S_TDM_MCLK";
|
||||
case ESP32_BUS_TYPE_I2S_TDM_BCLK: return "I2S_TDM_BCLK";
|
||||
case ESP32_BUS_TYPE_I2S_TDM_WS: return "I2S_TDM_WS";
|
||||
case ESP32_BUS_TYPE_I2S_TDM_DOUT: return "I2S_TDM_DOUT";
|
||||
case ESP32_BUS_TYPE_I2S_TDM_DIN: return "I2S_TDM_DIN";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_TX_CLK: return "I2S_PDM_TX_CLK";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_TX_DOUT0: return "I2S_PDM_TX_DOUT0";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_TX_DOUT1: return "I2S_PDM_TX_DOUT1";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_RX_CLK: return "I2S_PDM_RX_CLK";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_RX_DIN0: return "I2S_PDM_RX_DIN0";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_RX_DIN1: return "I2S_PDM_RX_DIN1";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_RX_DIN2: return "I2S_PDM_RX_DIN2";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_RX_DIN3: return "I2S_PDM_RX_DIN3";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_RX_CLK: return "I2S_PDM_RX_CLK";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_RX_DIN0: return "I2S_PDM_RX_DIN0";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_RX_DIN1: return "I2S_PDM_RX_DIN1";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_RX_DIN2: return "I2S_PDM_RX_DIN2";
|
||||
case ESP32_BUS_TYPE_I2S_PDM_RX_DIN3: return "I2S_PDM_RX_DIN3";
|
||||
#endif
|
||||
#if SOC_I2C_SUPPORTED
|
||||
case ESP32_BUS_TYPE_I2C_MASTER_SDA: return "I2C_MASTER_SDA";
|
||||
case ESP32_BUS_TYPE_I2C_MASTER_SCL: return "I2C_MASTER_SCL";
|
||||
case ESP32_BUS_TYPE_I2C_SLAVE_SDA: return "I2C_SLAVE_SDA";
|
||||
case ESP32_BUS_TYPE_I2C_SLAVE_SCL: return "I2C_SLAVE_SCL";
|
||||
case ESP32_BUS_TYPE_I2C_SLAVE_SDA: return "I2C_SLAVE_SDA";
|
||||
case ESP32_BUS_TYPE_I2C_SLAVE_SCL: return "I2C_SLAVE_SCL";
|
||||
#endif
|
||||
#if SOC_GPSPI_SUPPORTED
|
||||
case ESP32_BUS_TYPE_SPI_MASTER_SCK: return "SPI_MASTER_SCK";
|
||||
case ESP32_BUS_TYPE_SPI_MASTER_SCK: return "SPI_MASTER_SCK";
|
||||
case ESP32_BUS_TYPE_SPI_MASTER_MISO: return "SPI_MASTER_MISO";
|
||||
case ESP32_BUS_TYPE_SPI_MASTER_MOSI: return "SPI_MASTER_MOSI";
|
||||
case ESP32_BUS_TYPE_SPI_MASTER_SS: return "SPI_MASTER_SS";
|
||||
case ESP32_BUS_TYPE_SPI_MASTER_SS: return "SPI_MASTER_SS";
|
||||
#endif
|
||||
#if SOC_SDMMC_HOST_SUPPORTED
|
||||
case ESP32_BUS_TYPE_SDMMC_CLK: return "SDMMC_CLK";
|
||||
case ESP32_BUS_TYPE_SDMMC_CMD: return "SDMMC_CMD";
|
||||
case ESP32_BUS_TYPE_SDMMC_D0: return "SDMMC_D0";
|
||||
case ESP32_BUS_TYPE_SDMMC_D1: return "SDMMC_D1";
|
||||
case ESP32_BUS_TYPE_SDMMC_D2: return "SDMMC_D2";
|
||||
case ESP32_BUS_TYPE_SDMMC_D3: return "SDMMC_D3";
|
||||
case ESP32_BUS_TYPE_SDMMC_D0: return "SDMMC_D0";
|
||||
case ESP32_BUS_TYPE_SDMMC_D1: return "SDMMC_D1";
|
||||
case ESP32_BUS_TYPE_SDMMC_D2: return "SDMMC_D2";
|
||||
case ESP32_BUS_TYPE_SDMMC_D3: return "SDMMC_D3";
|
||||
#endif
|
||||
#if SOC_TOUCH_SENSOR_SUPPORTED
|
||||
case ESP32_BUS_TYPE_TOUCH: return "TOUCH";
|
||||
@ -100,14 +100,14 @@ const char* perimanGetTypeName(peripheral_bus_type_t type) {
|
||||
#endif
|
||||
#if CONFIG_ETH_USE_ESP32_EMAC
|
||||
case ESP32_BUS_TYPE_ETHERNET_RMII: return "ETHERNET_RMII";
|
||||
case ESP32_BUS_TYPE_ETHERNET_CLK: return "ETHERNET_CLK";
|
||||
case ESP32_BUS_TYPE_ETHERNET_MCD: return "ETHERNET_MCD";
|
||||
case ESP32_BUS_TYPE_ETHERNET_CLK: return "ETHERNET_CLK";
|
||||
case ESP32_BUS_TYPE_ETHERNET_MCD: return "ETHERNET_MCD";
|
||||
case ESP32_BUS_TYPE_ETHERNET_MDIO: return "ETHERNET_MDIO";
|
||||
case ESP32_BUS_TYPE_ETHERNET_PWR: return "ETHERNET_PWR";
|
||||
case ESP32_BUS_TYPE_ETHERNET_PWR: return "ETHERNET_PWR";
|
||||
#endif
|
||||
#if CONFIG_LWIP_PPP_SUPPORT
|
||||
case ESP32_BUS_TYPE_PPP_TX: return "PPP_MODEM_TX";
|
||||
case ESP32_BUS_TYPE_PPP_RX: return "PPP_MODEM_RX";
|
||||
case ESP32_BUS_TYPE_PPP_TX: return "PPP_MODEM_TX";
|
||||
case ESP32_BUS_TYPE_PPP_RX: return "PPP_MODEM_RX";
|
||||
case ESP32_BUS_TYPE_PPP_RTS: return "PPP_MODEM_RTS";
|
||||
case ESP32_BUS_TYPE_PPP_CTS: return "PPP_MODEM_CTS";
|
||||
#endif
|
||||
@ -115,9 +115,9 @@ const char* perimanGetTypeName(peripheral_bus_type_t type) {
|
||||
}
|
||||
}
|
||||
|
||||
bool perimanSetPinBus(uint8_t pin, peripheral_bus_type_t type, void* bus, int8_t bus_num, int8_t bus_channel) {
|
||||
bool perimanSetPinBus(uint8_t pin, peripheral_bus_type_t type, void *bus, int8_t bus_num, int8_t bus_channel) {
|
||||
peripheral_bus_type_t otype = ESP32_BUS_TYPE_INIT;
|
||||
void* obus = NULL;
|
||||
void *obus = NULL;
|
||||
if (GPIO_NOT_VALID(pin)) {
|
||||
log_e("Invalid pin: %u", pin);
|
||||
return false;
|
||||
@ -161,7 +161,7 @@ bool perimanSetPinBus(uint8_t pin, peripheral_bus_type_t type, void* bus, int8_t
|
||||
return true;
|
||||
}
|
||||
|
||||
bool perimanSetPinBusExtraType(uint8_t pin, const char* extra_type) {
|
||||
bool perimanSetPinBusExtraType(uint8_t pin, const char *extra_type) {
|
||||
if (GPIO_NOT_VALID(pin)) {
|
||||
log_e("Invalid pin: %u", pin);
|
||||
return false;
|
||||
@ -175,7 +175,7 @@ bool perimanSetPinBusExtraType(uint8_t pin, const char* extra_type) {
|
||||
return true;
|
||||
}
|
||||
|
||||
void* perimanGetPinBus(uint8_t pin, peripheral_bus_type_t type) {
|
||||
void *perimanGetPinBus(uint8_t pin, peripheral_bus_type_t type) {
|
||||
if (GPIO_NOT_VALID(pin)) {
|
||||
log_e("Invalid pin: %u", pin);
|
||||
return NULL;
|
||||
@ -198,7 +198,7 @@ peripheral_bus_type_t perimanGetPinBusType(uint8_t pin) {
|
||||
return pins[pin].type;
|
||||
}
|
||||
|
||||
const char* perimanGetPinBusExtraType(uint8_t pin) {
|
||||
const char *perimanGetPinBusExtraType(uint8_t pin) {
|
||||
if (GPIO_NOT_VALID(pin)) {
|
||||
log_e("Invalid pin: %u", pin);
|
||||
return NULL;
|
||||
|
@ -17,131 +17,131 @@ extern "C" {
|
||||
|
||||
#define perimanClearPinBus(p) perimanSetPinBus(p, ESP32_BUS_TYPE_INIT, NULL, -1, -1)
|
||||
|
||||
typedef enum {
|
||||
ESP32_BUS_TYPE_INIT, // IO has not been attached to a bus yet
|
||||
ESP32_BUS_TYPE_GPIO, // IO is used as GPIO
|
||||
ESP32_BUS_TYPE_UART_RX, // IO is used as UART RX pin
|
||||
ESP32_BUS_TYPE_UART_TX, // IO is used as UART TX pin
|
||||
ESP32_BUS_TYPE_UART_CTS, // IO is used as UART CTS pin
|
||||
ESP32_BUS_TYPE_UART_RTS, // IO is used as UART RTS pin
|
||||
typedef enum {
|
||||
ESP32_BUS_TYPE_INIT, // IO has not been attached to a bus yet
|
||||
ESP32_BUS_TYPE_GPIO, // IO is used as GPIO
|
||||
ESP32_BUS_TYPE_UART_RX, // IO is used as UART RX pin
|
||||
ESP32_BUS_TYPE_UART_TX, // IO is used as UART TX pin
|
||||
ESP32_BUS_TYPE_UART_CTS, // IO is used as UART CTS pin
|
||||
ESP32_BUS_TYPE_UART_RTS, // IO is used as UART RTS pin
|
||||
#if SOC_SDM_SUPPORTED
|
||||
ESP32_BUS_TYPE_SIGMADELTA, // IO is used as SigmeDelta output
|
||||
ESP32_BUS_TYPE_SIGMADELTA, // IO is used as SigmeDelta output
|
||||
#endif
|
||||
#if SOC_ADC_SUPPORTED
|
||||
ESP32_BUS_TYPE_ADC_ONESHOT, // IO is used as ADC OneShot input
|
||||
ESP32_BUS_TYPE_ADC_CONT, // IO is used as ADC continuous input
|
||||
ESP32_BUS_TYPE_ADC_ONESHOT, // IO is used as ADC OneShot input
|
||||
ESP32_BUS_TYPE_ADC_CONT, // IO is used as ADC continuous input
|
||||
#endif
|
||||
#if SOC_DAC_SUPPORTED
|
||||
ESP32_BUS_TYPE_DAC_ONESHOT, // IO is used as DAC OneShot output
|
||||
ESP32_BUS_TYPE_DAC_CONT, // IO is used as DAC continuous output
|
||||
ESP32_BUS_TYPE_DAC_COSINE, // IO is used as DAC cosine output
|
||||
ESP32_BUS_TYPE_DAC_ONESHOT, // IO is used as DAC OneShot output
|
||||
ESP32_BUS_TYPE_DAC_CONT, // IO is used as DAC continuous output
|
||||
ESP32_BUS_TYPE_DAC_COSINE, // IO is used as DAC cosine output
|
||||
#endif
|
||||
#if SOC_LEDC_SUPPORTED
|
||||
ESP32_BUS_TYPE_LEDC, // IO is used as LEDC output
|
||||
ESP32_BUS_TYPE_LEDC, // IO is used as LEDC output
|
||||
#endif
|
||||
#if SOC_RMT_SUPPORTED
|
||||
ESP32_BUS_TYPE_RMT_TX, // IO is used as RMT output
|
||||
ESP32_BUS_TYPE_RMT_RX, // IO is used as RMT input
|
||||
ESP32_BUS_TYPE_RMT_TX, // IO is used as RMT output
|
||||
ESP32_BUS_TYPE_RMT_RX, // IO is used as RMT input
|
||||
#endif
|
||||
#if SOC_I2S_SUPPORTED
|
||||
ESP32_BUS_TYPE_I2S_STD_MCLK, // IO is used as I2S STD MCLK pin
|
||||
ESP32_BUS_TYPE_I2S_STD_BCLK, // IO is used as I2S STD BCLK pin
|
||||
ESP32_BUS_TYPE_I2S_STD_WS, // IO is used as I2S STD WS pin
|
||||
ESP32_BUS_TYPE_I2S_STD_DOUT, // IO is used as I2S STD DOUT pin
|
||||
ESP32_BUS_TYPE_I2S_STD_DIN, // IO is used as I2S STD DIN pin
|
||||
ESP32_BUS_TYPE_I2S_STD_MCLK, // IO is used as I2S STD MCLK pin
|
||||
ESP32_BUS_TYPE_I2S_STD_BCLK, // IO is used as I2S STD BCLK pin
|
||||
ESP32_BUS_TYPE_I2S_STD_WS, // IO is used as I2S STD WS pin
|
||||
ESP32_BUS_TYPE_I2S_STD_DOUT, // IO is used as I2S STD DOUT pin
|
||||
ESP32_BUS_TYPE_I2S_STD_DIN, // IO is used as I2S STD DIN pin
|
||||
|
||||
ESP32_BUS_TYPE_I2S_TDM_MCLK, // IO is used as I2S TDM MCLK pin
|
||||
ESP32_BUS_TYPE_I2S_TDM_BCLK, // IO is used as I2S TDM BCLK pin
|
||||
ESP32_BUS_TYPE_I2S_TDM_WS, // IO is used as I2S TDM WS pin
|
||||
ESP32_BUS_TYPE_I2S_TDM_DOUT, // IO is used as I2S TDM DOUT pin
|
||||
ESP32_BUS_TYPE_I2S_TDM_DIN, // IO is used as I2S TDM DIN pin
|
||||
ESP32_BUS_TYPE_I2S_TDM_MCLK, // IO is used as I2S TDM MCLK pin
|
||||
ESP32_BUS_TYPE_I2S_TDM_BCLK, // IO is used as I2S TDM BCLK pin
|
||||
ESP32_BUS_TYPE_I2S_TDM_WS, // IO is used as I2S TDM WS pin
|
||||
ESP32_BUS_TYPE_I2S_TDM_DOUT, // IO is used as I2S TDM DOUT pin
|
||||
ESP32_BUS_TYPE_I2S_TDM_DIN, // IO is used as I2S TDM DIN pin
|
||||
|
||||
ESP32_BUS_TYPE_I2S_PDM_TX_CLK, // IO is used as I2S PDM CLK pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_TX_DOUT0, // IO is used as I2S PDM DOUT0 pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_TX_DOUT1, // IO is used as I2S PDM DOUT1 pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_TX_CLK, // IO is used as I2S PDM CLK pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_TX_DOUT0, // IO is used as I2S PDM DOUT0 pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_TX_DOUT1, // IO is used as I2S PDM DOUT1 pin
|
||||
|
||||
ESP32_BUS_TYPE_I2S_PDM_RX_CLK, // IO is used as I2S PDM CLK pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_RX_DIN0, // IO is used as I2S PDM DIN0 pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_RX_DIN1, // IO is used as I2S PDM DIN1 pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_RX_DIN2, // IO is used as I2S PDM DIN2 pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_RX_DIN3, // IO is used as I2S PDM DIN3 pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_RX_CLK, // IO is used as I2S PDM CLK pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_RX_DIN0, // IO is used as I2S PDM DIN0 pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_RX_DIN1, // IO is used as I2S PDM DIN1 pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_RX_DIN2, // IO is used as I2S PDM DIN2 pin
|
||||
ESP32_BUS_TYPE_I2S_PDM_RX_DIN3, // IO is used as I2S PDM DIN3 pin
|
||||
#endif
|
||||
#if SOC_I2C_SUPPORTED
|
||||
ESP32_BUS_TYPE_I2C_MASTER_SDA, // IO is used as I2C master SDA pin
|
||||
ESP32_BUS_TYPE_I2C_MASTER_SCL, // IO is used as I2C master SCL pin
|
||||
ESP32_BUS_TYPE_I2C_SLAVE_SDA, // IO is used as I2C slave SDA pin
|
||||
ESP32_BUS_TYPE_I2C_SLAVE_SCL, // IO is used as I2C slave SCL pin
|
||||
ESP32_BUS_TYPE_I2C_MASTER_SDA, // IO is used as I2C master SDA pin
|
||||
ESP32_BUS_TYPE_I2C_MASTER_SCL, // IO is used as I2C master SCL pin
|
||||
ESP32_BUS_TYPE_I2C_SLAVE_SDA, // IO is used as I2C slave SDA pin
|
||||
ESP32_BUS_TYPE_I2C_SLAVE_SCL, // IO is used as I2C slave SCL pin
|
||||
#endif
|
||||
#if SOC_GPSPI_SUPPORTED
|
||||
ESP32_BUS_TYPE_SPI_MASTER_SCK, // IO is used as SPI master SCK pin
|
||||
ESP32_BUS_TYPE_SPI_MASTER_MISO, // IO is used as SPI master MISO pin
|
||||
ESP32_BUS_TYPE_SPI_MASTER_MOSI, // IO is used as SPI master MOSI pin
|
||||
ESP32_BUS_TYPE_SPI_MASTER_SS, // IO is used as SPI master SS pin
|
||||
ESP32_BUS_TYPE_SPI_MASTER_SCK, // IO is used as SPI master SCK pin
|
||||
ESP32_BUS_TYPE_SPI_MASTER_MISO, // IO is used as SPI master MISO pin
|
||||
ESP32_BUS_TYPE_SPI_MASTER_MOSI, // IO is used as SPI master MOSI pin
|
||||
ESP32_BUS_TYPE_SPI_MASTER_SS, // IO is used as SPI master SS pin
|
||||
#endif
|
||||
#if SOC_SDMMC_HOST_SUPPORTED
|
||||
ESP32_BUS_TYPE_SDMMC_CLK, // IO is used as SDMMC CLK pin
|
||||
ESP32_BUS_TYPE_SDMMC_CMD, // IO is used as SDMMC CMD pin
|
||||
ESP32_BUS_TYPE_SDMMC_D0, // IO is used as SDMMC D0 pin
|
||||
ESP32_BUS_TYPE_SDMMC_D1, // IO is used as SDMMC D1 pin
|
||||
ESP32_BUS_TYPE_SDMMC_D2, // IO is used as SDMMC D2 pin
|
||||
ESP32_BUS_TYPE_SDMMC_D3, // IO is used as SDMMC D3 pin
|
||||
ESP32_BUS_TYPE_SDMMC_CLK, // IO is used as SDMMC CLK pin
|
||||
ESP32_BUS_TYPE_SDMMC_CMD, // IO is used as SDMMC CMD pin
|
||||
ESP32_BUS_TYPE_SDMMC_D0, // IO is used as SDMMC D0 pin
|
||||
ESP32_BUS_TYPE_SDMMC_D1, // IO is used as SDMMC D1 pin
|
||||
ESP32_BUS_TYPE_SDMMC_D2, // IO is used as SDMMC D2 pin
|
||||
ESP32_BUS_TYPE_SDMMC_D3, // IO is used as SDMMC D3 pin
|
||||
#endif
|
||||
#if SOC_TOUCH_SENSOR_SUPPORTED
|
||||
ESP32_BUS_TYPE_TOUCH, // IO is used as TOUCH pin
|
||||
ESP32_BUS_TYPE_TOUCH, // IO is used as TOUCH pin
|
||||
#endif
|
||||
#if SOC_USB_SERIAL_JTAG_SUPPORTED || SOC_USB_OTG_SUPPORTED
|
||||
ESP32_BUS_TYPE_USB_DM, // IO is used as USB DM (+) pin
|
||||
ESP32_BUS_TYPE_USB_DP, // IO is used as USB DP (-) pin
|
||||
ESP32_BUS_TYPE_USB_DM, // IO is used as USB DM (+) pin
|
||||
ESP32_BUS_TYPE_USB_DP, // IO is used as USB DP (-) pin
|
||||
#endif
|
||||
#if SOC_GPSPI_SUPPORTED
|
||||
ESP32_BUS_TYPE_ETHERNET_SPI, // IO is used as ETHERNET SPI pin
|
||||
ESP32_BUS_TYPE_ETHERNET_SPI, // IO is used as ETHERNET SPI pin
|
||||
#endif
|
||||
#if CONFIG_ETH_USE_ESP32_EMAC
|
||||
ESP32_BUS_TYPE_ETHERNET_RMII, // IO is used as ETHERNET RMII pin
|
||||
ESP32_BUS_TYPE_ETHERNET_CLK, // IO is used as ETHERNET CLK pin
|
||||
ESP32_BUS_TYPE_ETHERNET_MCD, // IO is used as ETHERNET MCD pin
|
||||
ESP32_BUS_TYPE_ETHERNET_MDIO, // IO is used as ETHERNET MDIO pin
|
||||
ESP32_BUS_TYPE_ETHERNET_PWR, // IO is used as ETHERNET PWR pin
|
||||
ESP32_BUS_TYPE_ETHERNET_RMII, // IO is used as ETHERNET RMII pin
|
||||
ESP32_BUS_TYPE_ETHERNET_CLK, // IO is used as ETHERNET CLK pin
|
||||
ESP32_BUS_TYPE_ETHERNET_MCD, // IO is used as ETHERNET MCD pin
|
||||
ESP32_BUS_TYPE_ETHERNET_MDIO, // IO is used as ETHERNET MDIO pin
|
||||
ESP32_BUS_TYPE_ETHERNET_PWR, // IO is used as ETHERNET PWR pin
|
||||
#endif
|
||||
#if CONFIG_LWIP_PPP_SUPPORT
|
||||
ESP32_BUS_TYPE_PPP_TX, // IO is used as PPP Modem TX pin
|
||||
ESP32_BUS_TYPE_PPP_RX, // IO is used as PPP Modem RX pin
|
||||
ESP32_BUS_TYPE_PPP_RTS, // IO is used as PPP Modem RTS pin
|
||||
ESP32_BUS_TYPE_PPP_CTS, // IO is used as PPP Modem CTS pin
|
||||
ESP32_BUS_TYPE_PPP_TX, // IO is used as PPP Modem TX pin
|
||||
ESP32_BUS_TYPE_PPP_RX, // IO is used as PPP Modem RX pin
|
||||
ESP32_BUS_TYPE_PPP_RTS, // IO is used as PPP Modem RTS pin
|
||||
ESP32_BUS_TYPE_PPP_CTS, // IO is used as PPP Modem CTS pin
|
||||
#endif
|
||||
ESP32_BUS_TYPE_MAX
|
||||
} peripheral_bus_type_t;
|
||||
ESP32_BUS_TYPE_MAX
|
||||
} peripheral_bus_type_t;
|
||||
|
||||
typedef bool (*peripheral_bus_deinit_cb_t)(void* bus);
|
||||
typedef bool (*peripheral_bus_deinit_cb_t)(void *bus);
|
||||
|
||||
const char* perimanGetTypeName(peripheral_bus_type_t type);
|
||||
const char *perimanGetTypeName(peripheral_bus_type_t type);
|
||||
|
||||
// Sets the bus type, bus handle, bus number and bus channel for given pin.
|
||||
bool perimanSetPinBus(uint8_t pin, peripheral_bus_type_t type, void* bus, int8_t bus_num, int8_t bus_channel);
|
||||
// Sets the bus type, bus handle, bus number and bus channel for given pin.
|
||||
bool perimanSetPinBus(uint8_t pin, peripheral_bus_type_t type, void *bus, int8_t bus_num, int8_t bus_channel);
|
||||
|
||||
// Returns handle of the bus for the given pin if type of bus matches. NULL otherwise
|
||||
void* perimanGetPinBus(uint8_t pin, peripheral_bus_type_t type);
|
||||
// Returns handle of the bus for the given pin if type of bus matches. NULL otherwise
|
||||
void *perimanGetPinBus(uint8_t pin, peripheral_bus_type_t type);
|
||||
|
||||
// Returns the type of the bus for the given pin if attached. ESP32_BUS_TYPE_MAX otherwise
|
||||
peripheral_bus_type_t perimanGetPinBusType(uint8_t pin);
|
||||
// Returns the type of the bus for the given pin if attached. ESP32_BUS_TYPE_MAX otherwise
|
||||
peripheral_bus_type_t perimanGetPinBusType(uint8_t pin);
|
||||
|
||||
// Returns the bus number or unit of the bus for the given pin if set. -1 otherwise
|
||||
int8_t perimanGetPinBusNum(uint8_t pin);
|
||||
// Returns the bus number or unit of the bus for the given pin if set. -1 otherwise
|
||||
int8_t perimanGetPinBusNum(uint8_t pin);
|
||||
|
||||
// Returns the bus channel of the bus for the given pin if set. -1 otherwise
|
||||
int8_t perimanGetPinBusChannel(uint8_t pin);
|
||||
// Returns the bus channel of the bus for the given pin if set. -1 otherwise
|
||||
int8_t perimanGetPinBusChannel(uint8_t pin);
|
||||
|
||||
// Sets the peripheral destructor callback. Used to destroy bus when pin is assigned another function
|
||||
bool perimanSetBusDeinit(peripheral_bus_type_t type, peripheral_bus_deinit_cb_t cb);
|
||||
// Sets the peripheral destructor callback. Used to destroy bus when pin is assigned another function
|
||||
bool perimanSetBusDeinit(peripheral_bus_type_t type, peripheral_bus_deinit_cb_t cb);
|
||||
|
||||
// Check if given pin is a valid GPIO number
|
||||
bool perimanPinIsValid(uint8_t pin);
|
||||
// Check if given pin is a valid GPIO number
|
||||
bool perimanPinIsValid(uint8_t pin);
|
||||
|
||||
// Sets the extra type for non Init bus. Used to customize pin bus name which can be printed by printPerimanInfo().
|
||||
bool perimanSetPinBusExtraType(uint8_t pin, const char* extra_type);
|
||||
// Sets the extra type for non Init bus. Used to customize pin bus name which can be printed by printPerimanInfo().
|
||||
bool perimanSetPinBusExtraType(uint8_t pin, const char *extra_type);
|
||||
|
||||
// Returns the extra type of the bus for given pin if set. NULL otherwise
|
||||
const char* perimanGetPinBusExtraType(uint8_t pin);
|
||||
// Returns the extra type of the bus for given pin if set. NULL otherwise
|
||||
const char *perimanGetPinBusExtraType(uint8_t pin);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -39,7 +39,6 @@ __attribute__((weak)) bool testSPIRAM(void) {
|
||||
return esp_psram_extram_test();
|
||||
}
|
||||
|
||||
|
||||
bool psramInit() {
|
||||
if (spiramDetected) {
|
||||
return true;
|
||||
|
@ -30,12 +30,12 @@ extern "C" {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
bool psramInit();
|
||||
bool psramFound();
|
||||
bool psramInit();
|
||||
bool psramFound();
|
||||
|
||||
void *ps_malloc(size_t size);
|
||||
void *ps_calloc(size_t n, size_t size);
|
||||
void *ps_realloc(void *ptr, size_t size);
|
||||
void *ps_malloc(size_t size);
|
||||
void *ps_calloc(size_t n, size_t size);
|
||||
void *ps_realloc(void *ptr, size_t size);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -2,7 +2,6 @@
|
||||
|
||||
#include "esp32-hal-rgb-led.h"
|
||||
|
||||
|
||||
void neopixelWrite(uint8_t pin, uint8_t red_val, uint8_t green_val, uint8_t blue_val) {
|
||||
#if SOC_RMT_SUPPORTED
|
||||
rmt_data_t led_data[24];
|
||||
@ -16,7 +15,7 @@ void neopixelWrite(uint8_t pin, uint8_t red_val, uint8_t green_val, uint8_t blue
|
||||
return;
|
||||
}
|
||||
|
||||
int color[] = { green_val, red_val, blue_val }; // Color coding is in order GREEN, RED, BLUE
|
||||
int color[] = {green_val, red_val, blue_val}; // Color coding is in order GREEN, RED, BLUE
|
||||
int i = 0;
|
||||
for (int col = 0; col < 3; col++) {
|
||||
for (int bit = 0; bit < 8; bit++) {
|
||||
|
@ -11,7 +11,7 @@ extern "C" {
|
||||
#define RGB_BRIGHTNESS 64
|
||||
#endif
|
||||
|
||||
void neopixelWrite(uint8_t pin, uint8_t red_val, uint8_t green_val, uint8_t blue_val);
|
||||
void neopixelWrite(uint8_t pin, uint8_t red_val, uint8_t green_val, uint8_t blue_val);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -41,12 +41,11 @@ extern TaskHandle_t loopTaskHandle;
|
||||
#define RMT_MUTEX_UNLOCK(busptr)
|
||||
#else
|
||||
#define RMT_MUTEX_LOCK(busptr) \
|
||||
do { \
|
||||
do { \
|
||||
} while (xSemaphoreTake(busptr->g_rmt_objlocks, portMAX_DELAY) != pdPASS)
|
||||
#define RMT_MUTEX_UNLOCK(busptr) xSemaphoreGive(busptr->g_rmt_objlocks)
|
||||
#endif /* CONFIG_DISABLE_HAL_LOCKS */
|
||||
|
||||
|
||||
/**
|
||||
Typedefs for internal structures, enums
|
||||
*/
|
||||
@ -206,7 +205,7 @@ bool rmtSetCarrier(int pin, bool carrier_en, bool carrier_level, uint32_t freque
|
||||
log_w("GPIO %d - RMT Carrier must be a float percentage from 0 to 1. Setting to 50%.", pin);
|
||||
duty_percent = 0.5;
|
||||
}
|
||||
rmt_carrier_config_t carrier_cfg = { 0 };
|
||||
rmt_carrier_config_t carrier_cfg = {0};
|
||||
carrier_cfg.duty_cycle = duty_percent; // duty cycle
|
||||
carrier_cfg.frequency_hz = carrier_en ? frequency_Hz : 0; // carrier frequency in Hz
|
||||
carrier_cfg.flags.polarity_active_low = carrier_level; // carrier modulation polarity level
|
||||
@ -303,14 +302,17 @@ static bool _rmtWrite(int pin, rmt_data_t *data, size_t num_rmt_symbols, bool bl
|
||||
}
|
||||
|
||||
log_v("GPIO: %d - Request: %d RMT Symbols - %s - Timeout: %d", pin, num_rmt_symbols, blocking ? "Blocking" : "Non-Blocking", timeout_ms);
|
||||
log_v("GPIO: %d - Currently in Loop Mode: [%s] | Asked to Loop: %s, LoopCancel: %s", pin, bus->rmt_ch_is_looping ? "YES" : "NO", loop ? "YES" : "NO", loopCancel ? "YES" : "NO");
|
||||
log_v(
|
||||
"GPIO: %d - Currently in Loop Mode: [%s] | Asked to Loop: %s, LoopCancel: %s", pin, bus->rmt_ch_is_looping ? "YES" : "NO", loop ? "YES" : "NO",
|
||||
loopCancel ? "YES" : "NO"
|
||||
);
|
||||
|
||||
if ((xEventGroupGetBits(bus->rmt_events) & RMT_FLAG_TX_DONE) == 0) {
|
||||
log_v("GPIO %d - RMT Write still pending to be completed.", pin);
|
||||
return false;
|
||||
}
|
||||
|
||||
rmt_transmit_config_t transmit_cfg = { 0 }; // loop mode disabled
|
||||
rmt_transmit_config_t transmit_cfg = {0}; // loop mode disabled
|
||||
bool retCode = true;
|
||||
|
||||
RMT_MUTEX_LOCK(bus);
|
||||
@ -348,8 +350,7 @@ static bool _rmtWrite(int pin, rmt_data_t *data, size_t num_rmt_symbols, bool bl
|
||||
} else {
|
||||
if (blocking) {
|
||||
// wait for transmission confirmation | timeout
|
||||
retCode = (xEventGroupWaitBits(bus->rmt_events, RMT_FLAG_TX_DONE, pdFALSE /* do not clear on exit */,
|
||||
pdFALSE /* wait for all bits */, timeout_ms)
|
||||
retCode = (xEventGroupWaitBits(bus->rmt_events, RMT_FLAG_TX_DONE, pdFALSE /* do not clear on exit */, pdFALSE /* wait for all bits */, timeout_ms)
|
||||
& RMT_FLAG_TX_DONE)
|
||||
!= 0;
|
||||
}
|
||||
@ -387,8 +388,7 @@ static bool _rmtRead(int pin, rmt_data_t *data, size_t *num_rmt_symbols, bool wa
|
||||
rmt_receive(bus->rmt_channel_h, data, *num_rmt_symbols * sizeof(rmt_data_t), &receive_config);
|
||||
// wait for data if requested
|
||||
if (waitForData) {
|
||||
retCode = (xEventGroupWaitBits(bus->rmt_events, RMT_FLAG_RX_DONE, pdFALSE /* do not clear on exit */,
|
||||
pdFALSE /* wait for all bits */, timeout_ms)
|
||||
retCode = (xEventGroupWaitBits(bus->rmt_events, RMT_FLAG_RX_DONE, pdFALSE /* do not clear on exit */, pdFALSE /* wait for all bits */, timeout_ms)
|
||||
& RMT_FLAG_RX_DONE)
|
||||
!= 0;
|
||||
}
|
||||
@ -397,7 +397,6 @@ static bool _rmtRead(int pin, rmt_data_t *data, size_t *num_rmt_symbols, bool wa
|
||||
return retCode;
|
||||
}
|
||||
|
||||
|
||||
bool rmtWrite(int pin, rmt_data_t *data, size_t num_rmt_symbols, uint32_t timeout_ms) {
|
||||
return _rmtWrite(pin, data, num_rmt_symbols, true /*blocks*/, false /*looping*/, timeout_ms);
|
||||
}
|
||||
@ -451,7 +450,10 @@ bool rmtReceiveCompleted(int pin) {
|
||||
}
|
||||
|
||||
bool rmtInit(int pin, rmt_ch_dir_t channel_direction, rmt_reserve_memsize_t mem_size, uint32_t frequency_Hz) {
|
||||
log_v("GPIO %d - %s - MemSize[%d] - Freq=%dHz", pin, channel_direction == RMT_RX_MODE ? "RX MODE" : "TX MODE", mem_size * RMT_SYMBOLS_PER_CHANNEL_BLOCK, frequency_Hz);
|
||||
log_v(
|
||||
"GPIO %d - %s - MemSize[%d] - Freq=%dHz", pin, channel_direction == RMT_RX_MODE ? "RX MODE" : "TX MODE", mem_size * RMT_SYMBOLS_PER_CHANNEL_BLOCK,
|
||||
frequency_Hz
|
||||
);
|
||||
|
||||
// create common block mutex for protecting allocs from multiple threads allocating RMT channels
|
||||
if (!g_rmt_block_lock) {
|
||||
@ -535,7 +537,7 @@ bool rmtInit(int pin, rmt_ch_dir_t channel_direction, rmt_reserve_memsize_t mem_
|
||||
}
|
||||
|
||||
// set TX Callback
|
||||
rmt_tx_event_callbacks_t cbs = { .on_trans_done = _rmt_tx_done_callback };
|
||||
rmt_tx_event_callbacks_t cbs = {.on_trans_done = _rmt_tx_done_callback};
|
||||
if (ESP_OK != rmt_tx_register_event_callbacks(bus->rmt_channel_h, &cbs, bus)) {
|
||||
log_e("GPIO %d RMT - Error registering TX Callback.", pin);
|
||||
goto Err;
|
||||
@ -562,7 +564,7 @@ bool rmtInit(int pin, rmt_ch_dir_t channel_direction, rmt_reserve_memsize_t mem_
|
||||
}
|
||||
|
||||
// set RX Callback
|
||||
rmt_rx_event_callbacks_t cbs = { .on_recv_done = _rmt_rx_done_callback };
|
||||
rmt_rx_event_callbacks_t cbs = {.on_recv_done = _rmt_rx_done_callback};
|
||||
if (ESP_OK != rmt_rx_register_event_callbacks(bus->rmt_channel_h, &cbs, bus)) {
|
||||
log_e("GPIO %d RMT - Error registering RX Callback.", pin);
|
||||
goto Err;
|
||||
@ -588,8 +590,7 @@ bool rmtInit(int pin, rmt_ch_dir_t channel_direction, rmt_reserve_memsize_t mem_
|
||||
rmt_enable(bus->rmt_channel_h); // starts/enables the channel
|
||||
|
||||
// Finally, allocate Peripheral Manager RMT bus and associate it to its GPIO
|
||||
peripheral_bus_type_t pinBusType =
|
||||
channel_direction == RMT_TX_MODE ? ESP32_BUS_TYPE_RMT_TX : ESP32_BUS_TYPE_RMT_RX;
|
||||
peripheral_bus_type_t pinBusType = channel_direction == RMT_TX_MODE ? ESP32_BUS_TYPE_RMT_TX : ESP32_BUS_TYPE_RMT_RX;
|
||||
if (!perimanSetPinBus(pin, pinBusType, (void *)bus, -1, -1)) {
|
||||
log_e("Can't allocate the GPIO %d in the Peripheral Manager.", pin);
|
||||
goto Err;
|
||||
|
@ -22,37 +22,37 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
RMT_RX_MODE = 0, // false
|
||||
RMT_TX_MODE = 1, // true
|
||||
} rmt_ch_dir_t;
|
||||
typedef enum {
|
||||
RMT_RX_MODE = 0, // false
|
||||
RMT_TX_MODE = 1, // true
|
||||
} rmt_ch_dir_t;
|
||||
|
||||
typedef enum {
|
||||
RMT_MEM_NUM_BLOCKS_1 = 1,
|
||||
RMT_MEM_NUM_BLOCKS_2 = 2,
|
||||
typedef enum {
|
||||
RMT_MEM_NUM_BLOCKS_1 = 1,
|
||||
RMT_MEM_NUM_BLOCKS_2 = 2,
|
||||
#if SOC_RMT_TX_CANDIDATES_PER_GROUP > 2
|
||||
RMT_MEM_NUM_BLOCKS_3 = 3,
|
||||
RMT_MEM_NUM_BLOCKS_4 = 4,
|
||||
RMT_MEM_NUM_BLOCKS_3 = 3,
|
||||
RMT_MEM_NUM_BLOCKS_4 = 4,
|
||||
#if SOC_RMT_TX_CANDIDATES_PER_GROUP > 4
|
||||
RMT_MEM_NUM_BLOCKS_5 = 5,
|
||||
RMT_MEM_NUM_BLOCKS_6 = 6,
|
||||
RMT_MEM_NUM_BLOCKS_7 = 7,
|
||||
RMT_MEM_NUM_BLOCKS_8 = 8,
|
||||
RMT_MEM_NUM_BLOCKS_5 = 5,
|
||||
RMT_MEM_NUM_BLOCKS_6 = 6,
|
||||
RMT_MEM_NUM_BLOCKS_7 = 7,
|
||||
RMT_MEM_NUM_BLOCKS_8 = 8,
|
||||
#endif
|
||||
#endif
|
||||
} rmt_reserve_memsize_t;
|
||||
} rmt_reserve_memsize_t;
|
||||
|
||||
// Each RMT Symbols has 4 bytes
|
||||
// Total number of bytes per RMT_MEM_BLOCK is RMT_SYMBOLS_PER_CHANNEL_BLOCK * 4 bytes
|
||||
typedef union {
|
||||
struct {
|
||||
uint32_t duration0 : 15;
|
||||
uint32_t level0 : 1;
|
||||
uint32_t duration1 : 15;
|
||||
uint32_t level1 : 1;
|
||||
};
|
||||
uint32_t val;
|
||||
} rmt_data_t;
|
||||
// Each RMT Symbols has 4 bytes
|
||||
// Total number of bytes per RMT_MEM_BLOCK is RMT_SYMBOLS_PER_CHANNEL_BLOCK * 4 bytes
|
||||
typedef union {
|
||||
struct {
|
||||
uint32_t duration0 : 15;
|
||||
uint32_t level0 : 1;
|
||||
uint32_t duration1 : 15;
|
||||
uint32_t level1 : 1;
|
||||
};
|
||||
uint32_t val;
|
||||
} rmt_data_t;
|
||||
|
||||
// Reading and Writing shall use as rmt_symbols_size this unit
|
||||
// ESP32 has 8 MEM BLOCKS in total shared with Reading and/or Writing
|
||||
@ -67,16 +67,16 @@ extern "C" {
|
||||
// Helper macro to calculate the number of RTM symbols in a array or type
|
||||
#define RMT_SYMBOLS_OF(x) (sizeof(x) / sizeof(rmt_data_t))
|
||||
|
||||
/**
|
||||
/**
|
||||
Initialize the object
|
||||
|
||||
New Parameters in Arduino Core 3: RMT tick is set in the rmtInit() function by the
|
||||
frequency of the RMT channel. Example: 100ns tick => 10MHz, thus frequency will be 10,000,000 Hz
|
||||
Returns <true> on execution success, <false> otherwise
|
||||
*/
|
||||
bool rmtInit(int pin, rmt_ch_dir_t channel_direction, rmt_reserve_memsize_t memsize, uint32_t frequency_Hz);
|
||||
bool rmtInit(int pin, rmt_ch_dir_t channel_direction, rmt_reserve_memsize_t memsize, uint32_t frequency_Hz);
|
||||
|
||||
/**
|
||||
/**
|
||||
Sets the End of Transmission level to be set for the <pin> when the RMT transmission ends.
|
||||
This function affects how rmtWrite(), rmtWriteAsync() or rmtWriteLooping() will set the pin after writing the data.
|
||||
The default EOT level is LOW, in case this function isn't used before RMT Writing.
|
||||
@ -88,9 +88,9 @@ extern "C" {
|
||||
|
||||
Returns <true> when EOT has been correctly set for <pin>, <false> otherwise.
|
||||
*/
|
||||
bool rmtSetEOT(int pin, uint8_t EOT_Level);
|
||||
bool rmtSetEOT(int pin, uint8_t EOT_Level);
|
||||
|
||||
/**
|
||||
/**
|
||||
Sending data in Blocking Mode.
|
||||
<rmt_symbol> is a 32 bits structure as defined by rmt_data_t type.
|
||||
It is possible to use the macro RMT_SYMBOLS_OF(data), if data is an array of <rmt_data_t>.
|
||||
@ -105,9 +105,9 @@ extern "C" {
|
||||
Returns <true> when there is no error in the write operation, <false> otherwise, including when it
|
||||
exits by timeout.
|
||||
*/
|
||||
bool rmtWrite(int pin, rmt_data_t *data, size_t num_rmt_symbols, uint32_t timeout_ms);
|
||||
bool rmtWrite(int pin, rmt_data_t *data, size_t num_rmt_symbols, uint32_t timeout_ms);
|
||||
|
||||
/**
|
||||
/**
|
||||
Sending data in Async Mode.
|
||||
<rmt_symbol> is a 32 bits structure as defined by rmt_data_t type.
|
||||
It is possible to use the macro RMT_SYMBOLS_OF(data), if <data> is an array of <rmt_data_t>
|
||||
@ -121,9 +121,9 @@ extern "C" {
|
||||
|
||||
<bool rmtTransmitCompleted(int pin)> will return <true> when all data is sent.
|
||||
*/
|
||||
bool rmtWriteAsync(int pin, rmt_data_t *data, size_t num_rmt_symbols);
|
||||
bool rmtWriteAsync(int pin, rmt_data_t *data, size_t num_rmt_symbols);
|
||||
|
||||
/**
|
||||
/**
|
||||
Writing data up to the reserved memsize, looping continuously
|
||||
<rmt_symbol> is a 32 bits structure as defined by rmt_data_t type.
|
||||
It is possible to use the macro RMT_SYMBOLS_OF(data), if data is an array of rmt_data_t
|
||||
@ -135,9 +135,9 @@ extern "C" {
|
||||
|
||||
<bool rmtTransmitCompleted(int pin)> will return always <true> while it is looping.
|
||||
*/
|
||||
bool rmtWriteLooping(int pin, rmt_data_t *data, size_t num_rmt_symbols);
|
||||
bool rmtWriteLooping(int pin, rmt_data_t *data, size_t num_rmt_symbols);
|
||||
|
||||
/**
|
||||
/**
|
||||
Checks if transmission is completed and the rmtChannel ready for transmitting new data.
|
||||
To be ready for a new transmission, means that the previous transmission is completed.
|
||||
Returns <true> when all data has been sent, <false> otherwise.
|
||||
@ -147,9 +147,9 @@ extern "C" {
|
||||
rmtTranmitCompleted() will always return <true> when rmtWriteLooping() is called,
|
||||
because it has no effect in such case.
|
||||
*/
|
||||
bool rmtTransmitCompleted(int pin);
|
||||
bool rmtTransmitCompleted(int pin);
|
||||
|
||||
/**
|
||||
/**
|
||||
Initiates blocking receive. Read data will be stored in a user provided buffer <*data>
|
||||
It will read up to <num_rmt_symbols> RMT Symbols and the value of this variable will
|
||||
change to the effective number of symbols read.
|
||||
@ -167,9 +167,9 @@ extern "C" {
|
||||
will read RMT data latter asynchronously, affecting <*data> and <*num_rmt_symbols>. After timeout,
|
||||
the application can check if data is already available using <rmtReceiveCompleted(int pin)>
|
||||
*/
|
||||
bool rmtRead(int pin, rmt_data_t *data, size_t *num_rmt_symbols, uint32_t timeout_ms);
|
||||
bool rmtRead(int pin, rmt_data_t *data, size_t *num_rmt_symbols, uint32_t timeout_ms);
|
||||
|
||||
/**
|
||||
/**
|
||||
Initiates async (non-blocking) receive. It will return immediately after execution.
|
||||
Read data will be stored in a user provided buffer <*data>.
|
||||
It will read up to <num_rmt_symbols> RMT Symbols and the value of this variable will
|
||||
@ -181,16 +181,16 @@ extern "C" {
|
||||
the RMT received data to the user buffer <data> when the read operation happens.
|
||||
The application can check if data is already available using <rmtReceiveCompleted(int pin)>
|
||||
*/
|
||||
bool rmtReadAsync(int pin, rmt_data_t *data, size_t *num_rmt_symbols);
|
||||
bool rmtReadAsync(int pin, rmt_data_t *data, size_t *num_rmt_symbols);
|
||||
|
||||
/**
|
||||
/**
|
||||
Checks if a data reception is completed and the rmtChannel has new data for processing.
|
||||
Returns <true> when data has been received, <false> otherwise.
|
||||
The data reception information is reset when a new rmtRead/Async function is called.
|
||||
*/
|
||||
bool rmtReceiveCompleted(int pin);
|
||||
bool rmtReceiveCompleted(int pin);
|
||||
|
||||
/**
|
||||
/**
|
||||
Function used to set a threshold (in ticks) used to consider that a data reception has ended.
|
||||
In receive mode, when no edge is detected on the input signal for longer than idle_thres_ticks
|
||||
time, the receiving process is finished and the Data is made available by
|
||||
@ -198,9 +198,9 @@ extern "C" {
|
||||
define how many low/high bits are read at the end of the received data.
|
||||
The function returns <true> if it is correctly executed, <false> otherwise.
|
||||
*/
|
||||
bool rmtSetRxMaxThreshold(int pin, uint16_t idle_thres_ticks);
|
||||
bool rmtSetRxMaxThreshold(int pin, uint16_t idle_thres_ticks);
|
||||
|
||||
/**
|
||||
/**
|
||||
Parameters changed in Arduino Core 3: low and high (ticks) are now expressed in Carrier Freq in Hz and
|
||||
duty cycle in percentage float 0.0 to 1.0 - example: 38.5KHz 33% High => 38500, 0.33
|
||||
|
||||
@ -211,22 +211,22 @@ extern "C" {
|
||||
<duty_percent> is a float deom 0 to 1 (0.5 means a square wave) of the carrier frequency
|
||||
The function returns <true> if it is correctly executed, <false> otherwise.
|
||||
*/
|
||||
bool rmtSetCarrier(int pin, bool carrier_en, bool carrier_level, uint32_t frequency_Hz, float duty_percent);
|
||||
bool rmtSetCarrier(int pin, bool carrier_en, bool carrier_level, uint32_t frequency_Hz, float duty_percent);
|
||||
|
||||
/**
|
||||
/**
|
||||
Function used to filter input noise in the RX channel.
|
||||
In receiving mode, channel will ignore any input pulse which width (high or low)
|
||||
is smaller than <filter_pulse_ticks>
|
||||
If <filter_pulse_ns> is Zero, it will to disable the filter.
|
||||
The function returns <true> if it is correctly executed, <false> otherwise.
|
||||
*/
|
||||
bool rmtSetRxMinThreshold(int pin, uint8_t filter_pulse_ticks);
|
||||
bool rmtSetRxMinThreshold(int pin, uint8_t filter_pulse_ticks);
|
||||
|
||||
/**
|
||||
/**
|
||||
Deinitializes the driver and releases all allocated memory
|
||||
It also disables RMT for this gpio
|
||||
*/
|
||||
bool rmtDeinit(int pin);
|
||||
bool rmtDeinit(int pin);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -34,14 +34,7 @@ bool sigmaDeltaAttach(uint8_t pin, uint32_t freq) //freq 1220-312500
|
||||
log_e("Pin %u could not be detached.", pin);
|
||||
return false;
|
||||
}
|
||||
sdm_config_t config = {
|
||||
.gpio_num = (int)pin,
|
||||
.clk_src = SDM_CLK_SRC_DEFAULT,
|
||||
.sample_rate_hz = freq,
|
||||
.flags = {
|
||||
.invert_out = 0,
|
||||
.io_loop_back = 0 }
|
||||
};
|
||||
sdm_config_t config = {.gpio_num = (int)pin, .clk_src = SDM_CLK_SRC_DEFAULT, .sample_rate_hz = freq, .flags = {.invert_out = 0, .io_loop_back = 0}};
|
||||
esp_err_t err = sdm_new_channel(&config, &bus);
|
||||
if (err != ESP_OK) {
|
||||
log_e("sdm_new_channel failed with error: %d", err);
|
||||
|
@ -16,10 +16,10 @@ extern "C" {
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
//freq 1220-312500 duty 0-255
|
||||
bool sigmaDeltaAttach(uint8_t pin, uint32_t freq);
|
||||
bool sigmaDeltaWrite(uint8_t pin, uint8_t duty);
|
||||
bool sigmaDeltaDetach(uint8_t pin);
|
||||
//freq 1220-312500 duty 0-255
|
||||
bool sigmaDeltaAttach(uint8_t pin, uint32_t freq);
|
||||
bool sigmaDeltaWrite(uint8_t pin, uint8_t duty);
|
||||
bool sigmaDeltaDetach(uint8_t pin);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -75,50 +75,50 @@ struct spi_struct_t {
|
||||
// ESP32S2
|
||||
#define SPI_COUNT (3)
|
||||
|
||||
#define SPI_CLK_IDX(p) ((p == 0) ? SPICLK_OUT_MUX_IDX : ((p == 1) ? FSPICLK_OUT_MUX_IDX : ((p == 2) ? SPI3_CLK_OUT_MUX_IDX : 0)))
|
||||
#define SPI_CLK_IDX(p) ((p == 0) ? SPICLK_OUT_MUX_IDX : ((p == 1) ? FSPICLK_OUT_MUX_IDX : ((p == 2) ? SPI3_CLK_OUT_MUX_IDX : 0)))
|
||||
#define SPI_MISO_IDX(p) ((p == 0) ? SPIQ_OUT_IDX : ((p == 1) ? FSPIQ_OUT_IDX : ((p == 2) ? SPI3_Q_OUT_IDX : 0)))
|
||||
#define SPI_MOSI_IDX(p) ((p == 0) ? SPID_IN_IDX : ((p == 1) ? FSPID_IN_IDX : ((p == 2) ? SPI3_D_IN_IDX : 0)))
|
||||
|
||||
#define SPI_SPI_SS_IDX(n) ((n == 0) ? SPICS0_OUT_IDX : ((n == 1) ? SPICS1_OUT_IDX : 0))
|
||||
#define SPI_SPI_SS_IDX(n) ((n == 0) ? SPICS0_OUT_IDX : ((n == 1) ? SPICS1_OUT_IDX : 0))
|
||||
#define SPI_HSPI_SS_IDX(n) ((n == 0) ? SPI3_CS0_OUT_IDX : ((n == 1) ? SPI3_CS1_OUT_IDX : ((n == 2) ? SPI3_CS2_OUT_IDX : SPI3_CS0_OUT_IDX)))
|
||||
#define SPI_FSPI_SS_IDX(n) ((n == 0) ? FSPICS0_OUT_IDX : ((n == 1) ? FSPICS1_OUT_IDX : ((n == 2) ? FSPICS2_OUT_IDX : FSPICS0_OUT_IDX)))
|
||||
#define SPI_SS_IDX(p, n) ((p == 0) ? SPI_SPI_SS_IDX(n) : ((p == 1) ? SPI_SPI_SS_IDX(n) : ((p == 2) ? SPI_HSPI_SS_IDX(n) : 0)))
|
||||
#define SPI_SS_IDX(p, n) ((p == 0) ? SPI_SPI_SS_IDX(n) : ((p == 1) ? SPI_SPI_SS_IDX(n) : ((p == 2) ? SPI_HSPI_SS_IDX(n) : 0)))
|
||||
|
||||
#elif CONFIG_IDF_TARGET_ESP32S3
|
||||
// ESP32S3
|
||||
#define SPI_COUNT (2)
|
||||
|
||||
#define SPI_CLK_IDX(p) ((p == 0) ? FSPICLK_OUT_IDX : ((p == 1) ? SPI3_CLK_OUT_IDX : 0))
|
||||
#define SPI_CLK_IDX(p) ((p == 0) ? FSPICLK_OUT_IDX : ((p == 1) ? SPI3_CLK_OUT_IDX : 0))
|
||||
#define SPI_MISO_IDX(p) ((p == 0) ? FSPIQ_OUT_IDX : ((p == 1) ? SPI3_Q_OUT_IDX : 0))
|
||||
#define SPI_MOSI_IDX(p) ((p == 0) ? FSPID_IN_IDX : ((p == 1) ? SPI3_D_IN_IDX : 0))
|
||||
|
||||
#define SPI_HSPI_SS_IDX(n) ((n == 0) ? SPI3_CS0_OUT_IDX : ((n == 1) ? SPI3_CS1_OUT_IDX : 0))
|
||||
#define SPI_FSPI_SS_IDX(n) ((n == 0) ? FSPICS0_OUT_IDX : ((n == 1) ? FSPICS1_OUT_IDX : 0))
|
||||
#define SPI_SS_IDX(p, n) ((p == 0) ? SPI_FSPI_SS_IDX(n) : ((p == 1) ? SPI_HSPI_SS_IDX(n) : 0))
|
||||
#define SPI_SS_IDX(p, n) ((p == 0) ? SPI_FSPI_SS_IDX(n) : ((p == 1) ? SPI_HSPI_SS_IDX(n) : 0))
|
||||
|
||||
#elif CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
// ESP32C3
|
||||
#define SPI_COUNT (1)
|
||||
|
||||
#define SPI_CLK_IDX(p) FSPICLK_OUT_IDX
|
||||
#define SPI_CLK_IDX(p) FSPICLK_OUT_IDX
|
||||
#define SPI_MISO_IDX(p) FSPIQ_OUT_IDX
|
||||
#define SPI_MOSI_IDX(p) FSPID_IN_IDX
|
||||
|
||||
#define SPI_SPI_SS_IDX(n) ((n == 0) ? FSPICS0_OUT_IDX : ((n == 1) ? FSPICS1_OUT_IDX : ((n == 2) ? FSPICS2_OUT_IDX : FSPICS0_OUT_IDX)))
|
||||
#define SPI_SS_IDX(p, n) SPI_SPI_SS_IDX(n)
|
||||
#define SPI_SS_IDX(p, n) SPI_SPI_SS_IDX(n)
|
||||
|
||||
#else
|
||||
// ESP32
|
||||
#define SPI_COUNT (4)
|
||||
|
||||
#define SPI_CLK_IDX(p) ((p == 0) ? SPICLK_OUT_IDX : ((p == 1) ? SPICLK_OUT_IDX : ((p == 2) ? HSPICLK_OUT_IDX : ((p == 3) ? VSPICLK_OUT_IDX : 0))))
|
||||
#define SPI_CLK_IDX(p) ((p == 0) ? SPICLK_OUT_IDX : ((p == 1) ? SPICLK_OUT_IDX : ((p == 2) ? HSPICLK_OUT_IDX : ((p == 3) ? VSPICLK_OUT_IDX : 0))))
|
||||
#define SPI_MISO_IDX(p) ((p == 0) ? SPIQ_OUT_IDX : ((p == 1) ? SPIQ_OUT_IDX : ((p == 2) ? HSPIQ_OUT_IDX : ((p == 3) ? VSPIQ_OUT_IDX : 0))))
|
||||
#define SPI_MOSI_IDX(p) ((p == 0) ? SPID_IN_IDX : ((p == 1) ? SPID_IN_IDX : ((p == 2) ? HSPID_IN_IDX : ((p == 3) ? VSPID_IN_IDX : 0))))
|
||||
|
||||
#define SPI_SPI_SS_IDX(n) ((n == 0) ? SPICS0_OUT_IDX : ((n == 1) ? SPICS1_OUT_IDX : ((n == 2) ? SPICS2_OUT_IDX : SPICS0_OUT_IDX)))
|
||||
#define SPI_SPI_SS_IDX(n) ((n == 0) ? SPICS0_OUT_IDX : ((n == 1) ? SPICS1_OUT_IDX : ((n == 2) ? SPICS2_OUT_IDX : SPICS0_OUT_IDX)))
|
||||
#define SPI_HSPI_SS_IDX(n) ((n == 0) ? HSPICS0_OUT_IDX : ((n == 1) ? HSPICS1_OUT_IDX : ((n == 2) ? HSPICS2_OUT_IDX : HSPICS0_OUT_IDX)))
|
||||
#define SPI_VSPI_SS_IDX(n) ((n == 0) ? VSPICS0_OUT_IDX : ((n == 1) ? VSPICS1_OUT_IDX : ((n == 2) ? VSPICS2_OUT_IDX : VSPICS0_OUT_IDX)))
|
||||
#define SPI_SS_IDX(p, n) ((p == 0) ? SPI_SPI_SS_IDX(n) : ((p == 1) ? SPI_SPI_SS_IDX(n) : ((p == 2) ? SPI_HSPI_SS_IDX(n) : ((p == 3) ? SPI_VSPI_SS_IDX(n) : 0))))
|
||||
#define SPI_SS_IDX(p, n) ((p == 0) ? SPI_SPI_SS_IDX(n) : ((p == 1) ? SPI_SPI_SS_IDX(n) : ((p == 2) ? SPI_HSPI_SS_IDX(n) : ((p == 3) ? SPI_VSPI_SS_IDX(n) : 0))))
|
||||
|
||||
#endif
|
||||
|
||||
@ -128,50 +128,48 @@ struct spi_struct_t {
|
||||
|
||||
static spi_t _spi_bus_array[] = {
|
||||
#if CONFIG_IDF_TARGET_ESP32S2
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI1_BASE), 0, -1, -1, -1, -1 },
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI2_BASE), 1, -1, -1, -1, -1 },
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI3_BASE), 2, -1, -1, -1, -1 }
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI1_BASE), 0, -1, -1, -1, -1},
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), 1, -1, -1, -1, -1},
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI3_BASE), 2, -1, -1, -1, -1}
|
||||
#elif CONFIG_IDF_TARGET_ESP32S3
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI2_BASE), 0, -1, -1, -1, -1 },
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI3_BASE), 1, -1, -1, -1, -1 }
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), 0, -1, -1, -1, -1}, {(volatile spi_dev_t *)(DR_REG_SPI3_BASE), 1, -1, -1, -1, -1}
|
||||
#elif CONFIG_IDF_TARGET_ESP32C2
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI2_BASE), 0, -1, -1, -1, -1 }
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), 0, -1, -1, -1, -1}
|
||||
#elif CONFIG_IDF_TARGET_ESP32C3
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI2_BASE), 0, -1, -1, -1, -1 }
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), 0, -1, -1, -1, -1}
|
||||
#elif CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
{ (spi_dev_t *)(DR_REG_SPI2_BASE), 0, -1, -1, -1, -1 }
|
||||
{(spi_dev_t *)(DR_REG_SPI2_BASE), 0, -1, -1, -1, -1}
|
||||
#else
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI0_BASE), 0, -1, -1, -1, -1 },
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI1_BASE), 1, -1, -1, -1, -1 },
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI2_BASE), 2, -1, -1, -1, -1 },
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI3_BASE), 3, -1, -1, -1, -1 }
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI0_BASE), 0, -1, -1, -1, -1},
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI1_BASE), 1, -1, -1, -1, -1},
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), 2, -1, -1, -1, -1},
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI3_BASE), 3, -1, -1, -1, -1}
|
||||
#endif
|
||||
};
|
||||
#else
|
||||
#define SPI_MUTEX_LOCK() \
|
||||
do { \
|
||||
do { \
|
||||
} while (xSemaphoreTake(spi->lock, portMAX_DELAY) != pdPASS)
|
||||
#define SPI_MUTEX_UNLOCK() xSemaphoreGive(spi->lock)
|
||||
|
||||
static spi_t _spi_bus_array[] = {
|
||||
#if CONFIG_IDF_TARGET_ESP32S2
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 0, -1, -1, -1, -1 },
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 1, -1, -1, -1, -1 },
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 2, -1, -1, -1, -1 }
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 0, -1, -1, -1, -1},
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 1, -1, -1, -1, -1},
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 2, -1, -1, -1, -1}
|
||||
#elif CONFIG_IDF_TARGET_ESP32S3
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 0, -1, -1, -1, -1 },
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 1, -1, -1, -1, -1 }
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 0, -1, -1, -1, -1}, {(volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 1, -1, -1, -1, -1}
|
||||
#elif CONFIG_IDF_TARGET_ESP32C2
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 0, -1, -1, -1, -1 }
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 0, -1, -1, -1, -1}
|
||||
#elif CONFIG_IDF_TARGET_ESP32C3
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 0, -1, -1, -1, -1 }
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 0, -1, -1, -1, -1}
|
||||
#elif CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
{ (spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 0, -1, -1, -1, -1 }
|
||||
{(spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 0, -1, -1, -1, -1}
|
||||
#else
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI0_BASE), NULL, 0, -1, -1, -1, -1 },
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 1, -1, -1, -1, -1 },
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 2, -1, -1, -1, -1 },
|
||||
{ (volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 3, -1, -1, -1, -1 }
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI0_BASE), NULL, 0, -1, -1, -1, -1},
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 1, -1, -1, -1, -1},
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 2, -1, -1, -1, -1},
|
||||
{(volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 3, -1, -1, -1, -1}
|
||||
#endif
|
||||
};
|
||||
#endif
|
||||
@ -371,7 +369,8 @@ void spiEnableSSPins(spi_t *spi, uint8_t ss_mask) {
|
||||
return;
|
||||
}
|
||||
SPI_MUTEX_LOCK();
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.val &= ~(ss_mask & SPI_SS_MASK_ALL);
|
||||
#else
|
||||
spi->dev->pin.val &= ~(ss_mask & SPI_SS_MASK_ALL);
|
||||
@ -384,7 +383,8 @@ void spiDisableSSPins(spi_t *spi, uint8_t ss_mask) {
|
||||
return;
|
||||
}
|
||||
SPI_MUTEX_LOCK();
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.val |= (ss_mask & SPI_SS_MASK_ALL);
|
||||
#else
|
||||
spi->dev->pin.val |= (ss_mask & SPI_SS_MASK_ALL);
|
||||
@ -417,7 +417,8 @@ void spiSSSet(spi_t *spi) {
|
||||
return;
|
||||
}
|
||||
SPI_MUTEX_LOCK();
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.cs_keep_active = 1;
|
||||
#else
|
||||
spi->dev->pin.cs_keep_active = 1;
|
||||
@ -430,7 +431,8 @@ void spiSSClear(spi_t *spi) {
|
||||
return;
|
||||
}
|
||||
SPI_MUTEX_LOCK();
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.cs_keep_active = 0;
|
||||
#else
|
||||
spi->dev->pin.cs_keep_active = 0;
|
||||
@ -458,7 +460,8 @@ uint8_t spiGetDataMode(spi_t *spi) {
|
||||
if (!spi) {
|
||||
return 0;
|
||||
}
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
bool idleEdge = spi->dev->misc.ck_idle_edge;
|
||||
#else
|
||||
bool idleEdge = spi->dev->pin.ck_idle_edge;
|
||||
@ -483,7 +486,8 @@ void spiSetDataMode(spi_t *spi, uint8_t dataMode) {
|
||||
SPI_MUTEX_LOCK();
|
||||
switch (dataMode) {
|
||||
case SPI_MODE1:
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.ck_idle_edge = 0;
|
||||
#else
|
||||
spi->dev->pin.ck_idle_edge = 0;
|
||||
@ -491,7 +495,8 @@ void spiSetDataMode(spi_t *spi, uint8_t dataMode) {
|
||||
spi->dev->user.ck_out_edge = 1;
|
||||
break;
|
||||
case SPI_MODE2:
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.ck_idle_edge = 1;
|
||||
#else
|
||||
spi->dev->pin.ck_idle_edge = 1;
|
||||
@ -499,7 +504,8 @@ void spiSetDataMode(spi_t *spi, uint8_t dataMode) {
|
||||
spi->dev->user.ck_out_edge = 1;
|
||||
break;
|
||||
case SPI_MODE3:
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.ck_idle_edge = 1;
|
||||
#else
|
||||
spi->dev->pin.ck_idle_edge = 1;
|
||||
@ -508,7 +514,8 @@ void spiSetDataMode(spi_t *spi, uint8_t dataMode) {
|
||||
break;
|
||||
case SPI_MODE0:
|
||||
default:
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.ck_idle_edge = 0;
|
||||
#else
|
||||
spi->dev->pin.ck_idle_edge = 0;
|
||||
@ -545,8 +552,7 @@ static void _on_apb_change(void *arg, apb_change_ev_t ev_type, uint32_t old_apb,
|
||||
spi_t *spi = (spi_t *)arg;
|
||||
if (ev_type == APB_BEFORE_CHANGE) {
|
||||
SPI_MUTEX_LOCK();
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
} else {
|
||||
spi->dev->clock.val = spiFrequencyToClockDiv(old_apb / ((spi->dev->clock.clkdiv_pre + 1) * (spi->dev->clock.clkcnt_n + 1)));
|
||||
SPI_MUTEX_UNLOCK();
|
||||
@ -558,7 +564,8 @@ static void spiInitBus(spi_t *spi) {
|
||||
spi->dev->slave.trans_done = 0;
|
||||
#endif
|
||||
spi->dev->slave.val = 0;
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.val = 0;
|
||||
#else
|
||||
spi->dev->pin.val = 0;
|
||||
@ -684,8 +691,7 @@ void spiWaitReady(spi_t *spi) {
|
||||
if (!spi) {
|
||||
return;
|
||||
}
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
}
|
||||
|
||||
#if CONFIG_IDF_TARGET_ESP32S2
|
||||
@ -694,8 +700,8 @@ void spiWaitReady(spi_t *spi) {
|
||||
#elif CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#define usr_mosi_dbitlen ms_data_bitlen
|
||||
#define usr_miso_dbitlen ms_data_bitlen
|
||||
#define mosi_dlen ms_dlen
|
||||
#define miso_dlen ms_dlen
|
||||
#define mosi_dlen ms_dlen
|
||||
#define miso_dlen ms_dlen
|
||||
#endif
|
||||
|
||||
void spiWrite(spi_t *spi, const uint32_t *data, uint8_t len) {
|
||||
@ -720,12 +726,10 @@ void spiWrite(spi_t *spi, const uint32_t *data, uint8_t len) {
|
||||
}
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
SPI_MUTEX_UNLOCK();
|
||||
}
|
||||
|
||||
@ -749,12 +753,10 @@ void spiTransfer(spi_t *spi, uint32_t *data, uint8_t len) {
|
||||
}
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
for (i = 0; i < len; i++) {
|
||||
#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
data[i] = spi->dev->data_buf[i].val;
|
||||
@ -782,12 +784,10 @@ void spiWriteByte(spi_t *spi, uint8_t data) {
|
||||
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
SPI_MUTEX_UNLOCK();
|
||||
}
|
||||
|
||||
@ -805,12 +805,10 @@ uint8_t spiTransferByte(spi_t *spi, uint8_t data) {
|
||||
#endif
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
data = spi->dev->data_buf[0].val & 0xFF;
|
||||
#else
|
||||
@ -848,12 +846,10 @@ void spiWriteWord(spi_t *spi, uint16_t data) {
|
||||
#endif
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
SPI_MUTEX_UNLOCK();
|
||||
}
|
||||
|
||||
@ -874,12 +870,10 @@ uint16_t spiTransferWord(spi_t *spi, uint16_t data) {
|
||||
#endif
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
data = spi->dev->data_buf[0].val;
|
||||
#else
|
||||
@ -911,12 +905,10 @@ void spiWriteLong(spi_t *spi, uint32_t data) {
|
||||
#endif
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
SPI_MUTEX_UNLOCK();
|
||||
}
|
||||
|
||||
@ -937,12 +929,10 @@ uint32_t spiTransferLong(spi_t *spi, uint32_t data) {
|
||||
#endif
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
data = spi->dev->data_buf[0].val;
|
||||
#else
|
||||
@ -985,19 +975,17 @@ static void __spiTransferBytes(spi_t *spi, const uint8_t *data, uint8_t *out, ui
|
||||
#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->data_buf[i].val = wordsBuf[i]; //copy buffer to spi fifo
|
||||
#else
|
||||
spi->dev->data_buf[i] = wordsBuf[i]; //copy buffer to spi fifo
|
||||
spi->dev->data_buf[i] = wordsBuf[i]; //copy buffer to spi fifo
|
||||
#endif
|
||||
}
|
||||
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
|
||||
if (out) {
|
||||
for (i = 0; i < words; i++) {
|
||||
@ -1047,21 +1035,21 @@ void spiTransferBits(spi_t *spi, uint32_t data, uint32_t *out, uint8_t bits) {
|
||||
* Manual Lock Management
|
||||
* */
|
||||
|
||||
#define MSB_32_SET(var, val) \
|
||||
{ \
|
||||
uint8_t *d = (uint8_t *)&(val); \
|
||||
#define MSB_32_SET(var, val) \
|
||||
{ \
|
||||
uint8_t *d = (uint8_t *)&(val); \
|
||||
(var) = d[3] | (d[2] << 8) | (d[1] << 16) | (d[0] << 24); \
|
||||
}
|
||||
#define MSB_24_SET(var, val) \
|
||||
{ \
|
||||
uint8_t *d = (uint8_t *)&(val); \
|
||||
#define MSB_24_SET(var, val) \
|
||||
{ \
|
||||
uint8_t *d = (uint8_t *)&(val); \
|
||||
(var) = d[2] | (d[1] << 8) | (d[0] << 16); \
|
||||
}
|
||||
#define MSB_16_SET(var, val) \
|
||||
{ (var) = (((val)&0xFF00) >> 8) | (((val)&0xFF) << 8); }
|
||||
#define MSB_PIX_SET(var, val) \
|
||||
{ \
|
||||
uint8_t *d = (uint8_t *)&(val); \
|
||||
{ (var) = (((val) & 0xFF00) >> 8) | (((val) & 0xFF) << 8); }
|
||||
#define MSB_PIX_SET(var, val) \
|
||||
{ \
|
||||
uint8_t *d = (uint8_t *)&(val); \
|
||||
(var) = d[1] | (d[0] << 8) | (d[3] << 16) | (d[2] << 24); \
|
||||
}
|
||||
|
||||
@ -1073,7 +1061,8 @@ void spiTransaction(spi_t *spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bit
|
||||
spi->dev->clock.val = clockDiv;
|
||||
switch (dataMode) {
|
||||
case SPI_MODE1:
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.ck_idle_edge = 0;
|
||||
#else
|
||||
spi->dev->pin.ck_idle_edge = 0;
|
||||
@ -1081,7 +1070,8 @@ void spiTransaction(spi_t *spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bit
|
||||
spi->dev->user.ck_out_edge = 1;
|
||||
break;
|
||||
case SPI_MODE2:
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.ck_idle_edge = 1;
|
||||
#else
|
||||
spi->dev->pin.ck_idle_edge = 1;
|
||||
@ -1089,7 +1079,8 @@ void spiTransaction(spi_t *spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bit
|
||||
spi->dev->user.ck_out_edge = 1;
|
||||
break;
|
||||
case SPI_MODE3:
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.ck_idle_edge = 1;
|
||||
#else
|
||||
spi->dev->pin.ck_idle_edge = 1;
|
||||
@ -1098,7 +1089,8 @@ void spiTransaction(spi_t *spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bit
|
||||
break;
|
||||
case SPI_MODE0:
|
||||
default:
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 \
|
||||
|| CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->misc.ck_idle_edge = 0;
|
||||
#else
|
||||
spi->dev->pin.ck_idle_edge = 0;
|
||||
@ -1116,8 +1108,7 @@ void spiTransaction(spi_t *spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bit
|
||||
#if CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
// Sync new config with hardware, fixes https://github.com/espressif/arduino-esp32/issues/9221
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -1150,12 +1141,10 @@ void ARDUINO_ISR_ATTR spiWriteByteNL(spi_t *spi, uint8_t data) {
|
||||
#endif
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
}
|
||||
|
||||
uint8_t spiTransferByteNL(spi_t *spi, uint8_t data) {
|
||||
@ -1171,12 +1160,10 @@ uint8_t spiTransferByteNL(spi_t *spi, uint8_t data) {
|
||||
#endif
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
data = spi->dev->data_buf[0].val & 0xFF;
|
||||
#else
|
||||
@ -1203,12 +1190,10 @@ void ARDUINO_ISR_ATTR spiWriteShortNL(spi_t *spi, uint16_t data) {
|
||||
#endif
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
}
|
||||
|
||||
uint16_t spiTransferShortNL(spi_t *spi, uint16_t data) {
|
||||
@ -1227,12 +1212,10 @@ uint16_t spiTransferShortNL(spi_t *spi, uint16_t data) {
|
||||
#endif
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
data = spi->dev->data_buf[0].val & 0xFFFF;
|
||||
#else
|
||||
@ -1262,12 +1245,10 @@ void ARDUINO_ISR_ATTR spiWriteLongNL(spi_t *spi, uint32_t data) {
|
||||
#endif
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
}
|
||||
|
||||
uint32_t spiTransferLongNL(spi_t *spi, uint32_t data) {
|
||||
@ -1286,12 +1267,10 @@ uint32_t spiTransferLongNL(spi_t *spi, uint32_t data) {
|
||||
#endif
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
data = spi->dev->data_buf[0].val;
|
||||
#else
|
||||
@ -1331,12 +1310,10 @@ void spiWriteNL(spi_t *spi, const void *data_in, uint32_t len) {
|
||||
}
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
|
||||
data += c_longs;
|
||||
longs -= c_longs;
|
||||
@ -1381,12 +1358,10 @@ void spiTransferBytesNL(spi_t *spi, const void *data_in, uint8_t *data_out, uint
|
||||
}
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
if (result) {
|
||||
if (c_len & 3) {
|
||||
for (size_t i = 0; i < (c_longs - 1); i++) {
|
||||
@ -1457,12 +1432,10 @@ void spiTransferBitsNL(spi_t *spi, uint32_t data, uint32_t *out, uint8_t bits) {
|
||||
#endif
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
data = spi->dev->data_buf[0].val;
|
||||
#else
|
||||
@ -1533,12 +1506,10 @@ void ARDUINO_ISR_ATTR spiWritePixelsNL(spi_t *spi, const void *data_in, uint32_t
|
||||
}
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
spi->dev->cmd.update = 1;
|
||||
while (spi->dev->cmd.update)
|
||||
;
|
||||
while (spi->dev->cmd.update);
|
||||
#endif
|
||||
spi->dev->cmd.usr = 1;
|
||||
while (spi->dev->cmd.usr)
|
||||
;
|
||||
while (spi->dev->cmd.usr);
|
||||
|
||||
data += c_longs;
|
||||
longs -= c_longs;
|
||||
@ -1546,8 +1517,6 @@ void ARDUINO_ISR_ATTR spiWritePixelsNL(spi_t *spi, const void *data_in, uint32_t
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Clock Calculators
|
||||
*
|
||||
@ -1561,7 +1530,7 @@ typedef union {
|
||||
uint32_t clkcnt_n : 6; /*it is the divider of spi_clk. So spi_clk frequency is system/(spi_clkdiv_pre+1)/(spi_clkcnt_N+1)*/
|
||||
#if CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
uint32_t clkdiv_pre : 4; /*it is pre-divider of spi_clk.*/
|
||||
uint32_t reserved : 9; /*reserved*/
|
||||
uint32_t reserved : 9; /*reserved*/
|
||||
#else
|
||||
uint32_t clkdiv_pre : 13; /*it is pre-divider of spi_clk.*/
|
||||
#endif
|
||||
@ -1573,7 +1542,7 @@ typedef union {
|
||||
|
||||
uint32_t spiClockDivToFrequency(uint32_t clockDiv) {
|
||||
uint32_t apb_freq = getApbFrequency();
|
||||
spiClk_t reg = { clockDiv };
|
||||
spiClk_t reg = {clockDiv};
|
||||
return ClkRegToFreq(®);
|
||||
}
|
||||
|
||||
@ -1584,18 +1553,18 @@ uint32_t spiFrequencyToClockDiv(uint32_t freq) {
|
||||
return SPI_CLK_EQU_SYSCLK;
|
||||
}
|
||||
|
||||
const spiClk_t minFreqReg = { 0x7FFFF000 };
|
||||
const spiClk_t minFreqReg = {0x7FFFF000};
|
||||
uint32_t minFreq = ClkRegToFreq((spiClk_t *)&minFreqReg);
|
||||
if (freq < minFreq) {
|
||||
return minFreqReg.value;
|
||||
}
|
||||
|
||||
uint8_t calN = 1;
|
||||
spiClk_t bestReg = { 0 };
|
||||
spiClk_t bestReg = {0};
|
||||
uint32_t bestFreq = 0;
|
||||
|
||||
while (calN <= 0x3F) {
|
||||
spiClk_t reg = { 0 };
|
||||
spiClk_t reg = {0};
|
||||
uint32_t calFreq;
|
||||
int32_t calPre;
|
||||
int8_t calPreVari = -2;
|
||||
|
@ -44,12 +44,12 @@ extern "C" {
|
||||
|
||||
// This defines are not representing the real Divider of the ESP32
|
||||
// the Defines match to an AVR Arduino on 16MHz for better compatibility
|
||||
#define SPI_CLOCK_DIV2 0x00101001 //8 MHz
|
||||
#define SPI_CLOCK_DIV4 0x00241001 //4 MHz
|
||||
#define SPI_CLOCK_DIV8 0x004c1001 //2 MHz
|
||||
#define SPI_CLOCK_DIV16 0x009c1001 //1 MHz
|
||||
#define SPI_CLOCK_DIV32 0x013c1001 //500 KHz
|
||||
#define SPI_CLOCK_DIV64 0x027c1001 //250 KHz
|
||||
#define SPI_CLOCK_DIV2 0x00101001 //8 MHz
|
||||
#define SPI_CLOCK_DIV4 0x00241001 //4 MHz
|
||||
#define SPI_CLOCK_DIV8 0x004c1001 //2 MHz
|
||||
#define SPI_CLOCK_DIV16 0x009c1001 //1 MHz
|
||||
#define SPI_CLOCK_DIV32 0x013c1001 //500 KHz
|
||||
#define SPI_CLOCK_DIV64 0x027c1001 //250 KHz
|
||||
#define SPI_CLOCK_DIV128 0x04fc1001 //125 KHz
|
||||
|
||||
#define SPI_MODE0 0
|
||||
@ -57,96 +57,95 @@ extern "C" {
|
||||
#define SPI_MODE2 2
|
||||
#define SPI_MODE3 3
|
||||
|
||||
#define SPI_SS0 0
|
||||
#define SPI_SS1 1
|
||||
#define SPI_SS2 2
|
||||
#define SPI_SS0 0
|
||||
#define SPI_SS1 1
|
||||
#define SPI_SS2 2
|
||||
#define SPI_SS_MASK_ALL 0x7
|
||||
|
||||
#define SPI_LSBFIRST 0
|
||||
#define SPI_MSBFIRST 1
|
||||
|
||||
struct spi_struct_t;
|
||||
typedef struct spi_struct_t spi_t;
|
||||
struct spi_struct_t;
|
||||
typedef struct spi_struct_t spi_t;
|
||||
|
||||
spi_t *spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder);
|
||||
void spiStopBus(spi_t *spi);
|
||||
spi_t *spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder);
|
||||
void spiStopBus(spi_t *spi);
|
||||
|
||||
//Attach/Detach Signal Pins
|
||||
bool spiAttachSCK(spi_t *spi, int8_t sck);
|
||||
bool spiAttachMISO(spi_t *spi, int8_t miso);
|
||||
bool spiAttachMOSI(spi_t *spi, int8_t mosi);
|
||||
bool spiDetachSCK(spi_t *spi);
|
||||
bool spiDetachMISO(spi_t *spi);
|
||||
bool spiDetachMOSI(spi_t *spi);
|
||||
//Attach/Detach Signal Pins
|
||||
bool spiAttachSCK(spi_t *spi, int8_t sck);
|
||||
bool spiAttachMISO(spi_t *spi, int8_t miso);
|
||||
bool spiAttachMOSI(spi_t *spi, int8_t mosi);
|
||||
bool spiDetachSCK(spi_t *spi);
|
||||
bool spiDetachMISO(spi_t *spi);
|
||||
bool spiDetachMOSI(spi_t *spi);
|
||||
|
||||
//Attach/Detach SS pin to SPI_SSx signal
|
||||
bool spiAttachSS(spi_t *spi, uint8_t ss_num, int8_t ss);
|
||||
bool spiDetachSS(spi_t *spi);
|
||||
//Attach/Detach SS pin to SPI_SSx signal
|
||||
bool spiAttachSS(spi_t *spi, uint8_t ss_num, int8_t ss);
|
||||
bool spiDetachSS(spi_t *spi);
|
||||
|
||||
//Enable/Disable SPI_SSx pins
|
||||
void spiEnableSSPins(spi_t *spi, uint8_t ss_mask);
|
||||
void spiDisableSSPins(spi_t *spi, uint8_t ss_mask);
|
||||
//Enable/Disable SPI_SSx pins
|
||||
void spiEnableSSPins(spi_t *spi, uint8_t ss_mask);
|
||||
void spiDisableSSPins(spi_t *spi, uint8_t ss_mask);
|
||||
|
||||
//Enable/Disable hardware control of SPI_SSx pins
|
||||
void spiSSEnable(spi_t *spi);
|
||||
void spiSSDisable(spi_t *spi);
|
||||
//Enable/Disable hardware control of SPI_SSx pins
|
||||
void spiSSEnable(spi_t *spi);
|
||||
void spiSSDisable(spi_t *spi);
|
||||
|
||||
//Activate enabled SPI_SSx pins
|
||||
void spiSSSet(spi_t *spi);
|
||||
//Deactivate enabled SPI_SSx pins
|
||||
void spiSSClear(spi_t *spi);
|
||||
//Activate enabled SPI_SSx pins
|
||||
void spiSSSet(spi_t *spi);
|
||||
//Deactivate enabled SPI_SSx pins
|
||||
void spiSSClear(spi_t *spi);
|
||||
|
||||
void spiWaitReady(spi_t *spi);
|
||||
void spiWaitReady(spi_t *spi);
|
||||
|
||||
uint32_t spiGetClockDiv(spi_t *spi);
|
||||
uint8_t spiGetDataMode(spi_t *spi);
|
||||
uint8_t spiGetBitOrder(spi_t *spi);
|
||||
uint32_t spiGetClockDiv(spi_t *spi);
|
||||
uint8_t spiGetDataMode(spi_t *spi);
|
||||
uint8_t spiGetBitOrder(spi_t *spi);
|
||||
|
||||
|
||||
/*
|
||||
/*
|
||||
* Non transaction based lock methods (each locks and unlocks when called)
|
||||
* */
|
||||
void spiSetClockDiv(spi_t *spi, uint32_t clockDiv);
|
||||
void spiSetDataMode(spi_t *spi, uint8_t dataMode);
|
||||
void spiSetBitOrder(spi_t *spi, uint8_t bitOrder);
|
||||
void spiSetClockDiv(spi_t *spi, uint32_t clockDiv);
|
||||
void spiSetDataMode(spi_t *spi, uint8_t dataMode);
|
||||
void spiSetBitOrder(spi_t *spi, uint8_t bitOrder);
|
||||
|
||||
void spiWrite(spi_t *spi, const uint32_t *data, uint8_t len);
|
||||
void spiWriteByte(spi_t *spi, uint8_t data);
|
||||
void spiWriteWord(spi_t *spi, uint16_t data);
|
||||
void spiWriteLong(spi_t *spi, uint32_t data);
|
||||
void spiWrite(spi_t *spi, const uint32_t *data, uint8_t len);
|
||||
void spiWriteByte(spi_t *spi, uint8_t data);
|
||||
void spiWriteWord(spi_t *spi, uint16_t data);
|
||||
void spiWriteLong(spi_t *spi, uint32_t data);
|
||||
|
||||
void spiTransfer(spi_t *spi, uint32_t *out, uint8_t len);
|
||||
uint8_t spiTransferByte(spi_t *spi, uint8_t data);
|
||||
uint16_t spiTransferWord(spi_t *spi, uint16_t data);
|
||||
uint32_t spiTransferLong(spi_t *spi, uint32_t data);
|
||||
void spiTransferBytes(spi_t *spi, const uint8_t *data, uint8_t *out, uint32_t size);
|
||||
void spiTransferBits(spi_t *spi, uint32_t data, uint32_t *out, uint8_t bits);
|
||||
void spiTransfer(spi_t *spi, uint32_t *out, uint8_t len);
|
||||
uint8_t spiTransferByte(spi_t *spi, uint8_t data);
|
||||
uint16_t spiTransferWord(spi_t *spi, uint16_t data);
|
||||
uint32_t spiTransferLong(spi_t *spi, uint32_t data);
|
||||
void spiTransferBytes(spi_t *spi, const uint8_t *data, uint8_t *out, uint32_t size);
|
||||
void spiTransferBits(spi_t *spi, uint32_t data, uint32_t *out, uint8_t bits);
|
||||
|
||||
/*
|
||||
/*
|
||||
* New (EXPERIMENTAL) Transaction lock based API (lock once until endTransaction)
|
||||
* */
|
||||
void spiTransaction(spi_t *spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder);
|
||||
void spiSimpleTransaction(spi_t *spi);
|
||||
void spiEndTransaction(spi_t *spi);
|
||||
void spiTransaction(spi_t *spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder);
|
||||
void spiSimpleTransaction(spi_t *spi);
|
||||
void spiEndTransaction(spi_t *spi);
|
||||
|
||||
void spiWriteNL(spi_t *spi, const void *data_in, uint32_t len);
|
||||
void spiWriteByteNL(spi_t *spi, uint8_t data);
|
||||
void spiWriteShortNL(spi_t *spi, uint16_t data);
|
||||
void spiWriteLongNL(spi_t *spi, uint32_t data);
|
||||
void spiWritePixelsNL(spi_t *spi, const void *data_in, uint32_t len);
|
||||
void spiWriteNL(spi_t *spi, const void *data_in, uint32_t len);
|
||||
void spiWriteByteNL(spi_t *spi, uint8_t data);
|
||||
void spiWriteShortNL(spi_t *spi, uint16_t data);
|
||||
void spiWriteLongNL(spi_t *spi, uint32_t data);
|
||||
void spiWritePixelsNL(spi_t *spi, const void *data_in, uint32_t len);
|
||||
|
||||
#define spiTransferNL(spi, data, len) spiTransferBytesNL(spi, data, data, len)
|
||||
uint8_t spiTransferByteNL(spi_t *spi, uint8_t data);
|
||||
uint16_t spiTransferShortNL(spi_t *spi, uint16_t data);
|
||||
uint32_t spiTransferLongNL(spi_t *spi, uint32_t data);
|
||||
void spiTransferBytesNL(spi_t *spi, const void *data_in, uint8_t *data_out, uint32_t len);
|
||||
void spiTransferBitsNL(spi_t *spi, uint32_t data_in, uint32_t *data_out, uint8_t bits);
|
||||
uint8_t spiTransferByteNL(spi_t *spi, uint8_t data);
|
||||
uint16_t spiTransferShortNL(spi_t *spi, uint16_t data);
|
||||
uint32_t spiTransferLongNL(spi_t *spi, uint32_t data);
|
||||
void spiTransferBytesNL(spi_t *spi, const void *data_in, uint8_t *data_out, uint32_t len);
|
||||
void spiTransferBitsNL(spi_t *spi, uint32_t data_in, uint32_t *data_out, uint8_t bits);
|
||||
|
||||
/*
|
||||
/*
|
||||
* Helper functions to translate frequency to clock divider and back
|
||||
* */
|
||||
uint32_t spiFrequencyToClockDiv(uint32_t freq);
|
||||
uint32_t spiClockDivToFrequency(uint32_t freq);
|
||||
uint32_t spiFrequencyToClockDiv(uint32_t freq);
|
||||
uint32_t spiClockDivToFrequency(uint32_t freq);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -18,9 +18,9 @@
|
||||
#include "esp_netif.h"
|
||||
|
||||
static void setTimeZone(long offset, int daylight) {
|
||||
char cst[17] = { 0 };
|
||||
char cst[17] = {0};
|
||||
char cdt[17] = "DST";
|
||||
char tz[33] = { 0 };
|
||||
char tz[33] = {0};
|
||||
|
||||
if (offset % 3600) {
|
||||
sprintf(cst, "UTC%ld:%02u:%02u", offset / 3600, abs((offset % 3600) / 60), abs(offset % 60));
|
||||
@ -44,16 +44,16 @@ static void setTimeZone(long offset, int daylight) {
|
||||
* configTime
|
||||
* Source: https://github.com/esp8266/Arduino/blob/master/cores/esp8266/time.c
|
||||
* */
|
||||
void configTime(long gmtOffset_sec, int daylightOffset_sec, const char* server1, const char* server2, const char* server3) {
|
||||
void configTime(long gmtOffset_sec, int daylightOffset_sec, const char *server1, const char *server2, const char *server3) {
|
||||
//tcpip_adapter_init(); // Should not hurt anything if already inited
|
||||
esp_netif_init();
|
||||
if (sntp_enabled()) {
|
||||
sntp_stop();
|
||||
}
|
||||
sntp_setoperatingmode(SNTP_OPMODE_POLL);
|
||||
sntp_setservername(0, (char*)server1);
|
||||
sntp_setservername(1, (char*)server2);
|
||||
sntp_setservername(2, (char*)server3);
|
||||
sntp_setservername(0, (char *)server1);
|
||||
sntp_setservername(1, (char *)server2);
|
||||
sntp_setservername(2, (char *)server3);
|
||||
sntp_init();
|
||||
setTimeZone(-gmtOffset_sec, daylightOffset_sec);
|
||||
}
|
||||
@ -62,22 +62,22 @@ void configTime(long gmtOffset_sec, int daylightOffset_sec, const char* server1,
|
||||
* configTzTime
|
||||
* sntp setup using TZ environment variable
|
||||
* */
|
||||
void configTzTime(const char* tz, const char* server1, const char* server2, const char* server3) {
|
||||
void configTzTime(const char *tz, const char *server1, const char *server2, const char *server3) {
|
||||
//tcpip_adapter_init(); // Should not hurt anything if already inited
|
||||
esp_netif_init();
|
||||
if (sntp_enabled()) {
|
||||
sntp_stop();
|
||||
}
|
||||
sntp_setoperatingmode(SNTP_OPMODE_POLL);
|
||||
sntp_setservername(0, (char*)server1);
|
||||
sntp_setservername(1, (char*)server2);
|
||||
sntp_setservername(2, (char*)server3);
|
||||
sntp_setservername(0, (char *)server1);
|
||||
sntp_setservername(1, (char *)server2);
|
||||
sntp_setservername(2, (char *)server3);
|
||||
sntp_init();
|
||||
setenv("TZ", tz, 1);
|
||||
tzset();
|
||||
}
|
||||
|
||||
bool getLocalTime(struct tm* info, uint32_t ms) {
|
||||
bool getLocalTime(struct tm *info, uint32_t ms) {
|
||||
uint32_t start = millis();
|
||||
time_t now;
|
||||
while ((millis() - start) <= ms) {
|
||||
|
@ -97,7 +97,9 @@ hw_timer_t *timerBegin(uint32_t frequency) {
|
||||
divider = counter_src_hz / frequency;
|
||||
if ((divider >= 2) && (divider <= 65536)) {
|
||||
break;
|
||||
} else divider = 0;
|
||||
} else {
|
||||
divider = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (divider == 0) {
|
||||
|
@ -29,29 +29,29 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct timer_struct_t;
|
||||
typedef struct timer_struct_t hw_timer_t;
|
||||
struct timer_struct_t;
|
||||
typedef struct timer_struct_t hw_timer_t;
|
||||
|
||||
hw_timer_t* timerBegin(uint32_t frequency);
|
||||
void timerEnd(hw_timer_t* timer);
|
||||
hw_timer_t *timerBegin(uint32_t frequency);
|
||||
void timerEnd(hw_timer_t *timer);
|
||||
|
||||
void timerStart(hw_timer_t* timer);
|
||||
void timerStop(hw_timer_t* timer);
|
||||
void timerRestart(hw_timer_t* timer);
|
||||
void timerWrite(hw_timer_t* timer, uint64_t val);
|
||||
void timerStart(hw_timer_t *timer);
|
||||
void timerStop(hw_timer_t *timer);
|
||||
void timerRestart(hw_timer_t *timer);
|
||||
void timerWrite(hw_timer_t *timer, uint64_t val);
|
||||
|
||||
uint64_t timerRead(hw_timer_t* timer);
|
||||
uint64_t timerReadMicros(hw_timer_t* timer);
|
||||
uint64_t timerReadMilis(hw_timer_t* timer);
|
||||
double timerReadSeconds(hw_timer_t* timer);
|
||||
uint64_t timerRead(hw_timer_t *timer);
|
||||
uint64_t timerReadMicros(hw_timer_t *timer);
|
||||
uint64_t timerReadMilis(hw_timer_t *timer);
|
||||
double timerReadSeconds(hw_timer_t *timer);
|
||||
|
||||
uint32_t timerGetFrequency(hw_timer_t* timer);
|
||||
uint32_t timerGetFrequency(hw_timer_t *timer);
|
||||
|
||||
void timerAttachInterrupt(hw_timer_t* timer, void (*userFunc)(void));
|
||||
void timerAttachInterruptArg(hw_timer_t* timer, void (*userFunc)(void*), void* arg);
|
||||
void timerDetachInterrupt(hw_timer_t* timer);
|
||||
void timerAttachInterrupt(hw_timer_t *timer, void (*userFunc)(void));
|
||||
void timerAttachInterruptArg(hw_timer_t *timer, void (*userFunc)(void *), void *arg);
|
||||
void timerDetachInterrupt(hw_timer_t *timer);
|
||||
|
||||
void timerAlarm(hw_timer_t* timer, uint64_t alarm_value, bool autoreload, uint64_t reload_count);
|
||||
void timerAlarm(hw_timer_t *timer, uint64_t alarm_value, bool autoreload, uint64_t reload_count);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -102,9 +102,7 @@ static void configure_pins(usb_hal_context_t *usb) {
|
||||
}
|
||||
|
||||
esp_err_t tinyusb_driver_install(const tinyusb_config_t *config) {
|
||||
usb_hal_context_t hal = {
|
||||
.use_external_phy = config->external_phy
|
||||
};
|
||||
usb_hal_context_t hal = {.use_external_phy = config->external_phy};
|
||||
usb_hal_init(&hal);
|
||||
configure_pins(&hal);
|
||||
if (!tusb_init()) {
|
||||
@ -114,15 +112,6 @@ esp_err_t tinyusb_driver_install(const tinyusb_config_t *config) {
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
typedef char tusb_str_t[127];
|
||||
|
||||
static bool WEBUSB_ENABLED = false;
|
||||
@ -172,7 +161,6 @@ static char *tinyusb_string_descriptor[MAX_STRING_DESCRIPTORS] = {
|
||||
USB_DEVICE_SERIAL, // 3: Serials, should use chip ID
|
||||
};
|
||||
|
||||
|
||||
/* Microsoft OS 2.0 registry property descriptor
|
||||
Per MS requirements https://msdn.microsoft.com/en-us/library/windows/hardware/hh450799(v=vs.85).aspx
|
||||
device should create DeviceInterfaceGUIDs. It can be done by driver and
|
||||
@ -200,25 +188,23 @@ static uint8_t const tinyusb_ms_os_20_descriptor[] = {
|
||||
U16_TO_U8S_LE(0x0008), U16_TO_U8S_LE(MS_OS_20_SUBSET_HEADER_FUNCTION), 0, 0, U16_TO_U8S_LE(MS_OS_20_DESC_LEN - 0x0A - 0x08),
|
||||
|
||||
// MS OS 2.0 Compatible ID descriptor: length, type, compatible ID, sub compatible ID
|
||||
U16_TO_U8S_LE(0x0014), U16_TO_U8S_LE(MS_OS_20_FEATURE_COMPATBLE_ID), 'W', 'I', 'N', 'U', 'S', 'B', 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // sub-compatible
|
||||
U16_TO_U8S_LE(0x0014), U16_TO_U8S_LE(MS_OS_20_FEATURE_COMPATBLE_ID), 'W', 'I', 'N', 'U', 'S', 'B', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, // sub-compatible
|
||||
|
||||
// MS OS 2.0 Registry property descriptor: length, type
|
||||
U16_TO_U8S_LE(MS_OS_20_DESC_LEN - 0x0A - 0x08 - 0x08 - 0x14), U16_TO_U8S_LE(MS_OS_20_FEATURE_REG_PROPERTY),
|
||||
U16_TO_U8S_LE(0x0007), U16_TO_U8S_LE(0x002A), // wPropertyDataType, wPropertyNameLength and PropertyName "DeviceInterfaceGUIDs\0" in UTF-16
|
||||
'D', 0x00, 'e', 0x00, 'v', 0x00, 'i', 0x00, 'c', 0x00, 'e', 0x00, 'I', 0x00, 'n', 0x00, 't', 0x00, 'e', 0x00,
|
||||
'r', 0x00, 'f', 0x00, 'a', 0x00, 'c', 0x00, 'e', 0x00, 'G', 0x00, 'U', 0x00, 'I', 0x00, 'D', 0x00, 's', 0x00, 0x00, 0x00,
|
||||
U16_TO_U8S_LE(MS_OS_20_DESC_LEN - 0x0A - 0x08 - 0x08 - 0x14), U16_TO_U8S_LE(MS_OS_20_FEATURE_REG_PROPERTY), U16_TO_U8S_LE(0x0007),
|
||||
U16_TO_U8S_LE(0x002A), // wPropertyDataType, wPropertyNameLength and PropertyName "DeviceInterfaceGUIDs\0" in UTF-16
|
||||
'D', 0x00, 'e', 0x00, 'v', 0x00, 'i', 0x00, 'c', 0x00, 'e', 0x00, 'I', 0x00, 'n', 0x00, 't', 0x00, 'e', 0x00, 'r', 0x00, 'f', 0x00, 'a', 0x00, 'c', 0x00, 'e',
|
||||
0x00, 'G', 0x00, 'U', 0x00, 'I', 0x00, 'D', 0x00, 's', 0x00, 0x00, 0x00,
|
||||
U16_TO_U8S_LE(0x0050), // wPropertyDataLength
|
||||
//bPropertyData: “{975F44D9-0D08-43FD-8B3E-127CA8AFFF9D}”.
|
||||
'{', 0x00, '9', 0x00, '7', 0x00, '5', 0x00, 'F', 0x00, '4', 0x00, '4', 0x00, 'D', 0x00, '9', 0x00, '-', 0x00,
|
||||
'0', 0x00, 'D', 0x00, '0', 0x00, '8', 0x00, '-', 0x00, '4', 0x00, '3', 0x00, 'F', 0x00, 'D', 0x00, '-', 0x00,
|
||||
'8', 0x00, 'B', 0x00, '3', 0x00, 'E', 0x00, '-', 0x00, '1', 0x00, '2', 0x00, '7', 0x00, 'C', 0x00, 'A', 0x00,
|
||||
'8', 0x00, 'A', 0x00, 'F', 0x00, 'F', 0x00, 'F', 0x00, '9', 0x00, 'D', 0x00, '}', 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
'{', 0x00, '9', 0x00, '7', 0x00, '5', 0x00, 'F', 0x00, '4', 0x00, '4', 0x00, 'D', 0x00, '9', 0x00, '-', 0x00, '0', 0x00, 'D', 0x00, '0', 0x00, '8', 0x00, '-',
|
||||
0x00, '4', 0x00, '3', 0x00, 'F', 0x00, 'D', 0x00, '-', 0x00, '8', 0x00, 'B', 0x00, '3', 0x00, 'E', 0x00, '-', 0x00, '1', 0x00, '2', 0x00, '7', 0x00, 'C',
|
||||
0x00, 'A', 0x00, '8', 0x00, 'A', 0x00, 'F', 0x00, 'F', 0x00, 'F', 0x00, '9', 0x00, 'D', 0x00, '}', 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
|
||||
TU_VERIFY_STATIC(sizeof(tinyusb_ms_os_20_descriptor) == MS_OS_20_DESC_LEN, "Incorrect size");
|
||||
|
||||
|
||||
/*
|
||||
* BOS Descriptor (required for webUSB)
|
||||
* */
|
||||
@ -272,7 +258,7 @@ static uint8_t *tinyusb_config_descriptor = NULL;
|
||||
* */
|
||||
typedef union {
|
||||
struct {
|
||||
uint32_t in : 16;
|
||||
uint32_t in : 16;
|
||||
uint32_t out : 16;
|
||||
};
|
||||
uint32_t val;
|
||||
@ -280,7 +266,6 @@ typedef union {
|
||||
|
||||
static tinyusb_endpoints_usage_t tinyusb_endpoints;
|
||||
|
||||
|
||||
/*
|
||||
* TinyUSB Callbacks
|
||||
* */
|
||||
@ -407,7 +392,6 @@ __attribute__((weak)) int32_t tud_msc_scsi_cb(uint8_t lun, uint8_t const scsi_cm
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Private API
|
||||
* */
|
||||
@ -651,10 +635,7 @@ static void tinyusb_apply_device_config(tinyusb_device_config_t *config) {
|
||||
}
|
||||
|
||||
// Windows 10 will not recognize the CDC device if WebUSB is enabled and USB Class is not 2 (CDC)
|
||||
if (
|
||||
(tinyusb_loaded_interfaces_mask & BIT(USB_INTERFACE_CDC))
|
||||
&& config->webusb_enabled
|
||||
&& (config->usb_class != TUSB_CLASS_CDC)) {
|
||||
if ((tinyusb_loaded_interfaces_mask & BIT(USB_INTERFACE_CDC)) && config->webusb_enabled && (config->usb_class != TUSB_CLASS_CDC)) {
|
||||
config->usb_class = TUSB_CLASS_CDC;
|
||||
config->usb_protocol = 0x00;
|
||||
}
|
||||
@ -676,14 +657,16 @@ static void tinyusb_apply_device_config(tinyusb_device_config_t *config) {
|
||||
// This top level thread processes all usb events and invokes callbacks
|
||||
static void usb_device_task(void *param) {
|
||||
(void)param;
|
||||
while (1) tud_task(); // RTOS forever loop
|
||||
while (1) {
|
||||
tud_task(); // RTOS forever loop
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* PUBLIC API
|
||||
* */
|
||||
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_ERROR
|
||||
const char *tinyusb_interface_names[USB_INTERFACE_MAX] = { "MSC", "DFU", "HID", "VENDOR", "CDC", "MIDI", "CUSTOM" };
|
||||
const char *tinyusb_interface_names[USB_INTERFACE_MAX] = {"MSC", "DFU", "HID", "VENDOR", "CDC", "MIDI", "CUSTOM"};
|
||||
#endif
|
||||
static bool tinyusb_is_initialized = false;
|
||||
|
||||
|
@ -28,81 +28,71 @@ extern "C" {
|
||||
#include "tusb_option.h"
|
||||
#include "tusb_config.h"
|
||||
|
||||
#define USB_ESPRESSIF_VID 0x303A
|
||||
#define USB_ESPRESSIF_VID 0x303A
|
||||
#define USB_STRING_DESCRIPTOR_ARRAY_SIZE 10
|
||||
|
||||
typedef struct {
|
||||
uint16_t vid;
|
||||
uint16_t pid;
|
||||
const char *product_name;
|
||||
const char *manufacturer_name;
|
||||
const char *serial_number;
|
||||
uint16_t fw_version;
|
||||
typedef struct {
|
||||
uint16_t vid;
|
||||
uint16_t pid;
|
||||
const char *product_name;
|
||||
const char *manufacturer_name;
|
||||
const char *serial_number;
|
||||
uint16_t fw_version;
|
||||
|
||||
uint16_t usb_version;
|
||||
uint8_t usb_class;
|
||||
uint8_t usb_subclass;
|
||||
uint8_t usb_protocol;
|
||||
uint8_t usb_attributes;
|
||||
uint16_t usb_power_ma;
|
||||
uint16_t usb_version;
|
||||
uint8_t usb_class;
|
||||
uint8_t usb_subclass;
|
||||
uint8_t usb_protocol;
|
||||
uint8_t usb_attributes;
|
||||
uint16_t usb_power_ma;
|
||||
|
||||
bool webusb_enabled;
|
||||
const char *webusb_url;
|
||||
} tinyusb_device_config_t;
|
||||
bool webusb_enabled;
|
||||
const char *webusb_url;
|
||||
} tinyusb_device_config_t;
|
||||
|
||||
#define TINYUSB_CONFIG_DEFAULT() \
|
||||
{ \
|
||||
.vid = USB_ESPRESSIF_VID, \
|
||||
.pid = 0x0002, \
|
||||
.product_name = CONFIG_TINYUSB_DESC_PRODUCT_STRING, \
|
||||
.manufacturer_name = CONFIG_TINYUSB_DESC_MANUFACTURER_STRING, \
|
||||
.serial_number = CONFIG_TINYUSB_DESC_SERIAL_STRING, \
|
||||
.fw_version = CONFIG_TINYUSB_DESC_BCDDEVICE, \
|
||||
.usb_version = 0x0200, \
|
||||
.usb_class = TUSB_CLASS_MISC, \
|
||||
.usb_subclass = MISC_SUBCLASS_COMMON, \
|
||||
.usb_protocol = MISC_PROTOCOL_IAD, \
|
||||
.usb_attributes = TUSB_DESC_CONFIG_ATT_SELF_POWERED, \
|
||||
.usb_power_ma = 500, \
|
||||
.webusb_enabled = false, \
|
||||
.webusb_url = "espressif.github.io/arduino-esp32/webusb.html" \
|
||||
#define TINYUSB_CONFIG_DEFAULT() \
|
||||
{ \
|
||||
.vid = USB_ESPRESSIF_VID, .pid = 0x0002, .product_name = CONFIG_TINYUSB_DESC_PRODUCT_STRING, .manufacturer_name = CONFIG_TINYUSB_DESC_MANUFACTURER_STRING, \
|
||||
.serial_number = CONFIG_TINYUSB_DESC_SERIAL_STRING, .fw_version = CONFIG_TINYUSB_DESC_BCDDEVICE, .usb_version = 0x0200, .usb_class = TUSB_CLASS_MISC, \
|
||||
.usb_subclass = MISC_SUBCLASS_COMMON, .usb_protocol = MISC_PROTOCOL_IAD, .usb_attributes = TUSB_DESC_CONFIG_ATT_SELF_POWERED, .usb_power_ma = 500, \
|
||||
.webusb_enabled = false, .webusb_url = "espressif.github.io/arduino-esp32/webusb.html" \
|
||||
}
|
||||
|
||||
esp_err_t tinyusb_init(tinyusb_device_config_t *config);
|
||||
esp_err_t tinyusb_init(tinyusb_device_config_t *config);
|
||||
|
||||
/*
|
||||
/*
|
||||
* USB Persistence API
|
||||
* */
|
||||
typedef enum {
|
||||
RESTART_NO_PERSIST,
|
||||
RESTART_PERSIST,
|
||||
RESTART_BOOTLOADER,
|
||||
RESTART_BOOTLOADER_DFU,
|
||||
RESTART_TYPE_MAX
|
||||
} restart_type_t;
|
||||
typedef enum {
|
||||
RESTART_NO_PERSIST,
|
||||
RESTART_PERSIST,
|
||||
RESTART_BOOTLOADER,
|
||||
RESTART_BOOTLOADER_DFU,
|
||||
RESTART_TYPE_MAX
|
||||
} restart_type_t;
|
||||
|
||||
void usb_persist_restart(restart_type_t mode);
|
||||
void usb_persist_restart(restart_type_t mode);
|
||||
|
||||
// The following definitions and functions are to be used only by the drivers
|
||||
typedef enum {
|
||||
USB_INTERFACE_MSC,
|
||||
USB_INTERFACE_DFU,
|
||||
USB_INTERFACE_HID,
|
||||
USB_INTERFACE_VENDOR,
|
||||
USB_INTERFACE_CDC,
|
||||
USB_INTERFACE_MIDI,
|
||||
USB_INTERFACE_CUSTOM,
|
||||
USB_INTERFACE_MAX
|
||||
} tinyusb_interface_t;
|
||||
// The following definitions and functions are to be used only by the drivers
|
||||
typedef enum {
|
||||
USB_INTERFACE_MSC,
|
||||
USB_INTERFACE_DFU,
|
||||
USB_INTERFACE_HID,
|
||||
USB_INTERFACE_VENDOR,
|
||||
USB_INTERFACE_CDC,
|
||||
USB_INTERFACE_MIDI,
|
||||
USB_INTERFACE_CUSTOM,
|
||||
USB_INTERFACE_MAX
|
||||
} tinyusb_interface_t;
|
||||
|
||||
typedef uint16_t (*tinyusb_descriptor_cb_t)(uint8_t *dst, uint8_t *itf);
|
||||
typedef uint16_t (*tinyusb_descriptor_cb_t)(uint8_t *dst, uint8_t *itf);
|
||||
|
||||
esp_err_t tinyusb_enable_interface(tinyusb_interface_t interface, uint16_t descriptor_len, tinyusb_descriptor_cb_t cb);
|
||||
esp_err_t tinyusb_enable_interface2(tinyusb_interface_t interface, uint16_t descriptor_len, tinyusb_descriptor_cb_t cb, bool reserve_endpoints);
|
||||
uint8_t tinyusb_add_string_descriptor(const char *str);
|
||||
uint8_t tinyusb_get_free_duplex_endpoint(void);
|
||||
uint8_t tinyusb_get_free_in_endpoint(void);
|
||||
uint8_t tinyusb_get_free_out_endpoint(void);
|
||||
esp_err_t tinyusb_enable_interface(tinyusb_interface_t interface, uint16_t descriptor_len, tinyusb_descriptor_cb_t cb);
|
||||
esp_err_t tinyusb_enable_interface2(tinyusb_interface_t interface, uint16_t descriptor_len, tinyusb_descriptor_cb_t cb, bool reserve_endpoints);
|
||||
uint8_t tinyusb_add_string_descriptor(const char *str);
|
||||
uint8_t tinyusb_get_free_duplex_endpoint(void);
|
||||
uint8_t tinyusb_get_free_in_endpoint(void);
|
||||
uint8_t tinyusb_get_free_out_endpoint(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -48,7 +48,7 @@ static TouchInterruptHandle_t __touchInterruptHandlers[SOC_TOUCH_SENSOR_NUM] = {
|
||||
|
||||
static uint8_t used_pads = 0;
|
||||
static bool initialized = false;
|
||||
static bool channels_initialized[SOC_TOUCH_SENSOR_NUM] = { false };
|
||||
static bool channels_initialized[SOC_TOUCH_SENSOR_NUM] = {false};
|
||||
|
||||
static void ARDUINO_ISR_ATTR __touchISR(void *arg) {
|
||||
#if SOC_TOUCH_VERSION_1 // ESP32
|
||||
@ -90,8 +90,6 @@ static void ARDUINO_ISR_ATTR __touchISR(void *arg) {
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void __touchSetCycles(uint16_t measure, uint16_t sleep) {
|
||||
__touchSleepCycles = sleep;
|
||||
__touchMeasureCycles = measure;
|
||||
@ -268,7 +266,6 @@ static void __touchDettachInterrupt(uint8_t pin) {
|
||||
__touchConfigInterrupt(pin, NULL, NULL, 0, false); // userFunc as NULL acts as detaching
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
External Public Touch API Functions
|
||||
*/
|
||||
|
@ -34,49 +34,48 @@ extern "C" {
|
||||
#endif
|
||||
|
||||
#if SOC_TOUCH_VERSION_1 // ESP32
|
||||
typedef uint16_t touch_value_t;
|
||||
typedef uint16_t touch_value_t;
|
||||
#elif SOC_TOUCH_VERSION_2 // ESP32S2 ESP32S3
|
||||
typedef uint32_t touch_value_t;
|
||||
#endif
|
||||
|
||||
/*
|
||||
/*
|
||||
* Set cycles that measurement operation takes
|
||||
* The result from touchRead, threshold and detection
|
||||
* accuracy depend on these values. Defaults are
|
||||
* 0x1000 for measure and 0x1000 for sleep.
|
||||
* With default values touchRead takes 0.5ms
|
||||
* */
|
||||
void touchSetCycles(uint16_t measure, uint16_t sleep);
|
||||
void touchSetCycles(uint16_t measure, uint16_t sleep);
|
||||
|
||||
/*
|
||||
/*
|
||||
* Read touch pad (for ESP32 values close to 0 mean touch detected /
|
||||
* for ESP32-S2/S3 higher values mean touch detected)
|
||||
* You can use this method to chose a good threshold value
|
||||
* to use as value for touchAttachInterrupt
|
||||
* */
|
||||
touch_value_t touchRead(uint8_t pin);
|
||||
touch_value_t touchRead(uint8_t pin);
|
||||
|
||||
/*
|
||||
/*
|
||||
* Set function to be called if touch pad value falls (ESP32)
|
||||
* below the given threshold / rises (ESP32-S2/S3) by given increment (threshold).
|
||||
* Use touchRead to determine a proper threshold between touched and untouched state
|
||||
* */
|
||||
void touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), touch_value_t threshold);
|
||||
void touchAttachInterruptArg(uint8_t pin, void (*userFunc)(void *), void *arg, touch_value_t threshold);
|
||||
void touchDetachInterrupt(uint8_t pin);
|
||||
void touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), touch_value_t threshold);
|
||||
void touchAttachInterruptArg(uint8_t pin, void (*userFunc)(void *), void *arg, touch_value_t threshold);
|
||||
void touchDetachInterrupt(uint8_t pin);
|
||||
|
||||
/*
|
||||
/*
|
||||
* Specific functions to ESP32
|
||||
* Tells the driver if it shall activate the ISR if the sensor is Lower or Higher than the Threshold
|
||||
* Default if Lower.
|
||||
**/
|
||||
|
||||
#if SOC_TOUCH_VERSION_1 // Only for ESP32 SoC
|
||||
void touchInterruptSetThresholdDirection(bool mustbeLower);
|
||||
void touchInterruptSetThresholdDirection(bool mustbeLower);
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
/*
|
||||
* Specific functions to ESP32-S2 and ESP32-S3
|
||||
* Returns true when the latest ISR status for the Touchpad is that it is touched (Active)
|
||||
* and false when the Touchpad is untoouched (Inactive)
|
||||
@ -85,14 +84,14 @@ typedef uint32_t touch_value_t;
|
||||
**/
|
||||
|
||||
#if SOC_TOUCH_VERSION_2 // Only for ESP32S2 and ESP32S3
|
||||
// returns true if touch pad has been and continues pressed and false otherwise
|
||||
bool touchInterruptGetLastStatus(uint8_t pin);
|
||||
// returns true if touch pad has been and continues pressed and false otherwise
|
||||
bool touchInterruptGetLastStatus(uint8_t pin);
|
||||
#endif
|
||||
|
||||
/*
|
||||
/*
|
||||
* Setup touch pad wake up from deep sleep with given threshold.
|
||||
**/
|
||||
void touchSleepWakeUpEnable(uint8_t pin, touch_value_t threshold);
|
||||
void touchSleepWakeUpEnable(uint8_t pin, touch_value_t threshold);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -60,30 +60,32 @@ struct uart_struct_t {
|
||||
#define UART_MUTEX_UNLOCK()
|
||||
|
||||
static uart_t _uart_bus_array[] = {
|
||||
{ 0, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0 },
|
||||
{0, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0},
|
||||
#if SOC_UART_NUM > 1
|
||||
{ 1, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0 },
|
||||
{1, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0},
|
||||
#endif
|
||||
#if SOC_UART_NUM > 2
|
||||
{ 2, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0 },
|
||||
{2, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0},
|
||||
#endif
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
#define UART_MUTEX_LOCK() \
|
||||
if (uart->lock != NULL) do { \
|
||||
if (uart->lock != NULL) \
|
||||
do { \
|
||||
} while (xSemaphoreTake(uart->lock, portMAX_DELAY) != pdPASS)
|
||||
#define UART_MUTEX_UNLOCK() \
|
||||
if (uart->lock != NULL) xSemaphoreGive(uart->lock)
|
||||
if (uart->lock != NULL) \
|
||||
xSemaphoreGive(uart->lock)
|
||||
|
||||
static uart_t _uart_bus_array[] = {
|
||||
{ NULL, 0, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0 },
|
||||
{NULL, 0, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0},
|
||||
#if SOC_UART_NUM > 1
|
||||
{ NULL, 1, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0 },
|
||||
{NULL, 1, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0},
|
||||
#endif
|
||||
#if SOC_UART_NUM > 2
|
||||
{ NULL, 2, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0 },
|
||||
{NULL, 2, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0},
|
||||
#endif
|
||||
};
|
||||
|
||||
@ -97,7 +99,7 @@ static bool _uartDetachPins(uint8_t uart_num, int8_t rxPin, int8_t txPin, int8_t
|
||||
return false;
|
||||
}
|
||||
// get UART information
|
||||
uart_t* uart = &_uart_bus_array[uart_num];
|
||||
uart_t *uart = &_uart_bus_array[uart_num];
|
||||
bool retCode = true;
|
||||
//log_v("detaching UART%d pins: prev,pin RX(%d,%d) TX(%d,%d) CTS(%d,%d) RTS(%d,%d)", uart_num,
|
||||
// uart->_rxPin, rxPin, uart->_txPin, txPin, uart->_ctsPin, ctsPin, uart->_rtsPin, rtsPin); vTaskDelay(10);
|
||||
@ -148,32 +150,31 @@ static bool _uartDetachPins(uint8_t uart_num, int8_t rxPin, int8_t txPin, int8_t
|
||||
}
|
||||
|
||||
// Peripheral Manager detach callback for each specific UART PIN
|
||||
static bool _uartDetachBus_RX(void* busptr) {
|
||||
static bool _uartDetachBus_RX(void *busptr) {
|
||||
// sanity check - it should never happen
|
||||
assert(busptr && "_uartDetachBus_RX bus NULL pointer.");
|
||||
uart_t* bus = (uart_t*)busptr;
|
||||
uart_t *bus = (uart_t *)busptr;
|
||||
return _uartDetachPins(bus->num, bus->_rxPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
|
||||
}
|
||||
|
||||
static bool _uartDetachBus_TX(void* busptr) {
|
||||
static bool _uartDetachBus_TX(void *busptr) {
|
||||
// sanity check - it should never happen
|
||||
assert(busptr && "_uartDetachBus_TX bus NULL pointer.");
|
||||
uart_t* bus = (uart_t*)busptr;
|
||||
uart_t *bus = (uart_t *)busptr;
|
||||
return _uartDetachPins(bus->num, UART_PIN_NO_CHANGE, bus->_txPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
|
||||
}
|
||||
|
||||
|
||||
static bool _uartDetachBus_CTS(void* busptr) {
|
||||
static bool _uartDetachBus_CTS(void *busptr) {
|
||||
// sanity check - it should never happen
|
||||
assert(busptr && "_uartDetachBus_CTS bus NULL pointer.");
|
||||
uart_t* bus = (uart_t*)busptr;
|
||||
uart_t *bus = (uart_t *)busptr;
|
||||
return _uartDetachPins(bus->num, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, bus->_ctsPin, UART_PIN_NO_CHANGE);
|
||||
}
|
||||
|
||||
static bool _uartDetachBus_RTS(void* busptr) {
|
||||
static bool _uartDetachBus_RTS(void *busptr) {
|
||||
// sanity check - it should never happen
|
||||
assert(busptr && "_uartDetachBus_RTS bus NULL pointer.");
|
||||
uart_t* bus = (uart_t*)busptr;
|
||||
uart_t *bus = (uart_t *)busptr;
|
||||
return _uartDetachPins(bus->num, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, bus->_rtsPin);
|
||||
}
|
||||
|
||||
@ -185,20 +186,23 @@ static bool _uartAttachPins(uint8_t uart_num, int8_t rxPin, int8_t txPin, int8_t
|
||||
return false;
|
||||
}
|
||||
// get UART information
|
||||
uart_t* uart = &_uart_bus_array[uart_num];
|
||||
uart_t *uart = &_uart_bus_array[uart_num];
|
||||
//log_v("attaching UART%d pins: prev,new RX(%d,%d) TX(%d,%d) CTS(%d,%d) RTS(%d,%d)", uart_num,
|
||||
// uart->_rxPin, rxPin, uart->_txPin, txPin, uart->_ctsPin, ctsPin, uart->_rtsPin, rtsPin); vTaskDelay(10);
|
||||
|
||||
|
||||
bool retCode = true;
|
||||
if (rxPin >= 0) {
|
||||
// forces a clean detaching from a previous peripheral
|
||||
if (perimanGetPinBusType(rxPin) != ESP32_BUS_TYPE_INIT) perimanClearPinBus(rxPin);
|
||||
if (perimanGetPinBusType(rxPin) != ESP32_BUS_TYPE_INIT) {
|
||||
perimanClearPinBus(rxPin);
|
||||
}
|
||||
// connect RX Pad
|
||||
bool ret = ESP_OK == uart_set_pin(uart->num, UART_PIN_NO_CHANGE, rxPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
|
||||
if (ret) {
|
||||
ret &= perimanSetPinBus(rxPin, ESP32_BUS_TYPE_UART_RX, (void*)uart, uart_num, -1);
|
||||
if (ret) uart->_rxPin = rxPin;
|
||||
ret &= perimanSetPinBus(rxPin, ESP32_BUS_TYPE_UART_RX, (void *)uart, uart_num, -1);
|
||||
if (ret) {
|
||||
uart->_rxPin = rxPin;
|
||||
}
|
||||
}
|
||||
if (!ret) {
|
||||
log_e("UART%d failed to attach RX pin %d", uart_num, rxPin);
|
||||
@ -207,12 +211,16 @@ static bool _uartAttachPins(uint8_t uart_num, int8_t rxPin, int8_t txPin, int8_t
|
||||
}
|
||||
if (txPin >= 0) {
|
||||
// forces a clean detaching from a previous peripheral
|
||||
if (perimanGetPinBusType(txPin) != ESP32_BUS_TYPE_INIT) perimanClearPinBus(txPin);
|
||||
if (perimanGetPinBusType(txPin) != ESP32_BUS_TYPE_INIT) {
|
||||
perimanClearPinBus(txPin);
|
||||
}
|
||||
// connect TX Pad
|
||||
bool ret = ESP_OK == uart_set_pin(uart->num, txPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
|
||||
if (ret) {
|
||||
ret &= perimanSetPinBus(txPin, ESP32_BUS_TYPE_UART_TX, (void*)uart, uart_num, -1);
|
||||
if (ret) uart->_txPin = txPin;
|
||||
ret &= perimanSetPinBus(txPin, ESP32_BUS_TYPE_UART_TX, (void *)uart, uart_num, -1);
|
||||
if (ret) {
|
||||
uart->_txPin = txPin;
|
||||
}
|
||||
}
|
||||
if (!ret) {
|
||||
log_e("UART%d failed to attach TX pin %d", uart_num, txPin);
|
||||
@ -221,12 +229,16 @@ static bool _uartAttachPins(uint8_t uart_num, int8_t rxPin, int8_t txPin, int8_t
|
||||
}
|
||||
if (ctsPin >= 0) {
|
||||
// forces a clean detaching from a previous peripheral
|
||||
if (perimanGetPinBusType(ctsPin) != ESP32_BUS_TYPE_INIT) perimanClearPinBus(ctsPin);
|
||||
if (perimanGetPinBusType(ctsPin) != ESP32_BUS_TYPE_INIT) {
|
||||
perimanClearPinBus(ctsPin);
|
||||
}
|
||||
// connect CTS Pad
|
||||
bool ret = ESP_OK == uart_set_pin(uart->num, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, ctsPin);
|
||||
if (ret) {
|
||||
ret &= perimanSetPinBus(ctsPin, ESP32_BUS_TYPE_UART_CTS, (void*)uart, uart_num, -1);
|
||||
if (ret) uart->_ctsPin = ctsPin;
|
||||
ret &= perimanSetPinBus(ctsPin, ESP32_BUS_TYPE_UART_CTS, (void *)uart, uart_num, -1);
|
||||
if (ret) {
|
||||
uart->_ctsPin = ctsPin;
|
||||
}
|
||||
}
|
||||
if (!ret) {
|
||||
log_e("UART%d failed to attach CTS pin %d", uart_num, ctsPin);
|
||||
@ -235,12 +247,16 @@ static bool _uartAttachPins(uint8_t uart_num, int8_t rxPin, int8_t txPin, int8_t
|
||||
}
|
||||
if (rtsPin >= 0) {
|
||||
// forces a clean detaching from a previous peripheral
|
||||
if (perimanGetPinBusType(rtsPin) != ESP32_BUS_TYPE_INIT) perimanClearPinBus(rtsPin);
|
||||
if (perimanGetPinBusType(rtsPin) != ESP32_BUS_TYPE_INIT) {
|
||||
perimanClearPinBus(rtsPin);
|
||||
}
|
||||
// connect RTS Pad
|
||||
bool ret = ESP_OK == uart_set_pin(uart->num, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, rtsPin, UART_PIN_NO_CHANGE);
|
||||
if (ret) {
|
||||
ret &= perimanSetPinBus(rtsPin, ESP32_BUS_TYPE_UART_RTS, (void*)uart, uart_num, -1);
|
||||
if (ret) uart->_rtsPin = rtsPin;
|
||||
ret &= perimanSetPinBus(rtsPin, ESP32_BUS_TYPE_UART_RTS, (void *)uart, uart_num, -1);
|
||||
if (ret) {
|
||||
uart->_rtsPin = rtsPin;
|
||||
}
|
||||
}
|
||||
if (!ret) {
|
||||
log_e("UART%d failed to attach RTS pin %d", uart_num, rtsPin);
|
||||
@ -268,7 +284,7 @@ void uart_init_PeriMan(void) {
|
||||
}
|
||||
|
||||
// Routines that take care of UART events will be in the HardwareSerial Class code
|
||||
void uartGetEventQueue(uart_t* uart, QueueHandle_t* q) {
|
||||
void uartGetEventQueue(uart_t *uart, QueueHandle_t *q) {
|
||||
// passing back NULL for the Queue pointer when UART is not initialized yet
|
||||
*q = NULL;
|
||||
if (uart == NULL) {
|
||||
@ -278,7 +294,7 @@ void uartGetEventQueue(uart_t* uart, QueueHandle_t* q) {
|
||||
return;
|
||||
}
|
||||
|
||||
bool uartIsDriverInstalled(uart_t* uart) {
|
||||
bool uartIsDriverInstalled(uart_t *uart) {
|
||||
if (uart == NULL) {
|
||||
return false;
|
||||
}
|
||||
@ -297,7 +313,7 @@ bool uartSetPins(uint8_t uart_num, int8_t rxPin, int8_t txPin, int8_t ctsPin, in
|
||||
return false;
|
||||
}
|
||||
// get UART information
|
||||
uart_t* uart = &_uart_bus_array[uart_num];
|
||||
uart_t *uart = &_uart_bus_array[uart_num];
|
||||
|
||||
bool retCode = true;
|
||||
UART_MUTEX_LOCK();
|
||||
@ -345,7 +361,7 @@ bool uartSetPins(uint8_t uart_num, int8_t rxPin, int8_t txPin, int8_t ctsPin, in
|
||||
}
|
||||
|
||||
//
|
||||
bool uartSetHwFlowCtrlMode(uart_t* uart, uart_hw_flowcontrol_t mode, uint8_t threshold) {
|
||||
bool uartSetHwFlowCtrlMode(uart_t *uart, uart_hw_flowcontrol_t mode, uint8_t threshold) {
|
||||
if (uart == NULL) {
|
||||
return false;
|
||||
}
|
||||
@ -358,15 +374,19 @@ bool uartSetHwFlowCtrlMode(uart_t* uart, uart_hw_flowcontrol_t mode, uint8_t thr
|
||||
}
|
||||
|
||||
// This helper function will return true if a new IDF UART driver needs to be restarted and false if the current one can continue its execution
|
||||
bool _testUartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted, uint8_t rxfifo_full_thrhd) {
|
||||
bool _testUartBegin(
|
||||
uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted,
|
||||
uint8_t rxfifo_full_thrhd
|
||||
) {
|
||||
if (uart_nr >= SOC_UART_NUM) {
|
||||
return false; // no new driver has to be installed
|
||||
}
|
||||
uart_t* uart = &_uart_bus_array[uart_nr];
|
||||
uart_t *uart = &_uart_bus_array[uart_nr];
|
||||
// verify if is necessary to restart the UART driver
|
||||
if (uart_is_driver_installed(uart_nr)) {
|
||||
// some parameters can't be changed unless we end the UART driver
|
||||
if (uart->_rx_buffer_size != rx_buffer_size || uart->_tx_buffer_size != tx_buffer_size || uart->_inverted != inverted || uart->_rxfifo_full_thrhd != rxfifo_full_thrhd) {
|
||||
if (uart->_rx_buffer_size != rx_buffer_size || uart->_tx_buffer_size != tx_buffer_size || uart->_inverted != inverted
|
||||
|| uart->_rxfifo_full_thrhd != rxfifo_full_thrhd) {
|
||||
return true; // the current IDF UART driver must be terminated and a new driver shall be installed
|
||||
} else {
|
||||
return false; // The current IDF UART driver can continue its execution
|
||||
@ -376,12 +396,15 @@ bool _testUartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t
|
||||
}
|
||||
}
|
||||
|
||||
uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted, uint8_t rxfifo_full_thrhd) {
|
||||
uart_t *uartBegin(
|
||||
uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted,
|
||||
uint8_t rxfifo_full_thrhd
|
||||
) {
|
||||
if (uart_nr >= SOC_UART_NUM) {
|
||||
log_e("UART number is invalid, please use number from 0 to %u", SOC_UART_NUM - 1);
|
||||
return NULL; // no new driver was installed
|
||||
}
|
||||
uart_t* uart = &_uart_bus_array[uart_nr];
|
||||
uart_t *uart = &_uart_bus_array[uart_nr];
|
||||
log_v("UART%d baud(%ld) Mode(%x) rxPin(%d) txPin(%d)", uart_nr, baudrate, config, rxPin, txPin);
|
||||
|
||||
#if !CONFIG_DISABLE_HAL_LOCKS
|
||||
@ -397,7 +420,8 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
|
||||
if (uart_is_driver_installed(uart_nr)) {
|
||||
log_v("UART%d Driver already installed.", uart_nr);
|
||||
// some parameters can't be changed unless we end the UART driver
|
||||
if (uart->_rx_buffer_size != rx_buffer_size || uart->_tx_buffer_size != tx_buffer_size || uart->_inverted != inverted || uart->_rxfifo_full_thrhd != rxfifo_full_thrhd) {
|
||||
if (uart->_rx_buffer_size != rx_buffer_size || uart->_tx_buffer_size != tx_buffer_size || uart->_inverted != inverted
|
||||
|| uart->_rxfifo_full_thrhd != rxfifo_full_thrhd) {
|
||||
log_v("UART%d changing buffer sizes or inverted signal or rxfifo_full_thrhd. IDF driver will be restarted", uart_nr);
|
||||
uartEnd(uart_nr);
|
||||
} else {
|
||||
@ -429,8 +453,7 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
|
||||
log_e("UART%d changing parity failed.", uart_nr);
|
||||
retCode = false;
|
||||
} else {
|
||||
log_v("UART%d changed parity to %s", uart_nr, parity == 0 ? "NONE" : parity == 2 ? "EVEN"
|
||||
: "ODD");
|
||||
log_v("UART%d changed parity to %s", uart_nr, parity == 0 ? "NONE" : parity == 2 ? "EVEN" : "ODD");
|
||||
}
|
||||
}
|
||||
if (retCode && (uart->_config & 0xc30) >> 4 != stop_bits) {
|
||||
@ -441,7 +464,9 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
|
||||
log_v("UART%d changed stop bits to %d", uart_nr, stop_bits == 3 ? 2 : 1);
|
||||
}
|
||||
}
|
||||
if (retCode) uart->_config = config;
|
||||
if (retCode) {
|
||||
uart->_config = config;
|
||||
}
|
||||
if (retCode && rxPin > 0 && uart->_rxPin != rxPin) {
|
||||
retCode &= _uartDetachPins(uart_nr, uart->_rxPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
|
||||
retCode &= _uartAttachPins(uart_nr, rxPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
|
||||
@ -484,7 +509,9 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
|
||||
UART_MUTEX_LOCK();
|
||||
bool retCode = ESP_OK == uart_driver_install(uart_nr, rx_buffer_size, tx_buffer_size, 20, &(uart->uart_event_queue), 0);
|
||||
|
||||
if (retCode) retCode &= ESP_OK == uart_param_config(uart_nr, &uart_config);
|
||||
if (retCode) {
|
||||
retCode &= ESP_OK == uart_param_config(uart_nr, &uart_config);
|
||||
}
|
||||
|
||||
// Is it right or the idea is to swap rx and tx pins?
|
||||
if (retCode && inverted) {
|
||||
@ -505,7 +532,9 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
|
||||
UART_MUTEX_UNLOCK();
|
||||
|
||||
// uartSetPins detaches previous pins if new ones are used over a previous begin()
|
||||
if (retCode) retCode &= uartSetPins(uart_nr, rxPin, txPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
|
||||
if (retCode) {
|
||||
retCode &= uartSetPins(uart_nr, rxPin, txPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
|
||||
}
|
||||
if (!retCode) {
|
||||
uartEnd(uart_nr);
|
||||
uart = NULL;
|
||||
@ -518,7 +547,7 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
|
||||
}
|
||||
|
||||
// This function code is under testing - for now just keep it here
|
||||
void uartSetFastReading(uart_t* uart) {
|
||||
void uartSetFastReading(uart_t *uart) {
|
||||
if (uart == NULL) {
|
||||
return;
|
||||
}
|
||||
@ -536,8 +565,7 @@ void uartSetFastReading(uart_t* uart) {
|
||||
UART_MUTEX_UNLOCK();
|
||||
}
|
||||
|
||||
|
||||
bool uartSetRxTimeout(uart_t* uart, uint8_t numSymbTimeout) {
|
||||
bool uartSetRxTimeout(uart_t *uart, uint8_t numSymbTimeout) {
|
||||
if (uart == NULL) {
|
||||
return false;
|
||||
}
|
||||
@ -548,7 +576,7 @@ bool uartSetRxTimeout(uart_t* uart, uint8_t numSymbTimeout) {
|
||||
return retCode;
|
||||
}
|
||||
|
||||
bool uartSetRxFIFOFull(uart_t* uart, uint8_t numBytesFIFOFull) {
|
||||
bool uartSetRxFIFOFull(uart_t *uart, uint8_t numBytesFIFOFull) {
|
||||
if (uart == NULL) {
|
||||
return false;
|
||||
}
|
||||
@ -559,14 +587,13 @@ bool uartSetRxFIFOFull(uart_t* uart, uint8_t numBytesFIFOFull) {
|
||||
return retCode;
|
||||
}
|
||||
|
||||
|
||||
void uartEnd(uint8_t uart_num) {
|
||||
if (uart_num >= SOC_UART_NUM) {
|
||||
log_e("Serial number is invalid, please use number from 0 to %u", SOC_UART_NUM - 1);
|
||||
return;
|
||||
}
|
||||
// get UART information
|
||||
uart_t* uart = &_uart_bus_array[uart_num];
|
||||
uart_t *uart = &_uart_bus_array[uart_num];
|
||||
|
||||
UART_MUTEX_LOCK();
|
||||
_uartDetachPins(uart_num, uart->_rxPin, uart->_txPin, uart->_ctsPin, uart->_rtsPin);
|
||||
@ -576,31 +603,31 @@ void uartEnd(uint8_t uart_num) {
|
||||
UART_MUTEX_UNLOCK();
|
||||
}
|
||||
|
||||
|
||||
void uartSetRxInvert(uart_t* uart, bool invert) {
|
||||
if (uart == NULL)
|
||||
void uartSetRxInvert(uart_t *uart, bool invert) {
|
||||
if (uart == NULL) {
|
||||
return;
|
||||
}
|
||||
#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
|
||||
// POTENTIAL ISSUE :: original code only set/reset rxd_inv bit
|
||||
// IDF or LL set/reset the whole inv_mask!
|
||||
// if (invert)
|
||||
// ESP_ERROR_CHECK(uart_set_line_inverse(uart->num, UART_SIGNAL_RXD_INV));
|
||||
// else
|
||||
// ESP_ERROR_CHECK(uart_set_line_inverse(uart->num, UART_SIGNAL_INV_DISABLE));
|
||||
// POTENTIAL ISSUE :: original code only set/reset rxd_inv bit
|
||||
// IDF or LL set/reset the whole inv_mask!
|
||||
// if (invert)
|
||||
// ESP_ERROR_CHECK(uart_set_line_inverse(uart->num, UART_SIGNAL_RXD_INV));
|
||||
// else
|
||||
// ESP_ERROR_CHECK(uart_set_line_inverse(uart->num, UART_SIGNAL_INV_DISABLE));
|
||||
|
||||
#else
|
||||
// this implementation is better over IDF API because it only affects RXD
|
||||
// this is supported in ESP32, ESP32-S2 and ESP32-C3
|
||||
uart_dev_t* hw = UART_LL_GET_HW(uart->num);
|
||||
if (invert)
|
||||
uart_dev_t *hw = UART_LL_GET_HW(uart->num);
|
||||
if (invert) {
|
||||
hw->conf0.rxd_inv = 1;
|
||||
else
|
||||
} else {
|
||||
hw->conf0.rxd_inv = 0;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
uint32_t uartAvailable(uart_t* uart) {
|
||||
uint32_t uartAvailable(uart_t *uart) {
|
||||
|
||||
if (uart == NULL) {
|
||||
return 0;
|
||||
@ -609,13 +636,14 @@ uint32_t uartAvailable(uart_t* uart) {
|
||||
UART_MUTEX_LOCK();
|
||||
size_t available;
|
||||
uart_get_buffered_data_len(uart->num, &available);
|
||||
if (uart->has_peek) available++;
|
||||
if (uart->has_peek) {
|
||||
available++;
|
||||
}
|
||||
UART_MUTEX_UNLOCK();
|
||||
return available;
|
||||
}
|
||||
|
||||
|
||||
uint32_t uartAvailableForWrite(uart_t* uart) {
|
||||
uint32_t uartAvailableForWrite(uart_t *uart) {
|
||||
if (uart == NULL) {
|
||||
return 0;
|
||||
}
|
||||
@ -629,7 +657,7 @@ uint32_t uartAvailableForWrite(uart_t* uart) {
|
||||
return available;
|
||||
}
|
||||
|
||||
size_t uartReadBytes(uart_t* uart, uint8_t* buffer, size_t size, uint32_t timeout_ms) {
|
||||
size_t uartReadBytes(uart_t *uart, uint8_t *buffer, size_t size, uint32_t timeout_ms) {
|
||||
if (uart == NULL || size == 0 || buffer == NULL) {
|
||||
return 0;
|
||||
}
|
||||
@ -647,18 +675,19 @@ size_t uartReadBytes(uart_t* uart, uint8_t* buffer, size_t size, uint32_t timeou
|
||||
|
||||
if (size > 0) {
|
||||
int len = uart_read_bytes(uart->num, buffer, size, pdMS_TO_TICKS(timeout_ms));
|
||||
if (len < 0) len = 0; // error reading UART
|
||||
if (len < 0) {
|
||||
len = 0; // error reading UART
|
||||
}
|
||||
bytes_read += len;
|
||||
}
|
||||
|
||||
|
||||
UART_MUTEX_UNLOCK();
|
||||
return bytes_read;
|
||||
}
|
||||
|
||||
// DEPRECATED but the original code will be kepts here as future reference when a final solution
|
||||
// to the UART driver is defined in the use case of reading byte by byte from UART.
|
||||
uint8_t uartRead(uart_t* uart) {
|
||||
uint8_t uartRead(uart_t *uart) {
|
||||
if (uart == NULL) {
|
||||
return 0;
|
||||
}
|
||||
@ -680,8 +709,7 @@ uint8_t uartRead(uart_t* uart) {
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
uint8_t uartPeek(uart_t* uart) {
|
||||
uint8_t uartPeek(uart_t *uart) {
|
||||
if (uart == NULL) {
|
||||
return 0;
|
||||
}
|
||||
@ -704,7 +732,7 @@ uint8_t uartPeek(uart_t* uart) {
|
||||
return c;
|
||||
}
|
||||
|
||||
void uartWrite(uart_t* uart, uint8_t c) {
|
||||
void uartWrite(uart_t *uart, uint8_t c) {
|
||||
if (uart == NULL) {
|
||||
return;
|
||||
}
|
||||
@ -713,7 +741,7 @@ void uartWrite(uart_t* uart, uint8_t c) {
|
||||
UART_MUTEX_UNLOCK();
|
||||
}
|
||||
|
||||
void uartWriteBuf(uart_t* uart, const uint8_t* data, size_t len) {
|
||||
void uartWriteBuf(uart_t *uart, const uint8_t *data, size_t len) {
|
||||
if (uart == NULL || data == NULL || !len) {
|
||||
return;
|
||||
}
|
||||
@ -723,18 +751,17 @@ void uartWriteBuf(uart_t* uart, const uint8_t* data, size_t len) {
|
||||
UART_MUTEX_UNLOCK();
|
||||
}
|
||||
|
||||
void uartFlush(uart_t* uart) {
|
||||
void uartFlush(uart_t *uart) {
|
||||
uartFlushTxOnly(uart, true);
|
||||
}
|
||||
|
||||
void uartFlushTxOnly(uart_t* uart, bool txOnly) {
|
||||
void uartFlushTxOnly(uart_t *uart, bool txOnly) {
|
||||
if (uart == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
UART_MUTEX_LOCK();
|
||||
while (!uart_ll_is_tx_idle(UART_LL_GET_HW(uart->num)))
|
||||
;
|
||||
while (!uart_ll_is_tx_idle(UART_LL_GET_HW(uart->num)));
|
||||
|
||||
if (!txOnly) {
|
||||
ESP_ERROR_CHECK(uart_flush_input(uart->num));
|
||||
@ -742,7 +769,7 @@ void uartFlushTxOnly(uart_t* uart, bool txOnly) {
|
||||
UART_MUTEX_UNLOCK();
|
||||
}
|
||||
|
||||
void uartSetBaudRate(uart_t* uart, uint32_t baud_rate) {
|
||||
void uartSetBaudRate(uart_t *uart, uint32_t baud_rate) {
|
||||
if (uart == NULL) {
|
||||
return;
|
||||
}
|
||||
@ -755,7 +782,7 @@ void uartSetBaudRate(uart_t* uart, uint32_t baud_rate) {
|
||||
UART_MUTEX_UNLOCK();
|
||||
}
|
||||
|
||||
uint32_t uartGetBaudRate(uart_t* uart) {
|
||||
uint32_t uartGetBaudRate(uart_t *uart) {
|
||||
uint32_t baud_rate = 0;
|
||||
uint32_t sclk_freq;
|
||||
|
||||
@ -772,51 +799,40 @@ uint32_t uartGetBaudRate(uart_t* uart) {
|
||||
}
|
||||
|
||||
static void ARDUINO_ISR_ATTR uart0_write_char(char c) {
|
||||
while (uart_ll_get_txfifo_len(&UART0) == 0)
|
||||
;
|
||||
uart_ll_write_txfifo(&UART0, (const uint8_t*)&c, 1);
|
||||
while (uart_ll_get_txfifo_len(&UART0) == 0);
|
||||
uart_ll_write_txfifo(&UART0, (const uint8_t *)&c, 1);
|
||||
}
|
||||
|
||||
#if SOC_UART_NUM > 1
|
||||
static void ARDUINO_ISR_ATTR uart1_write_char(char c) {
|
||||
while (uart_ll_get_txfifo_len(&UART1) == 0)
|
||||
;
|
||||
uart_ll_write_txfifo(&UART1, (const uint8_t*)&c, 1);
|
||||
while (uart_ll_get_txfifo_len(&UART1) == 0);
|
||||
uart_ll_write_txfifo(&UART1, (const uint8_t *)&c, 1);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SOC_UART_NUM > 2
|
||||
static void ARDUINO_ISR_ATTR uart2_write_char(char c) {
|
||||
while (uart_ll_get_txfifo_len(&UART2) == 0)
|
||||
;
|
||||
uart_ll_write_txfifo(&UART2, (const uint8_t*)&c, 1);
|
||||
while (uart_ll_get_txfifo_len(&UART2) == 0);
|
||||
uart_ll_write_txfifo(&UART2, (const uint8_t *)&c, 1);
|
||||
}
|
||||
#endif
|
||||
|
||||
void uart_install_putc() {
|
||||
switch (s_uart_debug_nr) {
|
||||
case 0:
|
||||
ets_install_putc1((void (*)(char)) & uart0_write_char);
|
||||
break;
|
||||
case 0: ets_install_putc1((void (*)(char)) & uart0_write_char); break;
|
||||
#if SOC_UART_NUM > 1
|
||||
case 1:
|
||||
ets_install_putc1((void (*)(char)) & uart1_write_char);
|
||||
break;
|
||||
case 1: ets_install_putc1((void (*)(char)) & uart1_write_char); break;
|
||||
#endif
|
||||
#if SOC_UART_NUM > 2
|
||||
case 2:
|
||||
ets_install_putc1((void (*)(char)) & uart2_write_char);
|
||||
break;
|
||||
case 2: ets_install_putc1((void (*)(char)) & uart2_write_char); break;
|
||||
#endif
|
||||
default:
|
||||
ets_install_putc1(NULL);
|
||||
break;
|
||||
default: ets_install_putc1(NULL); break;
|
||||
}
|
||||
}
|
||||
|
||||
// Routines that take care of UART mode in the HardwareSerial Class code
|
||||
// used to set UART_MODE_RS485_HALF_DUPLEX auto RTS for TXD for ESP32 chips
|
||||
bool uartSetMode(uart_t* uart, uart_mode_t mode) {
|
||||
bool uartSetMode(uart_t *uart, uart_mode_t mode) {
|
||||
if (uart == NULL || uart->num >= SOC_UART_NUM) {
|
||||
return false;
|
||||
}
|
||||
@ -827,7 +843,7 @@ bool uartSetMode(uart_t* uart, uart_mode_t mode) {
|
||||
return retCode;
|
||||
}
|
||||
|
||||
void uartSetDebug(uart_t* uart) {
|
||||
void uartSetDebug(uart_t *uart) {
|
||||
if (uart == NULL || uart->num >= SOC_UART_NUM) {
|
||||
s_uart_debug_nr = -1;
|
||||
} else {
|
||||
@ -840,16 +856,16 @@ int uartGetDebug() {
|
||||
return s_uart_debug_nr;
|
||||
}
|
||||
|
||||
int log_printfv(const char* format, va_list arg) {
|
||||
int log_printfv(const char *format, va_list arg) {
|
||||
static char loc_buf[64];
|
||||
char* temp = loc_buf;
|
||||
char *temp = loc_buf;
|
||||
uint32_t len;
|
||||
va_list copy;
|
||||
va_copy(copy, arg);
|
||||
len = vsnprintf(NULL, 0, format, copy);
|
||||
va_end(copy);
|
||||
if (len >= sizeof(loc_buf)) {
|
||||
temp = (char*)malloc(len + 1);
|
||||
temp = (char *)malloc(len + 1);
|
||||
if (temp == NULL) {
|
||||
return 0;
|
||||
}
|
||||
@ -883,13 +899,13 @@ int log_printfv(const char* format, va_list arg) {
|
||||
free(temp);
|
||||
}
|
||||
// flushes TX - make sure that the log message is completely sent.
|
||||
if (s_uart_debug_nr != -1)
|
||||
while (!uart_ll_is_tx_idle(UART_LL_GET_HW(s_uart_debug_nr)))
|
||||
;
|
||||
if (s_uart_debug_nr != -1) {
|
||||
while (!uart_ll_is_tx_idle(UART_LL_GET_HW(s_uart_debug_nr)));
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
int log_printf(const char* format, ...) {
|
||||
int log_printf(const char *format, ...) {
|
||||
int len;
|
||||
va_list arg;
|
||||
va_start(arg, format);
|
||||
@ -898,8 +914,7 @@ int log_printf(const char* format, ...) {
|
||||
return len;
|
||||
}
|
||||
|
||||
|
||||
static void log_print_buf_line(const uint8_t* b, size_t len, size_t total_len) {
|
||||
static void log_print_buf_line(const uint8_t *b, size_t len, size_t total_len) {
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
log_printf("%s0x%02x,", i ? " " : "", b[i]);
|
||||
}
|
||||
@ -917,7 +932,7 @@ static void log_print_buf_line(const uint8_t* b, size_t len, size_t total_len) {
|
||||
log_printf("\n");
|
||||
}
|
||||
|
||||
void log_print_buf(const uint8_t* b, size_t len) {
|
||||
void log_print_buf(const uint8_t *b, size_t len) {
|
||||
if (!len || !b) {
|
||||
return;
|
||||
}
|
||||
@ -933,17 +948,19 @@ void log_print_buf(const uint8_t* b, size_t len) {
|
||||
* if enough pulses are detected return the minimum high pulse duration + minimum low pulse duration divided by two.
|
||||
* This equals one bit period. If flag is true the function return immediately, otherwise it waits for enough pulses.
|
||||
*/
|
||||
unsigned long uartBaudrateDetect(uart_t* uart, bool flg) {
|
||||
unsigned long uartBaudrateDetect(uart_t *uart, bool flg) {
|
||||
// Baud rate detection only works for ESP32 and ESP32S2
|
||||
#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2
|
||||
if (uart == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
uart_dev_t* hw = UART_LL_GET_HW(uart->num);
|
||||
uart_dev_t *hw = UART_LL_GET_HW(uart->num);
|
||||
|
||||
while (hw->rxd_cnt.edge_cnt < 30) { // UART_PULSE_NUM(uart_num)
|
||||
if (flg) return 0;
|
||||
if (flg) {
|
||||
return 0;
|
||||
}
|
||||
ets_delay_us(1000);
|
||||
}
|
||||
|
||||
@ -958,7 +975,6 @@ unsigned long uartBaudrateDetect(uart_t* uart, bool flg) {
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* To start detection of baud rate with the uart the auto_baud.en bit needs to be cleared and set. The bit period is
|
||||
* detected calling uartBadrateDetect(). The raw baudrate is computed using the UART_CLK_FREQ. The raw baudrate is
|
||||
@ -980,14 +996,14 @@ unsigned long uartBaudrateDetect(uart_t* uart, bool flg) {
|
||||
*
|
||||
*
|
||||
*/
|
||||
void uartStartDetectBaudrate(uart_t* uart) {
|
||||
void uartStartDetectBaudrate(uart_t *uart) {
|
||||
if (uart == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Baud rate detection only works for ESP32 and ESP32S2
|
||||
#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2
|
||||
uart_dev_t* hw = UART_LL_GET_HW(uart->num);
|
||||
uart_dev_t *hw = UART_LL_GET_HW(uart->num);
|
||||
hw->auto_baud.glitch_filt = 0x08;
|
||||
hw->auto_baud.en = 0;
|
||||
hw->auto_baud.en = 1;
|
||||
@ -1007,7 +1023,7 @@ void uartStartDetectBaudrate(uart_t* uart) {
|
||||
#endif
|
||||
}
|
||||
|
||||
unsigned long uartDetectBaudrate(uart_t* uart) {
|
||||
unsigned long uartDetectBaudrate(uart_t *uart) {
|
||||
if (uart == NULL) {
|
||||
return 0;
|
||||
}
|
||||
@ -1027,7 +1043,7 @@ unsigned long uartDetectBaudrate(uart_t* uart) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
uart_dev_t* hw = UART_LL_GET_HW(uart->num);
|
||||
uart_dev_t *hw = UART_LL_GET_HW(uart->num);
|
||||
hw->auto_baud.en = 0;
|
||||
|
||||
uartStateDetectingBaudrate = false; // Initialize for the next round
|
||||
@ -1036,7 +1052,8 @@ unsigned long uartDetectBaudrate(uart_t* uart) {
|
||||
|
||||
//log_i("APB_FREQ = %d\nraw baudrate detected = %d", getApbFrequency(), baudrate);
|
||||
|
||||
static const unsigned long default_rates[] = { 300, 600, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 74880, 115200, 230400, 256000, 460800, 921600, 1843200, 3686400 };
|
||||
static const unsigned long default_rates[] = {300, 600, 1200, 2400, 4800, 9600, 19200, 38400, 57600,
|
||||
74880, 115200, 230400, 256000, 460800, 921600, 1843200, 3686400};
|
||||
|
||||
size_t i;
|
||||
for (i = 1; i < sizeof(default_rates) / sizeof(default_rates[0]) - 1; i++) // find the nearest real baudrate
|
||||
@ -1080,7 +1097,9 @@ unsigned long uartDetectBaudrate(uart_t* uart) {
|
||||
This creates a loop that lets us receive anything we send on the UART without external wires.
|
||||
*/
|
||||
void uart_internal_loopback(uint8_t uartNum, int8_t rxPin) {
|
||||
if (uartNum > SOC_UART_NUM - 1 || !GPIO_IS_VALID_GPIO(rxPin)) return;
|
||||
if (uartNum > SOC_UART_NUM - 1 || !GPIO_IS_VALID_GPIO(rxPin)) {
|
||||
return;
|
||||
}
|
||||
esp_rom_gpio_connect_out_signal(rxPin, UART_TX_SIGNAL(uartNum), false, false);
|
||||
}
|
||||
|
||||
@ -1101,9 +1120,9 @@ void uart_send_break(uint8_t uartNum) {
|
||||
}
|
||||
|
||||
// Sends a buffer and at the end of the stream, it generates BREAK in the line
|
||||
int uart_send_msg_with_break(uint8_t uartNum, uint8_t* msg, size_t msgSize) {
|
||||
int uart_send_msg_with_break(uint8_t uartNum, uint8_t *msg, size_t msgSize) {
|
||||
// 12 bits long BREAK for 8N1
|
||||
return uart_write_bytes_with_break(uartNum, (const void*)msg, msgSize, 12);
|
||||
return uart_write_bytes_with_break(uartNum, (const void *)msg, msgSize, 12);
|
||||
}
|
||||
|
||||
#endif /* SOC_UART_SUPPORTED */
|
||||
|
@ -29,87 +29,91 @@ extern "C" {
|
||||
#include "freertos/queue.h"
|
||||
#include "hal/uart_types.h"
|
||||
|
||||
struct uart_struct_t;
|
||||
typedef struct uart_struct_t uart_t;
|
||||
struct uart_struct_t;
|
||||
typedef struct uart_struct_t uart_t;
|
||||
|
||||
bool _testUartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted, uint8_t rxfifo_full_thrhd);
|
||||
uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted, uint8_t rxfifo_full_thrhd);
|
||||
void uartEnd(uint8_t uart_num);
|
||||
bool _testUartBegin(
|
||||
uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted,
|
||||
uint8_t rxfifo_full_thrhd
|
||||
);
|
||||
uart_t *uartBegin(
|
||||
uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted,
|
||||
uint8_t rxfifo_full_thrhd
|
||||
);
|
||||
void uartEnd(uint8_t uart_num);
|
||||
|
||||
// This is used to retrieve the Event Queue pointer from a UART IDF Driver in order to allow user to deal with its events
|
||||
void uartGetEventQueue(uart_t* uart, QueueHandle_t* q);
|
||||
// This is used to retrieve the Event Queue pointer from a UART IDF Driver in order to allow user to deal with its events
|
||||
void uartGetEventQueue(uart_t *uart, QueueHandle_t *q);
|
||||
|
||||
uint32_t uartAvailable(uart_t* uart);
|
||||
uint32_t uartAvailableForWrite(uart_t* uart);
|
||||
size_t uartReadBytes(uart_t* uart, uint8_t* buffer, size_t size, uint32_t timeout_ms);
|
||||
uint8_t uartRead(uart_t* uart);
|
||||
uint8_t uartPeek(uart_t* uart);
|
||||
uint32_t uartAvailable(uart_t *uart);
|
||||
uint32_t uartAvailableForWrite(uart_t *uart);
|
||||
size_t uartReadBytes(uart_t *uart, uint8_t *buffer, size_t size, uint32_t timeout_ms);
|
||||
uint8_t uartRead(uart_t *uart);
|
||||
uint8_t uartPeek(uart_t *uart);
|
||||
|
||||
void uartWrite(uart_t* uart, uint8_t c);
|
||||
void uartWriteBuf(uart_t* uart, const uint8_t* data, size_t len);
|
||||
void uartWrite(uart_t *uart, uint8_t c);
|
||||
void uartWriteBuf(uart_t *uart, const uint8_t *data, size_t len);
|
||||
|
||||
void uartFlush(uart_t* uart);
|
||||
void uartFlushTxOnly(uart_t* uart, bool txOnly);
|
||||
void uartFlush(uart_t *uart);
|
||||
void uartFlushTxOnly(uart_t *uart, bool txOnly);
|
||||
|
||||
void uartSetBaudRate(uart_t* uart, uint32_t baud_rate);
|
||||
uint32_t uartGetBaudRate(uart_t* uart);
|
||||
void uartSetBaudRate(uart_t *uart, uint32_t baud_rate);
|
||||
uint32_t uartGetBaudRate(uart_t *uart);
|
||||
|
||||
void uartSetRxInvert(uart_t* uart, bool invert);
|
||||
bool uartSetRxTimeout(uart_t* uart, uint8_t numSymbTimeout);
|
||||
bool uartSetRxFIFOFull(uart_t* uart, uint8_t numBytesFIFOFull);
|
||||
void uartSetFastReading(uart_t* uart);
|
||||
void uartSetRxInvert(uart_t *uart, bool invert);
|
||||
bool uartSetRxTimeout(uart_t *uart, uint8_t numSymbTimeout);
|
||||
bool uartSetRxFIFOFull(uart_t *uart, uint8_t numBytesFIFOFull);
|
||||
void uartSetFastReading(uart_t *uart);
|
||||
|
||||
void uartSetDebug(uart_t* uart);
|
||||
int uartGetDebug();
|
||||
void uartSetDebug(uart_t *uart);
|
||||
int uartGetDebug();
|
||||
|
||||
bool uartIsDriverInstalled(uart_t* uart);
|
||||
bool uartIsDriverInstalled(uart_t *uart);
|
||||
|
||||
// Negative Pin Number will keep it unmodified, thus this function can set individual pins
|
||||
// When pins are changed, it will detach the previous ones
|
||||
// Can be called before or after begin()
|
||||
bool uartSetPins(uint8_t uart_num, int8_t rxPin, int8_t txPin, int8_t ctsPin, int8_t rtsPin);
|
||||
// Negative Pin Number will keep it unmodified, thus this function can set individual pins
|
||||
// When pins are changed, it will detach the previous ones
|
||||
// Can be called before or after begin()
|
||||
bool uartSetPins(uint8_t uart_num, int8_t rxPin, int8_t txPin, int8_t ctsPin, int8_t rtsPin);
|
||||
|
||||
// helper functions
|
||||
int8_t uart_get_RxPin(uint8_t uart_num);
|
||||
int8_t uart_get_TxPin(uint8_t uart_num);
|
||||
void uart_init_PeriMan(void);
|
||||
// helper functions
|
||||
int8_t uart_get_RxPin(uint8_t uart_num);
|
||||
int8_t uart_get_TxPin(uint8_t uart_num);
|
||||
void uart_init_PeriMan(void);
|
||||
|
||||
// Enables or disables HW Flow Control function -- needs also to set CTS and/or RTS pins
|
||||
// UART_HW_FLOWCTRL_DISABLE = 0x0 disable hardware flow control
|
||||
// UART_HW_FLOWCTRL_RTS = 0x1 enable RX hardware flow control (rts)
|
||||
// UART_HW_FLOWCTRL_CTS = 0x2 enable TX hardware flow control (cts)
|
||||
// UART_HW_FLOWCTRL_CTS_RTS = 0x3 enable hardware flow control
|
||||
bool uartSetHwFlowCtrlMode(uart_t *uart, uart_hw_flowcontrol_t mode, uint8_t threshold);
|
||||
|
||||
// Enables or disables HW Flow Control function -- needs also to set CTS and/or RTS pins
|
||||
// UART_HW_FLOWCTRL_DISABLE = 0x0 disable hardware flow control
|
||||
// UART_HW_FLOWCTRL_RTS = 0x1 enable RX hardware flow control (rts)
|
||||
// UART_HW_FLOWCTRL_CTS = 0x2 enable TX hardware flow control (cts)
|
||||
// UART_HW_FLOWCTRL_CTS_RTS = 0x3 enable hardware flow control
|
||||
bool uartSetHwFlowCtrlMode(uart_t* uart, uart_hw_flowcontrol_t mode, uint8_t threshold);
|
||||
// Used to set RS485 function -- needs to disable HW Flow Control and set RTS pin to use
|
||||
// RTS pin becomes RS485 half duplex RE/DE
|
||||
// UART_MODE_UART = 0x00 mode: regular UART mode
|
||||
// UART_MODE_RS485_HALF_DUPLEX = 0x01 mode: half duplex RS485 UART mode control by RTS pin
|
||||
// UART_MODE_IRDA = 0x02 mode: IRDA UART mode
|
||||
// UART_MODE_RS485_COLLISION_DETECT = 0x03 mode: RS485 collision detection UART mode (used for test purposes)
|
||||
// UART_MODE_RS485_APP_CTRL = 0x04 mode: application control RS485 UART mode (used for test purposes)
|
||||
bool uartSetMode(uart_t *uart, uart_mode_t mode);
|
||||
|
||||
// Used to set RS485 function -- needs to disable HW Flow Control and set RTS pin to use
|
||||
// RTS pin becomes RS485 half duplex RE/DE
|
||||
// UART_MODE_UART = 0x00 mode: regular UART mode
|
||||
// UART_MODE_RS485_HALF_DUPLEX = 0x01 mode: half duplex RS485 UART mode control by RTS pin
|
||||
// UART_MODE_IRDA = 0x02 mode: IRDA UART mode
|
||||
// UART_MODE_RS485_COLLISION_DETECT = 0x03 mode: RS485 collision detection UART mode (used for test purposes)
|
||||
// UART_MODE_RS485_APP_CTRL = 0x04 mode: application control RS485 UART mode (used for test purposes)
|
||||
bool uartSetMode(uart_t* uart, uart_mode_t mode);
|
||||
void uartStartDetectBaudrate(uart_t *uart);
|
||||
unsigned long uartDetectBaudrate(uart_t *uart);
|
||||
|
||||
void uartStartDetectBaudrate(uart_t* uart);
|
||||
unsigned long uartDetectBaudrate(uart_t* uart);
|
||||
|
||||
/*
|
||||
/*
|
||||
These functions are for testing puspose only and can be used in Arduino Sketches
|
||||
Those are used in the UART examples
|
||||
*/
|
||||
|
||||
// Make sure UART's RX signal is connected to TX pin
|
||||
// This creates a loop that lets us receive anything we send on the UART
|
||||
void uart_internal_loopback(uint8_t uartNum, int8_t rxPin);
|
||||
// Make sure UART's RX signal is connected to TX pin
|
||||
// This creates a loop that lets us receive anything we send on the UART
|
||||
void uart_internal_loopback(uint8_t uartNum, int8_t rxPin);
|
||||
|
||||
// Routines that generate BREAK in the UART for testing purpose
|
||||
|
||||
// Forces a BREAK in the line based on SERIAL_8N1 configuration at any baud rate
|
||||
void uart_send_break(uint8_t uartNum);
|
||||
// Sends a buffer and at the end of the stream, it generates BREAK in the line
|
||||
int uart_send_msg_with_break(uint8_t uartNum, uint8_t* msg, size_t msgSize);
|
||||
// Routines that generate BREAK in the UART for testing purpose
|
||||
|
||||
// Forces a BREAK in the line based on SERIAL_8N1 configuration at any baud rate
|
||||
void uart_send_break(uint8_t uartNum);
|
||||
// Sends a buffer and at the end of the stream, it generates BREAK in the line
|
||||
int uart_send_msg_with_break(uint8_t uartNum, uint8_t *msg, size_t msgSize);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -61,13 +61,13 @@ extern "C" {
|
||||
#define ARDUINO_EVENT_RUNNING_CORE CONFIG_ARDUINO_EVENT_RUNNING_CORE
|
||||
#endif
|
||||
|
||||
//forward declaration from freertos/portmacro.h
|
||||
void vPortYield(void);
|
||||
void yield(void);
|
||||
//forward declaration from freertos/portmacro.h
|
||||
void vPortYield(void);
|
||||
void yield(void);
|
||||
#define optimistic_yield(u)
|
||||
|
||||
#define ESP_REG(addr) *((volatile uint32_t*)(addr))
|
||||
#define NOP() asm volatile("nop")
|
||||
#define ESP_REG(addr) *((volatile uint32_t *)(addr))
|
||||
#define NOP() asm volatile("nop")
|
||||
|
||||
#include "esp32-hal-log.h"
|
||||
#include "esp32-hal-matrix.h"
|
||||
@ -87,71 +87,68 @@ extern "C" {
|
||||
#include "esp32-hal-rgb-led.h"
|
||||
#include "esp32-hal-cpu.h"
|
||||
|
||||
void analogWrite(uint8_t pin, int value);
|
||||
void analogWriteFrequency(uint8_t pin, uint32_t freq);
|
||||
void analogWriteResolution(uint8_t pin, uint8_t bits);
|
||||
void analogWrite(uint8_t pin, int value);
|
||||
void analogWriteFrequency(uint8_t pin, uint32_t freq);
|
||||
void analogWriteResolution(uint8_t pin, uint8_t bits);
|
||||
|
||||
//returns chip temperature in Celsius
|
||||
float temperatureRead();
|
||||
//returns chip temperature in Celsius
|
||||
float temperatureRead();
|
||||
|
||||
//allows user to bypass SPI RAM test routine
|
||||
bool testSPIRAM(void);
|
||||
//allows user to bypass SPI RAM test routine
|
||||
bool testSPIRAM(void);
|
||||
|
||||
#if CONFIG_AUTOSTART_ARDUINO
|
||||
//enable/disable WDT for Arduino's setup and loop functions
|
||||
void enableLoopWDT();
|
||||
void disableLoopWDT();
|
||||
//feed WDT for the loop task
|
||||
void feedLoopWDT();
|
||||
//enable/disable WDT for Arduino's setup and loop functions
|
||||
void enableLoopWDT();
|
||||
void disableLoopWDT();
|
||||
//feed WDT for the loop task
|
||||
void feedLoopWDT();
|
||||
#endif
|
||||
|
||||
//enable/disable WDT for the IDLE task on Core 0 (SYSTEM)
|
||||
void enableCore0WDT();
|
||||
void disableCore0WDT();
|
||||
//enable/disable WDT for the IDLE task on Core 0 (SYSTEM)
|
||||
void enableCore0WDT();
|
||||
void disableCore0WDT();
|
||||
#ifndef CONFIG_FREERTOS_UNICORE
|
||||
//enable/disable WDT for the IDLE task on Core 1 (Arduino)
|
||||
void enableCore1WDT();
|
||||
void disableCore1WDT();
|
||||
//enable/disable WDT for the IDLE task on Core 1 (Arduino)
|
||||
void enableCore1WDT();
|
||||
void disableCore1WDT();
|
||||
#endif
|
||||
|
||||
//if xCoreID < 0 or CPU is unicore, it will use xTaskCreate, else xTaskCreatePinnedToCore
|
||||
//allows to easily handle all possible situations without repetitive code
|
||||
BaseType_t xTaskCreateUniversal(TaskFunction_t pxTaskCode,
|
||||
const char* const pcName,
|
||||
const uint32_t usStackDepth,
|
||||
void* const pvParameters,
|
||||
UBaseType_t uxPriority,
|
||||
TaskHandle_t* const pxCreatedTask,
|
||||
const BaseType_t xCoreID);
|
||||
//if xCoreID < 0 or CPU is unicore, it will use xTaskCreate, else xTaskCreatePinnedToCore
|
||||
//allows to easily handle all possible situations without repetitive code
|
||||
BaseType_t xTaskCreateUniversal(
|
||||
TaskFunction_t pxTaskCode, const char *const pcName, const uint32_t usStackDepth, void *const pvParameters, UBaseType_t uxPriority,
|
||||
TaskHandle_t *const pxCreatedTask, const BaseType_t xCoreID
|
||||
);
|
||||
|
||||
unsigned long micros();
|
||||
unsigned long millis();
|
||||
void delay(uint32_t);
|
||||
void delayMicroseconds(uint32_t us);
|
||||
unsigned long micros();
|
||||
unsigned long millis();
|
||||
void delay(uint32_t);
|
||||
void delayMicroseconds(uint32_t us);
|
||||
|
||||
#if !CONFIG_ESP32_PHY_AUTO_INIT
|
||||
void arduino_phy_init();
|
||||
void arduino_phy_init();
|
||||
#endif
|
||||
|
||||
#if !CONFIG_AUTOSTART_ARDUINO
|
||||
void initArduino();
|
||||
void initArduino();
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
int core; // core which triggered panic
|
||||
const char* reason; // exception string
|
||||
const void* pc; // instruction address that triggered the exception
|
||||
bool backtrace_corrupt; // if backtrace is corrupt
|
||||
bool backtrace_continues; // if backtrace continues, but did not fit
|
||||
unsigned int backtrace_len; // number of backtrace addresses
|
||||
unsigned int backtrace[60]; // backtrace addresses array
|
||||
} arduino_panic_info_t;
|
||||
typedef struct {
|
||||
int core; // core which triggered panic
|
||||
const char *reason; // exception string
|
||||
const void *pc; // instruction address that triggered the exception
|
||||
bool backtrace_corrupt; // if backtrace is corrupt
|
||||
bool backtrace_continues; // if backtrace continues, but did not fit
|
||||
unsigned int backtrace_len; // number of backtrace addresses
|
||||
unsigned int backtrace[60]; // backtrace addresses array
|
||||
} arduino_panic_info_t;
|
||||
|
||||
typedef void (*arduino_panic_handler_t)(arduino_panic_info_t* info, void* arg);
|
||||
typedef void (*arduino_panic_handler_t)(arduino_panic_info_t *info, void *arg);
|
||||
|
||||
void set_arduino_panic_handler(arduino_panic_handler_t handler, void* arg);
|
||||
arduino_panic_handler_t get_arduino_panic_handler(void);
|
||||
void* get_arduino_panic_handler_arg(void);
|
||||
void set_arduino_panic_handler(arduino_panic_handler_t handler, void *arg);
|
||||
arduino_panic_handler_t get_arduino_panic_handler(void);
|
||||
void *get_arduino_panic_handler_arg(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -20,5 +20,4 @@
|
||||
#define ICACHE_FLASH_ATTR
|
||||
#define ICACHE_RAM_ATTR ARDUINO_ISR_ATTR
|
||||
|
||||
|
||||
#endif /* _ESP8266_COMPAT_H_ */
|
||||
|
@ -37,15 +37,13 @@ extern "C" {
|
||||
*
|
||||
* To be used in comparisons, such as ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(2, 0, 0)
|
||||
*/
|
||||
#define ESP_ARDUINO_VERSION ESP_ARDUINO_VERSION_VAL(ESP_ARDUINO_VERSION_MAJOR, \
|
||||
ESP_ARDUINO_VERSION_MINOR, \
|
||||
ESP_ARDUINO_VERSION_PATCH)
|
||||
#define ESP_ARDUINO_VERSION ESP_ARDUINO_VERSION_VAL(ESP_ARDUINO_VERSION_MAJOR, ESP_ARDUINO_VERSION_MINOR, ESP_ARDUINO_VERSION_PATCH)
|
||||
|
||||
/**
|
||||
* Current ARDUINO version, as string
|
||||
*/
|
||||
#define df2xstr(s) #s
|
||||
#define df2str(s) df2xstr(s)
|
||||
#define df2xstr(s) #s
|
||||
#define df2str(s) df2xstr(s)
|
||||
#define ESP_ARDUINO_VERSION_STR df2str(ESP_ARDUINO_VERSION_MAJOR) "." df2str(ESP_ARDUINO_VERSION_MINOR) "." df2str(ESP_ARDUINO_VERSION_PATCH)
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
@ -1,3 +1,3 @@
|
||||
#define ATTR_PACKED __attribute__((__packed__))
|
||||
#define ATTR_PACKED __attribute__((__packed__))
|
||||
#define ATTR_ALIGNED(x) __attribute__((__aligned__(x)))
|
||||
#define ATTR_SECTION(x) __attribute__((__section__(x)))
|
||||
|
@ -111,7 +111,9 @@ void fat_set_table_index(uint8_t *table, uint16_t index, uint16_t value, bool fa
|
||||
}
|
||||
}
|
||||
|
||||
fat_boot_sector_t *fat_add_boot_sector(uint8_t *dst, uint16_t sector_num, uint16_t table_sectors, const char *file_system_type, const char *volume_label, uint32_t serial_number) {
|
||||
fat_boot_sector_t *fat_add_boot_sector(
|
||||
uint8_t *dst, uint16_t sector_num, uint16_t table_sectors, const char *file_system_type, const char *volume_label, uint32_t serial_number
|
||||
) {
|
||||
fat_boot_sector_t *boot = (fat_boot_sector_t *)dst;
|
||||
boot->jump_instruction[0] = 0xEB;
|
||||
boot->jump_instruction[1] = 0x3C;
|
||||
@ -149,7 +151,9 @@ fat_dir_entry_t *fat_add_label(uint8_t *dst, const char *volume_label) {
|
||||
return entry;
|
||||
}
|
||||
|
||||
fat_dir_entry_t *fat_add_root_file(uint8_t *dst, uint8_t index, const char *file_name, const char *file_extension, size_t file_size, uint16_t data_start_sector, bool is_fat16) {
|
||||
fat_dir_entry_t *fat_add_root_file(
|
||||
uint8_t *dst, uint8_t index, const char *file_name, const char *file_extension, size_t file_size, uint16_t data_start_sector, bool is_fat16
|
||||
) {
|
||||
fat_boot_sector_t *boot = (fat_boot_sector_t *)dst;
|
||||
uint8_t *table = dst + DISK_SECTOR_SIZE;
|
||||
fat_dir_entry_t *entry = (fat_dir_entry_t *)(dst + ((boot->sectors_per_alloc_table + 1) * DISK_SECTOR_SIZE) + (index * sizeof(fat_dir_entry_t)));
|
||||
@ -173,7 +177,7 @@ fat_dir_entry_t *fat_add_root_file(uint8_t *dst, uint8_t index, const char *file
|
||||
fat_set_table_index(table, data_end_sector - 1, 0xFFFF, is_fat16);
|
||||
|
||||
//Set Firmware Date based on the build time
|
||||
static const char *month_names_short[12] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
|
||||
static const char *month_names_short[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
|
||||
char mstr[8] = {
|
||||
'\0',
|
||||
};
|
||||
|
@ -24,117 +24,121 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define FAT_U8(v) ((v)&0xFF)
|
||||
#define FAT_U8(v) ((v) & 0xFF)
|
||||
#define FAT_U16(v) FAT_U8(v), FAT_U8((v) >> 8)
|
||||
#define FAT_U32(v) FAT_U8(v), FAT_U8((v) >> 8), FAT_U8((v) >> 16), FAT_U8((v) >> 24)
|
||||
|
||||
#define FAT12_TBL2B(l, h) FAT_U8(l), FAT_U8(((l >> 8) & 0xF) | ((h << 4) & 0xF0)), FAT_U8(h >> 4)
|
||||
|
||||
#define FAT_MS2B(s, ms) FAT_U8(((((s)&0x1) * 1000) + (ms)) / 10)
|
||||
#define FAT_HMS2B(h, m, s) FAT_U8(((s) >> 1) | (((m)&0x7) << 5)), FAT_U8((((m) >> 3) & 0x7) | ((h) << 3))
|
||||
#define FAT_YMD2B(y, m, d) FAT_U8(((d)&0x1F) | (((m)&0x7) << 5)), FAT_U8((((m) >> 3) & 0x1) | ((((y)-1980) & 0x7F) << 1))
|
||||
#define FAT_MS2B(s, ms) FAT_U8(((((s) & 0x1) * 1000) + (ms)) / 10)
|
||||
#define FAT_HMS2B(h, m, s) FAT_U8(((s) >> 1) | (((m) & 0x7) << 5)), FAT_U8((((m) >> 3) & 0x7) | ((h) << 3))
|
||||
#define FAT_YMD2B(y, m, d) FAT_U8(((d) & 0x1F) | (((m) & 0x7) << 5)), FAT_U8((((m) >> 3) & 0x1) | ((((y) - 1980) & 0x7F) << 1))
|
||||
|
||||
#define FAT_MS2V(s, ms) FAT_U8(((((s)&0x1) * 1000) + (ms)) / 10)
|
||||
#define FAT_HMS2V(h, m, s) (FAT_U8(((s) >> 1) | (((m)&0x7) << 5)) | (FAT_U8((((m) >> 3) & 0x7) | ((h) << 3)) << 8))
|
||||
#define FAT_YMD2V(y, m, d) (FAT_U8(((d)&0x1F) | (((m)&0x7) << 5)) | (FAT_U8((((m) >> 3) & 0x1) | ((((y)-1980) & 0x7F) << 1)) << 8))
|
||||
#define FAT_MS2V(s, ms) FAT_U8(((((s) & 0x1) * 1000) + (ms)) / 10)
|
||||
#define FAT_HMS2V(h, m, s) (FAT_U8(((s) >> 1) | (((m) & 0x7) << 5)) | (FAT_U8((((m) >> 3) & 0x7) | ((h) << 3)) << 8))
|
||||
#define FAT_YMD2V(y, m, d) (FAT_U8(((d) & 0x1F) | (((m) & 0x7) << 5)) | (FAT_U8((((m) >> 3) & 0x1) | ((((y) - 1980) & 0x7F) << 1)) << 8))
|
||||
|
||||
#define FAT_B2HMS(hms) ((hms >> 11) & 0x1F), ((hms >> 5) & 0x3F), ((hms & 0x1F) << 1)
|
||||
#define FAT_B2YMD(ymd) (((ymd >> 9) & 0x7F) + 1980), ((ymd >> 5) & 0x0F), (ymd & 0x1F)
|
||||
|
||||
#define FAT_FILE_ATTR_READ_ONLY 0x01
|
||||
#define FAT_FILE_ATTR_HIDDEN 0x02
|
||||
#define FAT_FILE_ATTR_SYSTEM 0x04
|
||||
#define FAT_FILE_ATTR_READ_ONLY 0x01
|
||||
#define FAT_FILE_ATTR_HIDDEN 0x02
|
||||
#define FAT_FILE_ATTR_SYSTEM 0x04
|
||||
#define FAT_FILE_ATTR_VOLUME_LABEL 0x08
|
||||
#define FAT_FILE_ATTR_SUBDIRECTORY 0x10
|
||||
#define FAT_FILE_ATTR_ARCHIVE 0x20
|
||||
#define FAT_FILE_ATTR_DEVICE 0x40
|
||||
#define FAT_FILE_ATTR_ARCHIVE 0x20
|
||||
#define FAT_FILE_ATTR_DEVICE 0x40
|
||||
|
||||
static const uint16_t DISK_SECTOR_SIZE = 512;
|
||||
static const uint16_t DISK_SECTOR_SIZE = 512;
|
||||
|
||||
#define FAT_SIZE_TO_SECTORS(bytes) ((bytes) / DISK_SECTOR_SIZE) + (((bytes) % DISK_SECTOR_SIZE) ? 1 : 0)
|
||||
|
||||
typedef struct __attribute__((packed)) {
|
||||
uint8_t jump_instruction[3];
|
||||
char oem_name[8]; //padded with spaces (0x20)
|
||||
uint16_t bytes_per_sector; //DISK_SECTOR_SIZE usually 512
|
||||
uint8_t sectors_per_cluster; //Allowed values are 1, 2, 4, 8, 16, 32, 64, and 128
|
||||
uint16_t reserved_sectors_count; //At least 1 for this sector, usually 32 for FAT32
|
||||
uint8_t file_alloc_tables_num; //Almost always 2; RAM disks might use 1
|
||||
uint16_t max_root_dir_entries; //FAT12 and FAT16
|
||||
uint16_t fat12_sector_num; //DISK_SECTOR_NUM FAT12 and FAT16
|
||||
uint8_t media_descriptor;
|
||||
uint16_t sectors_per_alloc_table; //FAT12 and FAT16
|
||||
uint16_t sectors_per_track; //A value of 0 may indicate LBA-only access
|
||||
uint16_t num_heads;
|
||||
uint32_t hidden_sectors_count;
|
||||
uint32_t total_sectors_32;
|
||||
uint8_t physical_drive_number; //0x00 for (first) removable media, 0x80 for (first) fixed disk
|
||||
uint8_t reserved0;
|
||||
uint8_t extended_boot_signature; //should be 0x29
|
||||
uint32_t serial_number; //0x1234 => 1234
|
||||
char volume_label[11]; //padded with spaces (0x20)
|
||||
char file_system_type[8]; //padded with spaces (0x20)
|
||||
uint8_t reserved[448];
|
||||
uint16_t signature; //should be 0xAA55
|
||||
} fat_boot_sector_t;
|
||||
typedef struct __attribute__((packed)) {
|
||||
uint8_t jump_instruction[3];
|
||||
char oem_name[8]; //padded with spaces (0x20)
|
||||
uint16_t bytes_per_sector; //DISK_SECTOR_SIZE usually 512
|
||||
uint8_t sectors_per_cluster; //Allowed values are 1, 2, 4, 8, 16, 32, 64, and 128
|
||||
uint16_t reserved_sectors_count; //At least 1 for this sector, usually 32 for FAT32
|
||||
uint8_t file_alloc_tables_num; //Almost always 2; RAM disks might use 1
|
||||
uint16_t max_root_dir_entries; //FAT12 and FAT16
|
||||
uint16_t fat12_sector_num; //DISK_SECTOR_NUM FAT12 and FAT16
|
||||
uint8_t media_descriptor;
|
||||
uint16_t sectors_per_alloc_table; //FAT12 and FAT16
|
||||
uint16_t sectors_per_track; //A value of 0 may indicate LBA-only access
|
||||
uint16_t num_heads;
|
||||
uint32_t hidden_sectors_count;
|
||||
uint32_t total_sectors_32;
|
||||
uint8_t physical_drive_number; //0x00 for (first) removable media, 0x80 for (first) fixed disk
|
||||
uint8_t reserved0;
|
||||
uint8_t extended_boot_signature; //should be 0x29
|
||||
uint32_t serial_number; //0x1234 => 1234
|
||||
char volume_label[11]; //padded with spaces (0x20)
|
||||
char file_system_type[8]; //padded with spaces (0x20)
|
||||
uint8_t reserved[448];
|
||||
uint16_t signature; //should be 0xAA55
|
||||
} fat_boot_sector_t;
|
||||
|
||||
typedef struct __attribute__((packed)) {
|
||||
union {
|
||||
struct {
|
||||
char file_name[8]; //padded with spaces (0x20)
|
||||
char file_extension[3]; //padded with spaces (0x20)
|
||||
};
|
||||
struct {
|
||||
uint8_t file_magic; // 0xE5:deleted, 0x05:will_be_deleted, 0x00:end_marker, 0x2E:dot_marker(. or ..)
|
||||
char file_magic_data[10];
|
||||
};
|
||||
char volume_label[11]; //padded with spaces (0x20)
|
||||
typedef struct __attribute__((packed)) {
|
||||
union {
|
||||
struct {
|
||||
char file_name[8]; //padded with spaces (0x20)
|
||||
char file_extension[3]; //padded with spaces (0x20)
|
||||
};
|
||||
uint8_t file_attr; //mask of FAT_FILE_ATTR_*
|
||||
uint8_t reserved; //always 0
|
||||
uint8_t creation_time_ms; //ms * 10; max 1990 (1s 990ms)
|
||||
uint16_t creation_time_hms; // [5:6:5] => h:m:(s/2)
|
||||
uint16_t creation_time_ymd; // [7:4:5] => (y+1980):m:d
|
||||
uint16_t last_access_ymd;
|
||||
uint16_t extended_attr;
|
||||
uint16_t last_modified_hms;
|
||||
uint16_t last_modified_ymd;
|
||||
uint16_t data_start_sector;
|
||||
uint32_t file_size;
|
||||
} fat_dir_entry_t;
|
||||
|
||||
typedef struct __attribute__((packed)) {
|
||||
union {
|
||||
struct {
|
||||
uint8_t number : 5;
|
||||
uint8_t reserved0 : 1;
|
||||
uint8_t llfp : 1;
|
||||
uint8_t reserved1 : 1;
|
||||
} seq;
|
||||
uint8_t seq_num; //0xE5: Deleted Entry
|
||||
struct {
|
||||
uint8_t file_magic; // 0xE5:deleted, 0x05:will_be_deleted, 0x00:end_marker, 0x2E:dot_marker(. or ..)
|
||||
char file_magic_data[10];
|
||||
};
|
||||
uint16_t name0[5];
|
||||
uint8_t attr; //ALWAYS 0x0F
|
||||
uint8_t type; //ALWAYS 0x00
|
||||
uint8_t dos_checksum;
|
||||
uint16_t name1[6];
|
||||
uint16_t first_cluster; //ALWAYS 0x0000
|
||||
uint16_t name2[2];
|
||||
} fat_lfn_entry_t;
|
||||
char volume_label[11]; //padded with spaces (0x20)
|
||||
};
|
||||
uint8_t file_attr; //mask of FAT_FILE_ATTR_*
|
||||
uint8_t reserved; //always 0
|
||||
uint8_t creation_time_ms; //ms * 10; max 1990 (1s 990ms)
|
||||
uint16_t creation_time_hms; // [5:6:5] => h:m:(s/2)
|
||||
uint16_t creation_time_ymd; // [7:4:5] => (y+1980):m:d
|
||||
uint16_t last_access_ymd;
|
||||
uint16_t extended_attr;
|
||||
uint16_t last_modified_hms;
|
||||
uint16_t last_modified_ymd;
|
||||
uint16_t data_start_sector;
|
||||
uint32_t file_size;
|
||||
} fat_dir_entry_t;
|
||||
|
||||
typedef union {
|
||||
fat_dir_entry_t dir;
|
||||
fat_lfn_entry_t lfn;
|
||||
} fat_entry_t;
|
||||
typedef struct __attribute__((packed)) {
|
||||
union {
|
||||
struct {
|
||||
uint8_t number : 5;
|
||||
uint8_t reserved0 : 1;
|
||||
uint8_t llfp : 1;
|
||||
uint8_t reserved1 : 1;
|
||||
} seq;
|
||||
uint8_t seq_num; //0xE5: Deleted Entry
|
||||
};
|
||||
uint16_t name0[5];
|
||||
uint8_t attr; //ALWAYS 0x0F
|
||||
uint8_t type; //ALWAYS 0x00
|
||||
uint8_t dos_checksum;
|
||||
uint16_t name1[6];
|
||||
uint16_t first_cluster; //ALWAYS 0x0000
|
||||
uint16_t name2[2];
|
||||
} fat_lfn_entry_t;
|
||||
|
||||
const char *fat_file_system_type(bool fat16);
|
||||
uint16_t fat_sectors_per_alloc_table(uint32_t sector_num, bool fat16);
|
||||
uint8_t *fat_add_table(uint8_t *dst, fat_boot_sector_t *boot, bool fat16);
|
||||
void fat_set_table_index(uint8_t *table, uint16_t index, uint16_t value, bool fat16);
|
||||
fat_boot_sector_t *fat_add_boot_sector(uint8_t *dst, uint16_t sector_num, uint16_t table_sectors, const char *file_system_type, const char *volume_label, uint32_t serial_number);
|
||||
fat_dir_entry_t *fat_add_label(uint8_t *dst, const char *volume_label);
|
||||
fat_dir_entry_t *fat_add_root_file(uint8_t *dst, uint8_t index, const char *file_name, const char *file_extension, size_t file_size, uint16_t data_start_sector, bool is_fat16);
|
||||
uint8_t fat_lfn_checksum(const uint8_t *short_filename);
|
||||
typedef union {
|
||||
fat_dir_entry_t dir;
|
||||
fat_lfn_entry_t lfn;
|
||||
} fat_entry_t;
|
||||
|
||||
const char *fat_file_system_type(bool fat16);
|
||||
uint16_t fat_sectors_per_alloc_table(uint32_t sector_num, bool fat16);
|
||||
uint8_t *fat_add_table(uint8_t *dst, fat_boot_sector_t *boot, bool fat16);
|
||||
void fat_set_table_index(uint8_t *table, uint16_t index, uint16_t value, bool fat16);
|
||||
fat_boot_sector_t *fat_add_boot_sector(
|
||||
uint8_t *dst, uint16_t sector_num, uint16_t table_sectors, const char *file_system_type, const char *volume_label, uint32_t serial_number
|
||||
);
|
||||
fat_dir_entry_t *fat_add_label(uint8_t *dst, const char *volume_label);
|
||||
fat_dir_entry_t *fat_add_root_file(
|
||||
uint8_t *dst, uint8_t index, const char *file_name, const char *file_extension, size_t file_size, uint16_t data_start_sector, bool is_fat16
|
||||
);
|
||||
uint8_t fat_lfn_checksum(const uint8_t *short_filename);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@ -16,103 +16,109 @@ int8_t gpioNumberToDigitalPin(int8_t gpioNumber);
|
||||
|
||||
// cores/esp32/Arduino.h
|
||||
#define pulseInLong(pin, args...) pulseInLong(digitalPinToGPIONumber(pin), args)
|
||||
#define pulseIn(pin, args...) pulseIn(digitalPinToGPIONumber(pin), args)
|
||||
#define noTone(_pin) noTone(digitalPinToGPIONumber(_pin))
|
||||
#define tone(_pin, args...) tone(digitalPinToGPIONumber(_pin), args)
|
||||
#define pulseIn(pin, args...) pulseIn(digitalPinToGPIONumber(pin), args)
|
||||
#define noTone(_pin) noTone(digitalPinToGPIONumber(_pin))
|
||||
#define tone(_pin, args...) tone(digitalPinToGPIONumber(_pin), args)
|
||||
|
||||
// cores/esp32/esp32-hal.h
|
||||
#define analogGetChannel(pin) analogGetChannel(digitalPinToGPIONumber(pin))
|
||||
#define analogWrite(pin, value) analogWrite(digitalPinToGPIONumber(pin), value)
|
||||
#define analogWriteFrequency(pin, freq) analogWriteFrequency(digitalPinToGPIONumber(pin), freq)
|
||||
#define analogGetChannel(pin) analogGetChannel(digitalPinToGPIONumber(pin))
|
||||
#define analogWrite(pin, value) analogWrite(digitalPinToGPIONumber(pin), value)
|
||||
#define analogWriteFrequency(pin, freq) analogWriteFrequency(digitalPinToGPIONumber(pin), freq)
|
||||
#define analogWriteResolution(pin, bits) analogWriteResolution(digitalPinToGPIONumber(pin), bits)
|
||||
|
||||
// cores/esp32/esp32-hal-adc.h
|
||||
#define analogRead(pin) analogRead(digitalPinToGPIONumber(pin))
|
||||
#define analogReadMilliVolts(pin) analogReadMilliVolts(digitalPinToGPIONumber(pin))
|
||||
#define analogRead(pin) analogRead(digitalPinToGPIONumber(pin))
|
||||
#define analogReadMilliVolts(pin) analogReadMilliVolts(digitalPinToGPIONumber(pin))
|
||||
#define analogSetPinAttenuation(pin, attenuation) analogSetPinAttenuation(digitalPinToGPIONumber(pin), attenuation)
|
||||
|
||||
// cores/esp32/esp32-hal-dac.h
|
||||
#define dacDisable(pin) dacDisable(digitalPinToGPIONumber(pin))
|
||||
#define dacDisable(pin) dacDisable(digitalPinToGPIONumber(pin))
|
||||
#define dacWrite(pin, value) dacWrite(digitalPinToGPIONumber(pin), value)
|
||||
|
||||
// cores/esp32/esp32-hal-gpio.h
|
||||
#define analogChannelToDigitalPin(channel) gpioNumberToDigitalPin(analogChannelToDigitalPin(channel))
|
||||
#define digitalPinToAnalogChannel(pin) digitalPinToAnalogChannel(digitalPinToGPIONumber(pin))
|
||||
#define digitalPinToTouchChannel(pin) digitalPinToTouchChannel(digitalPinToGPIONumber(pin))
|
||||
#define digitalRead(pin) digitalRead(digitalPinToGPIONumber(pin))
|
||||
#define analogChannelToDigitalPin(channel) gpioNumberToDigitalPin(analogChannelToDigitalPin(channel))
|
||||
#define digitalPinToAnalogChannel(pin) digitalPinToAnalogChannel(digitalPinToGPIONumber(pin))
|
||||
#define digitalPinToTouchChannel(pin) digitalPinToTouchChannel(digitalPinToGPIONumber(pin))
|
||||
#define digitalRead(pin) digitalRead(digitalPinToGPIONumber(pin))
|
||||
#define attachInterruptArg(pin, fcn, arg, mode) attachInterruptArg(digitalPinToGPIONumber(pin), fcn, arg, mode)
|
||||
#define attachInterrupt(pin, fcn, mode) attachInterrupt(digitalPinToGPIONumber(pin), fcn, mode)
|
||||
#define detachInterrupt(pin) detachInterrupt(digitalPinToGPIONumber(pin))
|
||||
#define digitalWrite(pin, val) digitalWrite(digitalPinToGPIONumber(pin), val)
|
||||
#define pinMode(pin, mode) pinMode(digitalPinToGPIONumber(pin), mode)
|
||||
#define attachInterrupt(pin, fcn, mode) attachInterrupt(digitalPinToGPIONumber(pin), fcn, mode)
|
||||
#define detachInterrupt(pin) detachInterrupt(digitalPinToGPIONumber(pin))
|
||||
#define digitalWrite(pin, val) digitalWrite(digitalPinToGPIONumber(pin), val)
|
||||
#define pinMode(pin, mode) pinMode(digitalPinToGPIONumber(pin), mode)
|
||||
|
||||
// cores/esp32/esp32-hal-i2c.h
|
||||
#define i2cInit(i2c_num, sda, scl, clk_speed) i2cInit(i2c_num, digitalPinToGPIONumber(sda), digitalPinToGPIONumber(scl), clk_speed)
|
||||
|
||||
// cores/esp32/esp32-hal-i2c-slave.h
|
||||
#define i2cSlaveInit(num, sda, scl, slaveID, frequency, rx_len, tx_len) i2cSlaveInit(num, digitalPinToGPIONumber(sda), digitalPinToGPIONumber(scl), slaveID, frequency, rx_len, tx_len)
|
||||
#define i2cSlaveInit(num, sda, scl, slaveID, frequency, rx_len, tx_len) \
|
||||
i2cSlaveInit(num, digitalPinToGPIONumber(sda), digitalPinToGPIONumber(scl), slaveID, frequency, rx_len, tx_len)
|
||||
|
||||
// cores/esp32/esp32-hal-ledc.h
|
||||
#define ledcAttach(pin, freq, resolution) ledcAttach(digitalPinToGPIONumber(pin), freq, resolution)
|
||||
#define ledcAttach(pin, freq, resolution) ledcAttach(digitalPinToGPIONumber(pin), freq, resolution)
|
||||
#define ledcAttachChannel(pin, freq, resolution, channel) ledcAttachChannel(digitalPinToGPIONumber(pin), freq, resolution, channel)
|
||||
#define ledcWrite(pin, duty) ledcWrite(digitalPinToGPIONumber(pin), duty)
|
||||
#define ledcWriteTone(pin, freq) ledcWriteTone(digitalPinToGPIONumber(pin), freq)
|
||||
#define ledcWriteNote(pin, note, octave) ledcWriteNote(digitalPinToGPIONumber(pin), note, octave)
|
||||
#define ledcRead(pin) ledcRead(digitalPinToGPIONumber(pin))
|
||||
#define ledcReadFreq(pin) ledcReadFreq(digitalPinToGPIONumber(pin))
|
||||
#define ledcDetach(pin) ledcDetach(digitalPinToGPIONumber(pin))
|
||||
#define ledcChangeFrequency(pin, freq, resolution) ledcChangeFrequency(digitalPinToGPIONumber(pin), freq, resolution)
|
||||
#define ledcOutputInvert(pin, out_invert) ledcOutputInvert(digitalPinToGPIONumber(pin), out_invert)
|
||||
#define ledcWrite(pin, duty) ledcWrite(digitalPinToGPIONumber(pin), duty)
|
||||
#define ledcWriteTone(pin, freq) ledcWriteTone(digitalPinToGPIONumber(pin), freq)
|
||||
#define ledcWriteNote(pin, note, octave) ledcWriteNote(digitalPinToGPIONumber(pin), note, octave)
|
||||
#define ledcRead(pin) ledcRead(digitalPinToGPIONumber(pin))
|
||||
#define ledcReadFreq(pin) ledcReadFreq(digitalPinToGPIONumber(pin))
|
||||
#define ledcDetach(pin) ledcDetach(digitalPinToGPIONumber(pin))
|
||||
#define ledcChangeFrequency(pin, freq, resolution) ledcChangeFrequency(digitalPinToGPIONumber(pin), freq, resolution)
|
||||
#define ledcOutputInvert(pin, out_invert) ledcOutputInvert(digitalPinToGPIONumber(pin), out_invert)
|
||||
|
||||
#define ledcFade(pin, start_duty, target_duty, max_fade_time_ms) ledcFade(digitalPinToGPIONumber(pin), start_duty, target_duty, max_fade_time_ms)
|
||||
#define ledcFadeWithInterrupt(pin, start_duty, target_duty, max_fade_time_ms, userFunc) ledcFadeWithInterrupt(digitalPinToGPIONumber(pin), start_duty, target_duty, max_fade_time_ms, userFunc)
|
||||
#define ledcFadeWithInterruptArg(pin, start_duty, target_duty, max_fade_time_ms, userFunc, arg) ledcFadeWithInterruptArg(digitalPinToGPIONumber(pin), start_duty, target_duty, max_fade_time_ms, userFunc, arg)
|
||||
#define ledcFadeWithInterrupt(pin, start_duty, target_duty, max_fade_time_ms, userFunc) \
|
||||
ledcFadeWithInterrupt(digitalPinToGPIONumber(pin), start_duty, target_duty, max_fade_time_ms, userFunc)
|
||||
#define ledcFadeWithInterruptArg(pin, start_duty, target_duty, max_fade_time_ms, userFunc, arg) \
|
||||
ledcFadeWithInterruptArg(digitalPinToGPIONumber(pin), start_duty, target_duty, max_fade_time_ms, userFunc, arg)
|
||||
|
||||
// cores/esp32/esp32-hal-matrix.h
|
||||
#define pinMatrixInAttach(pin, signal, inverted) pinMatrixInAttach(digitalPinToGPIONumber(pin), signal, inverted)
|
||||
#define pinMatrixInAttach(pin, signal, inverted) pinMatrixInAttach(digitalPinToGPIONumber(pin), signal, inverted)
|
||||
#define pinMatrixOutAttach(pin, function, invertOut, invertEnable) pinMatrixOutAttach(digitalPinToGPIONumber(pin), function, invertOut, invertEnable)
|
||||
#define pinMatrixOutDetach(pin, invertOut, invertEnable) pinMatrixOutDetach(digitalPinToGPIONumber(pin), invertOut, invertEnable)
|
||||
#define pinMatrixOutDetach(pin, invertOut, invertEnable) pinMatrixOutDetach(digitalPinToGPIONumber(pin), invertOut, invertEnable)
|
||||
|
||||
// cores/esp32/esp32-hal-rgb-led.h
|
||||
#define neopixelWrite(pin, red_val, green_val, blue_val) neopixelWrite(digitalPinToGPIONumber(pin), red_val, green_val, blue_val)
|
||||
|
||||
// cores/esp32/esp32-hal-rmt.h
|
||||
#define rmtInit(pin, channel_direction, memsize, frequency_Hz) rmtInit(digitalPinToGPIONumber(pin), channel_direction, memsize, frequency_Hz)
|
||||
#define rmtSetEOT(pin, EOT_Level) rmtSetEOT(digitalPinToGPIONumber(pin), EOT_Level)
|
||||
#define rmtWrite(pin, data, num_rmt_symbols, timeout_ms) rmtWrite(digitalPinToGPIONumber(pin), data, num_rmt_symbols, timeout_ms)
|
||||
#define rmtWriteAsync(pin, data, num_rmt_symbols) rmtWriteAsync(digitalPinToGPIONumber(pin), data, num_rmt_symbols)
|
||||
#define rmtWriteLooping(pin, data, num_rmt_symbols) rmtWriteLooping(digitalPinToGPIONumber(pin), data, num_rmt_symbols)
|
||||
#define rmtTransmitCompleted(pin) rmtTransmitCompleted(digitalPinToGPIONumber(pin))
|
||||
#define rmtRead(pin, data, num_rmt_symbols, timeout_ms) rmtRead(digitalPinToGPIONumber(pin), data, num_rmt_symbols, timeout_ms)
|
||||
#define rmtReadAsync(pin, data, num_rmt_symbols) rmtReadAsync(digitalPinToGPIONumber(pin), data, num_rmt_symbols)
|
||||
#define rmtReceiveCompleted(pin) rmtReceiveCompleted(digitalPinToGPIONumber(pin))
|
||||
#define rmtSetRxMaxThreshold(pin, idle_thres_ticks) rmtSetRxMaxThreshold(digitalPinToGPIONumber(pin), idle_thres_ticks)
|
||||
#define rmtSetCarrier(pin, carrier_en, carrier_level, frequency_Hz, duty_percent) rmtSetCarrier(digitalPinToGPIONumber(pin), carrier_en, carrier_level, frequency_Hz, duty_percent)
|
||||
#define rmtSetEOT(pin, EOT_Level) rmtSetEOT(digitalPinToGPIONumber(pin), EOT_Level)
|
||||
#define rmtWrite(pin, data, num_rmt_symbols, timeout_ms) rmtWrite(digitalPinToGPIONumber(pin), data, num_rmt_symbols, timeout_ms)
|
||||
#define rmtWriteAsync(pin, data, num_rmt_symbols) rmtWriteAsync(digitalPinToGPIONumber(pin), data, num_rmt_symbols)
|
||||
#define rmtWriteLooping(pin, data, num_rmt_symbols) rmtWriteLooping(digitalPinToGPIONumber(pin), data, num_rmt_symbols)
|
||||
#define rmtTransmitCompleted(pin) rmtTransmitCompleted(digitalPinToGPIONumber(pin))
|
||||
#define rmtRead(pin, data, num_rmt_symbols, timeout_ms) rmtRead(digitalPinToGPIONumber(pin), data, num_rmt_symbols, timeout_ms)
|
||||
#define rmtReadAsync(pin, data, num_rmt_symbols) rmtReadAsync(digitalPinToGPIONumber(pin), data, num_rmt_symbols)
|
||||
#define rmtReceiveCompleted(pin) rmtReceiveCompleted(digitalPinToGPIONumber(pin))
|
||||
#define rmtSetRxMaxThreshold(pin, idle_thres_ticks) rmtSetRxMaxThreshold(digitalPinToGPIONumber(pin), idle_thres_ticks)
|
||||
#define rmtSetCarrier(pin, carrier_en, carrier_level, frequency_Hz, duty_percent) \
|
||||
rmtSetCarrier(digitalPinToGPIONumber(pin), carrier_en, carrier_level, frequency_Hz, duty_percent)
|
||||
#define rmtSetRxMinThreshold(pin, filter_pulse_ticks) rmtSetRxMinThreshold(digitalPinToGPIONumber(pin), filter_pulse_ticks)
|
||||
#define rmtDeinit(pin) rmtDeinit(digitalPinToGPIONumber(pin))
|
||||
#define rmtDeinit(pin) rmtDeinit(digitalPinToGPIONumber(pin))
|
||||
|
||||
// cores/esp32/esp32-hal-sigmadelta.h
|
||||
#define sigmaDeltaAttach(pin, freq) sigmaDeltaAttach(digitalPinToGPIONumber(pin), freq)
|
||||
#define sigmaDeltaWrite(pin, duty) sigmaDeltaWrite(digitalPinToGPIONumber(pin), duty)
|
||||
#define sigmaDeltaDetach(pin) sigmaDeltaDetach(digitalPinToGPIONumber(pin))
|
||||
#define sigmaDeltaWrite(pin, duty) sigmaDeltaWrite(digitalPinToGPIONumber(pin), duty)
|
||||
#define sigmaDeltaDetach(pin) sigmaDeltaDetach(digitalPinToGPIONumber(pin))
|
||||
|
||||
// cores/esp32/esp32-hal-spi.h
|
||||
#define spiAttachSCK(spi, sck) spiAttachSCK(spi, digitalPinToGPIONumber(sck))
|
||||
#define spiAttachMISO(spi, miso) spiAttachMISO(spi, digitalPinToGPIONumber(miso))
|
||||
#define spiAttachMOSI(spi, mosi) spiAttachMOSI(spi, digitalPinToGPIONumber(mosi))
|
||||
#define spiAttachSCK(spi, sck) spiAttachSCK(spi, digitalPinToGPIONumber(sck))
|
||||
#define spiAttachMISO(spi, miso) spiAttachMISO(spi, digitalPinToGPIONumber(miso))
|
||||
#define spiAttachMOSI(spi, mosi) spiAttachMOSI(spi, digitalPinToGPIONumber(mosi))
|
||||
#define spiAttachSS(spi, cs_num, ss) spiAttachSS(spi, cs_num, digitalPinToGPIONumber(ss))
|
||||
|
||||
// cores/esp32/esp32-hal-touch.h
|
||||
#define touchInterruptGetLastStatus(pin) touchInterruptGetLastStatus(digitalPinToGPIONumber(pin))
|
||||
#define touchRead(pin) touchRead(digitalPinToGPIONumber(pin))
|
||||
#define touchInterruptGetLastStatus(pin) touchInterruptGetLastStatus(digitalPinToGPIONumber(pin))
|
||||
#define touchRead(pin) touchRead(digitalPinToGPIONumber(pin))
|
||||
#define touchAttachInterruptArg(pin, userFunc, arg, threshold) touchAttachInterruptArg(digitalPinToGPIONumber(pin), userFunc, arg, threshold)
|
||||
#define touchAttachInterrupt(pin, userFunc, threshold) touchAttachInterrupt(digitalPinToGPIONumber(pin), userFunc, threshold)
|
||||
#define touchDetachInterrupt(pin) touchDetachInterrupt(digitalPinToGPIONumber(pin))
|
||||
#define touchSleepWakeUpEnable(pin, threshold) touchSleepWakeUpEnable(digitalPinToGPIONumber(pin), threshold)
|
||||
#define touchAttachInterrupt(pin, userFunc, threshold) touchAttachInterrupt(digitalPinToGPIONumber(pin), userFunc, threshold)
|
||||
#define touchDetachInterrupt(pin) touchDetachInterrupt(digitalPinToGPIONumber(pin))
|
||||
#define touchSleepWakeUpEnable(pin, threshold) touchSleepWakeUpEnable(digitalPinToGPIONumber(pin), threshold)
|
||||
|
||||
// cores/esp32/esp32-hal-uart.h
|
||||
#define uartBegin(uart_nr, baudrate, config, rxPin, txPin, rx_buffer_size, tx_buffer_size, inverted, rxfifo_full_thrhd) \
|
||||
uartBegin(uart_nr, baudrate, config, digitalPinToGPIONumber(rxPin), digitalPinToGPIONumber(txPin), rx_buffer_size, tx_buffer_size, inverted, rxfifo_full_thrhd)
|
||||
#define uartBegin(uart_nr, baudrate, config, rxPin, txPin, rx_buffer_size, tx_buffer_size, inverted, rxfifo_full_thrhd) \
|
||||
uartBegin( \
|
||||
uart_nr, baudrate, config, digitalPinToGPIONumber(rxPin), digitalPinToGPIONumber(txPin), rx_buffer_size, tx_buffer_size, inverted, rxfifo_full_thrhd \
|
||||
)
|
||||
#define uartSetPins(uart, rxPin, txPin, ctsPin, rtsPin) \
|
||||
uartSetPins(uart, digitalPinToGPIONumber(rxPin), digitalPinToGPIONumber(txPin), digitalPinToGPIONumber(ctsPin), digitalPinToGPIONumber(rtsPin))
|
||||
#define uartDetachPins(uart, rxPin, txPin, ctsPin, rtsPin) \
|
||||
|
@ -9,21 +9,25 @@ For details, see http://sourceforge.net/projects/libb64
|
||||
#include <stdint.h>
|
||||
|
||||
static int base64_decode_value_signed(int8_t value_in) {
|
||||
static const int8_t decoding[] = { 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 };
|
||||
static const int8_t decoding[] = {62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1, -1, 0, 1, 2, 3, 4,
|
||||
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1,
|
||||
26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51};
|
||||
static const int8_t decoding_size = sizeof(decoding);
|
||||
value_in -= 43;
|
||||
if (value_in < 0 || value_in >= decoding_size) return -1;
|
||||
if (value_in < 0 || value_in >= decoding_size) {
|
||||
return -1;
|
||||
}
|
||||
return decoding[(int)value_in];
|
||||
}
|
||||
|
||||
void base64_init_decodestate(base64_decodestate* state_in) {
|
||||
void base64_init_decodestate(base64_decodestate *state_in) {
|
||||
state_in->step = step_a;
|
||||
state_in->plainchar = 0;
|
||||
}
|
||||
|
||||
static int base64_decode_block_signed(const int8_t* code_in, const int length_in, int8_t* plaintext_out, base64_decodestate* state_in) {
|
||||
const int8_t* codechar = code_in;
|
||||
int8_t* plainchar = plaintext_out;
|
||||
static int base64_decode_block_signed(const int8_t *code_in, const int length_in, int8_t *plaintext_out, base64_decodestate *state_in) {
|
||||
const int8_t *codechar = code_in;
|
||||
int8_t *plainchar = plaintext_out;
|
||||
int8_t fragment;
|
||||
|
||||
*plainchar = state_in->plainchar;
|
||||
@ -81,22 +85,24 @@ static int base64_decode_block_signed(const int8_t* code_in, const int length_in
|
||||
return plainchar - plaintext_out;
|
||||
}
|
||||
|
||||
static int base64_decode_chars_signed(const int8_t* code_in, const int length_in, int8_t* plaintext_out) {
|
||||
static int base64_decode_chars_signed(const int8_t *code_in, const int length_in, int8_t *plaintext_out) {
|
||||
base64_decodestate _state;
|
||||
base64_init_decodestate(&_state);
|
||||
int len = base64_decode_block_signed(code_in, length_in, plaintext_out, &_state);
|
||||
if (len > 0) plaintext_out[len] = 0;
|
||||
if (len > 0) {
|
||||
plaintext_out[len] = 0;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
int base64_decode_value(char value_in) {
|
||||
return base64_decode_value_signed(*((int8_t*)&value_in));
|
||||
return base64_decode_value_signed(*((int8_t *)&value_in));
|
||||
}
|
||||
|
||||
int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in) {
|
||||
return base64_decode_block_signed((int8_t*)code_in, length_in, (int8_t*)plaintext_out, state_in);
|
||||
int base64_decode_block(const char *code_in, const int length_in, char *plaintext_out, base64_decodestate *state_in) {
|
||||
return base64_decode_block_signed((int8_t *)code_in, length_in, (int8_t *)plaintext_out, state_in);
|
||||
}
|
||||
|
||||
int base64_decode_chars(const char* code_in, const int length_in, char* plaintext_out) {
|
||||
return base64_decode_chars_signed((int8_t*)code_in, length_in, (int8_t*)plaintext_out);
|
||||
int base64_decode_chars(const char *code_in, const int length_in, char *plaintext_out) {
|
||||
return base64_decode_chars_signed((int8_t *)code_in, length_in, (int8_t *)plaintext_out);
|
||||
}
|
||||
|
@ -14,25 +14,25 @@ For details, see http://sourceforge.net/projects/libb64
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
step_a,
|
||||
step_b,
|
||||
step_c,
|
||||
step_d
|
||||
} base64_decodestep;
|
||||
typedef enum {
|
||||
step_a,
|
||||
step_b,
|
||||
step_c,
|
||||
step_d
|
||||
} base64_decodestep;
|
||||
|
||||
typedef struct {
|
||||
base64_decodestep step;
|
||||
char plainchar;
|
||||
} base64_decodestate;
|
||||
typedef struct {
|
||||
base64_decodestep step;
|
||||
char plainchar;
|
||||
} base64_decodestate;
|
||||
|
||||
void base64_init_decodestate(base64_decodestate* state_in);
|
||||
void base64_init_decodestate(base64_decodestate *state_in);
|
||||
|
||||
int base64_decode_value(char value_in);
|
||||
int base64_decode_value(char value_in);
|
||||
|
||||
int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in);
|
||||
int base64_decode_block(const char *code_in, const int length_in, char *plaintext_out, base64_decodestate *state_in);
|
||||
|
||||
int base64_decode_chars(const char* code_in, const int length_in, char* plaintext_out);
|
||||
int base64_decode_chars(const char *code_in, const int length_in, char *plaintext_out);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
|
@ -7,23 +7,23 @@ For details, see http://sourceforge.net/projects/libb64
|
||||
|
||||
#include "cencode.h"
|
||||
|
||||
void base64_init_encodestate(base64_encodestate* state_in) {
|
||||
void base64_init_encodestate(base64_encodestate *state_in) {
|
||||
state_in->step = step_A;
|
||||
state_in->result = 0;
|
||||
}
|
||||
|
||||
char base64_encode_value(char value_in) {
|
||||
static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
static const char *encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
if (value_in > 63) {
|
||||
return '=';
|
||||
}
|
||||
return encoding[(int)value_in];
|
||||
}
|
||||
|
||||
int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in) {
|
||||
const char* plainchar = plaintext_in;
|
||||
const char* const plaintextend = plaintext_in + length_in;
|
||||
char* codechar = code_out;
|
||||
int base64_encode_block(const char *plaintext_in, int length_in, char *code_out, base64_encodestate *state_in) {
|
||||
const char *plainchar = plaintext_in;
|
||||
const char *const plaintextend = plaintext_in + length_in;
|
||||
char *codechar = code_out;
|
||||
char result;
|
||||
char fragment;
|
||||
|
||||
@ -70,8 +70,8 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
|
||||
return codechar - code_out;
|
||||
}
|
||||
|
||||
int base64_encode_blockend(char* code_out, base64_encodestate* state_in) {
|
||||
char* codechar = code_out;
|
||||
int base64_encode_blockend(char *code_out, base64_encodestate *state_in) {
|
||||
char *codechar = code_out;
|
||||
|
||||
switch (state_in->step) {
|
||||
case step_B:
|
||||
@ -83,15 +83,14 @@ int base64_encode_blockend(char* code_out, base64_encodestate* state_in) {
|
||||
*codechar++ = base64_encode_value(state_in->result);
|
||||
*codechar++ = '=';
|
||||
break;
|
||||
case step_A:
|
||||
break;
|
||||
case step_A: break;
|
||||
}
|
||||
*codechar = 0x00;
|
||||
|
||||
return codechar - code_out;
|
||||
}
|
||||
|
||||
int base64_encode_chars(const char* plaintext_in, int length_in, char* code_out) {
|
||||
int base64_encode_chars(const char *plaintext_in, int length_in, char *code_out) {
|
||||
base64_encodestate _state;
|
||||
base64_init_encodestate(&_state);
|
||||
int len = base64_encode_block(plaintext_in, length_in, code_out, &_state);
|
||||
|
@ -14,27 +14,27 @@ For details, see http://sourceforge.net/projects/libb64
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
step_A,
|
||||
step_B,
|
||||
step_C
|
||||
} base64_encodestep;
|
||||
typedef enum {
|
||||
step_A,
|
||||
step_B,
|
||||
step_C
|
||||
} base64_encodestep;
|
||||
|
||||
typedef struct {
|
||||
base64_encodestep step;
|
||||
char result;
|
||||
int stepcount;
|
||||
} base64_encodestate;
|
||||
typedef struct {
|
||||
base64_encodestep step;
|
||||
char result;
|
||||
int stepcount;
|
||||
} base64_encodestate;
|
||||
|
||||
void base64_init_encodestate(base64_encodestate* state_in);
|
||||
void base64_init_encodestate(base64_encodestate *state_in);
|
||||
|
||||
char base64_encode_value(char value_in);
|
||||
char base64_encode_value(char value_in);
|
||||
|
||||
int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in);
|
||||
int base64_encode_block(const char *plaintext_in, int length_in, char *code_out, base64_encodestate *state_in);
|
||||
|
||||
int base64_encode_blockend(char* code_out, base64_encodestate* state_in);
|
||||
int base64_encode_blockend(char *code_out, base64_encodestate *state_in);
|
||||
|
||||
int base64_encode_chars(const char* plaintext_in, int length_in, char* code_out);
|
||||
int base64_encode_chars(const char *plaintext_in, int length_in, char *code_out);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
|
@ -71,7 +71,9 @@ void loopTask(void *pvParameters) {
|
||||
esp_task_wdt_reset();
|
||||
}
|
||||
loop();
|
||||
if (serialEventRun) serialEventRun();
|
||||
if (serialEventRun) {
|
||||
serialEventRun();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -30,60 +30,64 @@ typedef long prog_int32_t;
|
||||
typedef unsigned long prog_uint32_t;
|
||||
|
||||
#define PROGMEM
|
||||
#define PGM_P const char *
|
||||
#define PGM_VOID_P const void *
|
||||
#define PSTR(s) (s)
|
||||
#define PGM_P const char *
|
||||
#define PGM_VOID_P const void *
|
||||
#define PSTR(s) (s)
|
||||
#define _SFR_BYTE(n) (n)
|
||||
|
||||
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
|
||||
#define pgm_read_word(addr) ({ \
|
||||
typeof(addr) _addr = (addr); \
|
||||
*(const unsigned short *)(_addr); \
|
||||
})
|
||||
#define pgm_read_dword(addr) ({ \
|
||||
typeof(addr) _addr = (addr); \
|
||||
*(const unsigned long *)(_addr); \
|
||||
})
|
||||
#define pgm_read_float(addr) ({ \
|
||||
typeof(addr) _addr = (addr); \
|
||||
*(const float *)(_addr); \
|
||||
})
|
||||
#define pgm_read_ptr(addr) ({ \
|
||||
typeof(addr) _addr = (addr); \
|
||||
*(void *const *)(_addr); \
|
||||
})
|
||||
#define pgm_read_word(addr) \
|
||||
({ \
|
||||
typeof(addr) _addr = (addr); \
|
||||
*(const unsigned short *)(_addr); \
|
||||
})
|
||||
#define pgm_read_dword(addr) \
|
||||
({ \
|
||||
typeof(addr) _addr = (addr); \
|
||||
*(const unsigned long *)(_addr); \
|
||||
})
|
||||
#define pgm_read_float(addr) \
|
||||
({ \
|
||||
typeof(addr) _addr = (addr); \
|
||||
*(const float *)(_addr); \
|
||||
})
|
||||
#define pgm_read_ptr(addr) \
|
||||
({ \
|
||||
typeof(addr) _addr = (addr); \
|
||||
*(void *const *)(_addr); \
|
||||
})
|
||||
|
||||
#define pgm_get_far_address(x) ((uint32_t)(&(x)))
|
||||
|
||||
#define pgm_read_byte_near(addr) pgm_read_byte(addr)
|
||||
#define pgm_read_word_near(addr) pgm_read_word(addr)
|
||||
#define pgm_read_byte_near(addr) pgm_read_byte(addr)
|
||||
#define pgm_read_word_near(addr) pgm_read_word(addr)
|
||||
#define pgm_read_dword_near(addr) pgm_read_dword(addr)
|
||||
#define pgm_read_float_near(addr) pgm_read_float(addr)
|
||||
#define pgm_read_ptr_near(addr) pgm_read_ptr(addr)
|
||||
#define pgm_read_byte_far(addr) pgm_read_byte(addr)
|
||||
#define pgm_read_word_far(addr) pgm_read_word(addr)
|
||||
#define pgm_read_dword_far(addr) pgm_read_dword(addr)
|
||||
#define pgm_read_float_far(addr) pgm_read_float(addr)
|
||||
#define pgm_read_ptr_far(addr) pgm_read_ptr(addr)
|
||||
#define pgm_read_ptr_near(addr) pgm_read_ptr(addr)
|
||||
#define pgm_read_byte_far(addr) pgm_read_byte(addr)
|
||||
#define pgm_read_word_far(addr) pgm_read_word(addr)
|
||||
#define pgm_read_dword_far(addr) pgm_read_dword(addr)
|
||||
#define pgm_read_float_far(addr) pgm_read_float(addr)
|
||||
#define pgm_read_ptr_far(addr) pgm_read_ptr(addr)
|
||||
|
||||
#define memcmp_P memcmp
|
||||
#define memccpy_P memccpy
|
||||
#define memmem_P memmem
|
||||
#define memcpy_P memcpy
|
||||
#define strcpy_P strcpy
|
||||
#define strncpy_P strncpy
|
||||
#define strcat_P strcat
|
||||
#define strncat_P strncat
|
||||
#define strcmp_P strcmp
|
||||
#define strncmp_P strncmp
|
||||
#define strcasecmp_P strcasecmp
|
||||
#define memcmp_P memcmp
|
||||
#define memccpy_P memccpy
|
||||
#define memmem_P memmem
|
||||
#define memcpy_P memcpy
|
||||
#define strcpy_P strcpy
|
||||
#define strncpy_P strncpy
|
||||
#define strcat_P strcat
|
||||
#define strncat_P strncat
|
||||
#define strcmp_P strcmp
|
||||
#define strncmp_P strncmp
|
||||
#define strcasecmp_P strcasecmp
|
||||
#define strncasecmp_P strncasecmp
|
||||
#define strlen_P strlen
|
||||
#define strnlen_P strnlen
|
||||
#define strstr_P strstr
|
||||
#define printf_P printf
|
||||
#define sprintf_P sprintf
|
||||
#define snprintf_P snprintf
|
||||
#define vsnprintf_P vsnprintf
|
||||
#define strlen_P strlen
|
||||
#define strnlen_P strnlen
|
||||
#define strstr_P strstr
|
||||
#define printf_P printf
|
||||
#define sprintf_P sprintf
|
||||
#define snprintf_P snprintf
|
||||
#define vsnprintf_P vsnprintf
|
||||
|
||||
#endif
|
||||
|
@ -30,9 +30,9 @@
|
||||
#include "stdlib_noniso.h"
|
||||
#include "esp_system.h"
|
||||
|
||||
static void reverse(char* begin, char* end) {
|
||||
char* is = begin;
|
||||
char* ie = end - 1;
|
||||
static void reverse(char *begin, char *end) {
|
||||
char *is = begin;
|
||||
char *ie = end - 1;
|
||||
while (is < ie) {
|
||||
char tmp = *ie;
|
||||
*ie = *is;
|
||||
@ -42,13 +42,13 @@ static void reverse(char* begin, char* end) {
|
||||
}
|
||||
}
|
||||
|
||||
char* ltoa(long value, char* result, int base) {
|
||||
char *ltoa(long value, char *result, int base) {
|
||||
if (base < 2 || base > 16) {
|
||||
*result = 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
char* out = result;
|
||||
char *out = result;
|
||||
long quotient = abs(value);
|
||||
|
||||
do {
|
||||
@ -59,21 +59,22 @@ char* ltoa(long value, char* result, int base) {
|
||||
} while (quotient);
|
||||
|
||||
// Apply negative sign
|
||||
if (value < 0)
|
||||
if (value < 0) {
|
||||
*out++ = '-';
|
||||
}
|
||||
|
||||
reverse(result, out);
|
||||
*out = 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
char* lltoa(long long val, char* result, int base) {
|
||||
char *lltoa(long long val, char *result, int base) {
|
||||
if (base < 2 || base > 16) {
|
||||
*result = 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
char* out = result;
|
||||
char *out = result;
|
||||
long long quotient = val > 0 ? val : -val;
|
||||
|
||||
do {
|
||||
@ -84,21 +85,22 @@ char* lltoa(long long val, char* result, int base) {
|
||||
} while (quotient);
|
||||
|
||||
// Apply negative sign
|
||||
if (val < 0)
|
||||
if (val < 0) {
|
||||
*out++ = '-';
|
||||
}
|
||||
|
||||
reverse(result, out);
|
||||
*out = 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
char* ultoa(unsigned long value, char* result, int base) {
|
||||
char *ultoa(unsigned long value, char *result, int base) {
|
||||
if (base < 2 || base > 16) {
|
||||
*result = 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
char* out = result;
|
||||
char *out = result;
|
||||
unsigned long quotient = value;
|
||||
|
||||
do {
|
||||
@ -113,13 +115,13 @@ char* ultoa(unsigned long value, char* result, int base) {
|
||||
return result;
|
||||
}
|
||||
|
||||
char* ulltoa(unsigned long long val, char* result, int base) {
|
||||
char *ulltoa(unsigned long long val, char *result, int base) {
|
||||
if (base < 2 || base > 16) {
|
||||
*result = 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
char* out = result;
|
||||
char *out = result;
|
||||
unsigned long long quotient = val;
|
||||
|
||||
do {
|
||||
@ -134,7 +136,7 @@ char* ulltoa(unsigned long long val, char* result, int base) {
|
||||
return result;
|
||||
}
|
||||
|
||||
char* dtostrf(double number, signed int width, unsigned int prec, char* s) {
|
||||
char *dtostrf(double number, signed int width, unsigned int prec, char *s) {
|
||||
bool negative = false;
|
||||
|
||||
if (isnan(number)) {
|
||||
@ -146,7 +148,7 @@ char* dtostrf(double number, signed int width, unsigned int prec, char* s) {
|
||||
return s;
|
||||
}
|
||||
|
||||
char* out = s;
|
||||
char *out = s;
|
||||
|
||||
int fillme = width; // how many cells to fill for the integer part
|
||||
if (prec > 0) {
|
||||
@ -163,8 +165,9 @@ char* dtostrf(double number, signed int width, unsigned int prec, char* s) {
|
||||
// Round correctly so that print(1.999, 2) prints as "2.00"
|
||||
// I optimized out most of the divisions
|
||||
double rounding = 2.0;
|
||||
for (unsigned int i = 0; i < prec; ++i)
|
||||
for (unsigned int i = 0; i < prec; ++i) {
|
||||
rounding *= 10.0;
|
||||
}
|
||||
rounding = 1.0 / rounding;
|
||||
|
||||
number += rounding;
|
||||
@ -186,14 +189,18 @@ char* dtostrf(double number, signed int width, unsigned int prec, char* s) {
|
||||
}
|
||||
|
||||
// Handle negative sign
|
||||
if (negative) *out++ = '-';
|
||||
if (negative) {
|
||||
*out++ = '-';
|
||||
}
|
||||
|
||||
// Print the digits, and if necessary, the decimal point
|
||||
digitcount += prec;
|
||||
int8_t digit = 0;
|
||||
while (digitcount-- > 0) {
|
||||
digit = (int8_t)number;
|
||||
if (digit > 9) digit = 9; // insurance
|
||||
if (digit > 9) {
|
||||
digit = 9; // insurance
|
||||
}
|
||||
*out++ = (char)('0' | digit);
|
||||
if ((digitcount == prec) && (prec > 0)) {
|
||||
*out++ = '.';
|
||||
|
@ -25,29 +25,28 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
int atoi(const char* s);
|
||||
int atoi(const char *s);
|
||||
|
||||
long atol(const char* s);
|
||||
long atol(const char *s);
|
||||
|
||||
double atof(const char* s);
|
||||
double atof(const char *s);
|
||||
|
||||
char* itoa(int val, char* s, int radix);
|
||||
char *itoa(int val, char *s, int radix);
|
||||
|
||||
char* ltoa(long val, char* s, int radix);
|
||||
char *ltoa(long val, char *s, int radix);
|
||||
|
||||
char* lltoa(long long val, char* s, int radix);
|
||||
char *lltoa(long long val, char *s, int radix);
|
||||
|
||||
char* utoa(unsigned int val, char* s, int radix);
|
||||
char *utoa(unsigned int val, char *s, int radix);
|
||||
|
||||
char* ultoa(unsigned long val, char* s, int radix);
|
||||
char *ultoa(unsigned long val, char *s, int radix);
|
||||
|
||||
char* ulltoa(unsigned long long val, char* s, int radix);
|
||||
char *ulltoa(unsigned long long val, char *s, int radix);
|
||||
|
||||
char* dtostrf(double val, signed int width, unsigned int prec, char* s);
|
||||
char *dtostrf(double val, signed int width, unsigned int prec, char *s);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
|
@ -34,9 +34,9 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef void (*voidFuncPtr)(void);
|
||||
typedef void (*voidFuncPtr)(void);
|
||||
|
||||
void initPins();
|
||||
void initPins();
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user