refactor(style): Change some style options (#9526)

* refactor(style): Change some style options

* refactor(style): Apply style changes

.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
+AlignConsecutiveAssignments:
-AlignConsecutiveBitFields: None
+  Enabled: false
-AlignConsecutiveDeclarations: None
+  AcrossEmptyLines: false
-AlignConsecutiveMacros: None
+  AcrossComments: false
-AlignEscapedNewlines: DontAlign
+  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
+BreakBeforeBraces: Custom
-BreakBeforeConceptDeclarations: false
+BreakBeforeConceptDeclarations: Always
-BreakBeforeInheritanceComma: false
+BreakBeforeInlineASMColon: OnlyMultiline
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializers: BeforeColon
-BreakConstructorInitializersBeforeComma: false
 BreakInheritanceList: BeforeColon
-BreakStringLiterals: false
+BreakStringLiterals: true
-ColumnLimit: 0
+ColumnLimit: 160
-CommentPragmas: ''
+CommentPragmas: ""
 CompactNamespaces: false
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
 ConstructorInitializerIndentWidth: 2
 ContinuationIndentWidth: 2
-Cpp11BracedListStyle: false
+Cpp11BracedListStyle: true
-DeriveLineEnding: true
+DerivePointerAlignment: false
-DerivePointerAlignment: true
 DisableFormat: false
-EmptyLineAfterAccessModifier: Leave
+EmptyLineAfterAccessModifier: Never
-EmptyLineBeforeAccessModifier: Leave
+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: ''
+IncludeIsMainRegex: ""
-IncludeIsMainSourceRegex: ''
+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: ''
+LineEnding: LF
-MacroBlockEnd: ''
+MacroBlockBegin: ""
-MaxEmptyLinesToKeep: 100000
+MacroBlockEnd: ""
+MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
 ObjCBinPackProtocolList: Auto
 ObjCBlockIndentWidth: 2
@@ -121,26 +164,32 @@ ObjCSpaceAfterProperty: false
 ObjCSpaceBeforeProtocolList: true
 PPIndentWidth: -1
 PackConstructorInitializers: BinPack
-PenaltyBreakAssignment: 1
+PenaltyBreakAssignment: 2
-PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakBeforeFirstCallParameter: 19
-PenaltyBreakComment: 1
+PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 1
+PenaltyBreakFirstLessLess: 120
-PenaltyBreakOpenParenthesis: 1
+PenaltyBreakOpenParenthesis: 0
-PenaltyBreakString: 1
+PenaltyBreakScopeResolution: 500
-PenaltyBreakTemplateDeclaration: 1
+PenaltyBreakString: 1000
-PenaltyExcessCharacter: 1
+PenaltyBreakTemplateDeclaration: 10
-PenaltyIndentedWhitespace: 1
+PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 1
+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
+SpacesInAngles: Never
-SpacesInCStyleCastParentheses: false
-SpacesInConditionalStatement: false
 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

.pre-commit-config.yaml

@@ -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++]

cores/esp32/Arduino.h

@@ -41,29 +41,29 @@
 #include "binary.h"
 #include "extra_attr.h"
 
-#define PI 3.1415926535897932384626433832795
+#define PI         3.1415926535897932384626433832795
-#define HALF_PI 1.5707963267948966192313216916398
+#define HALF_PI    1.5707963267948966192313216916398
-#define TWO_PI 6.283185307179586476925286766559
+#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 RISING    0x01
-#define FALLING 0x02
+#define FALLING   0x02
-#define CHANGE 0x03
+#define CHANGE    0x03
-#define ONLOW 0x04
+#define ONLOW     0x04
-#define ONHIGH 0x05
+#define ONHIGH    0x05
-#define ONLOW_WE 0x0C
+#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 _min(a, b)                ((a) < (b) ? (a) : (b))
-#define _max(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 _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 _round(x)                 ((x) >= 0 ? (long)((x) + 0.5) : (long)((x) - 0.5))  // round() comes from STL
-#define radians(deg) ((deg)*DEG_TO_RAD)
+#define radians(deg)              ((deg) * DEG_TO_RAD)
-#define degrees(rad) ((rad)*RAD_TO_DEG)
+#define degrees(rad)              ((rad) * RAD_TO_DEG)
-#define sq(x) ((x) * (x))
+#define sq(x)                     ((x) * (x))
 
 // ESP32xx runs FreeRTOS... disabling interrupts can lead to issues, such as Watchdog Timeout
-#define sei() portENABLE_INTERRUPTS()
+#define sei()          portENABLE_INTERRUPTS()
-#define cli() portDISABLE_INTERRUPTS()
+#define cli()          portDISABLE_INTERRUPTS()
-#define interrupts() sei()
+#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 bitRead(value, bit)            (((value) >> (bit)) & 0x01)
-#define bitSet(value, bit) ((value) |= (1UL << (bit)))
+#define bitSet(value, bit)             ((value) |= (1UL << (bit)))
-#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
+#define bitClear(value, bit)           ((value) &= ~(1UL << (bit)))
-#define bitToggle(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() \
+#define _NOP()               \
-  do { __asm__ volatile("nop"); } while (0)
+  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 portOutputRegister(port) ((volatile uint32_t *)GPIO_OUT_REG)
-#define portInputRegister(port) ((volatile uint32_t*)GPIO_IN_REG)
+#define portInputRegister(port)  ((volatile uint32_t *)GPIO_IN_REG)
-#define portModeRegister(port) ((volatile uint32_t*)GPIO_ENABLE_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 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 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 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_PIN        -1
-#define NOT_A_PORT -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 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 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 init(void);
-  void initVariant(void);
+void initVariant(void);
-  void initArduino(void);
+void initArduino(void);
 
-  unsigned long pulseIn(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);
+unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout);
 
-  uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder);
+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);
+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) \
+#define SET_LOOP_TASK_STACK_SIZE(sz)     \
-  size_t getArduinoLoopTaskStackSize() { return sz; }
+  size_t getArduinoLoopTaskStackSize() { \
+    return sz;                           \
+  }
 
 bool shouldPrintChipDebugReport(void);
-#define ENABLE_CHIP_DEBUG_REPORT \
+#define ENABLE_CHIP_DEBUG_REPORT          \
-  bool shouldPrintChipDebugReport(void) { return true; }
+  bool shouldPrintChipDebugReport(void) { \
+    return true;                          \
+  }
 
 // allows user to bypass esp_spiram_test()
 bool esp_psram_extram_test(void);
-#define BYPASS_SPIRAM_TEST(bypass) \
+#define BYPASS_SPIRAM_TEST(bypass)    \
-  bool testSPIRAM(void) { \
+  bool testSPIRAM(void) {             \
-    if (bypass) return true; \
+    if (bypass)                       \
-    else return esp_psram_extram_test(); \
+      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" bool getLocalTime(struct tm *info, uint32_t ms = 5000);
-extern "C" void configTime(long gmtOffset_sec, int daylightOffset_sec,
+extern "C" void configTime(long gmtOffset_sec, int daylightOffset_sec, const char *server1, const char *server2 = nullptr, const char *server3 = nullptr);
-                           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" 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);

cores/esp32/Client.h

@@ -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();

cores/esp32/Esp.cpp

@@ -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_ESP32D2WDQ5:   return "ESP32-D2WD";
-    case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD2:
+    case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD2:   return "ESP32-PICO-D2";
-      return "ESP32-PICO-D2";
+    case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD4:   return "ESP32-PICO-D4";
-    case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD4:
+    case EFUSE_RD_CHIP_VER_PKG_ESP32PICOV302: return "ESP32-PICO-V3-02";
-      return "ESP32-PICO-D4";
+    case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDR2V3: return "ESP32-D0WDR2-V3";
-    case EFUSE_RD_CHIP_VER_PKG_ESP32PICOV302:
+    default:                                  return "Unknown";
-      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:
+    case 0:  return "ESP32-S2";
-      return "ESP32-S2";
+    case 1:  return "ESP32-S2FH16";
-    case 1:
+    case 2:  return "ESP32-S2FH32";
-      return "ESP32-S2FH16";
+    default: return "ESP32-S2 (Unknown)";
-    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) {

cores/esp32/Esp.h

@@ -42,7 +42,6 @@ typedef enum {
   WDTO_8S = 8000     //!< WDTO_8S
 } WDTO_t;
 
-
 typedef enum {
   FM_QIO = 0x00,
   FM_QOUT = 0x01,

cores/esp32/FirmwareMSC.cpp

@@ -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()
+FirmwareMSC::FirmwareMSC() : msc() {}
-  : msc() {}
 
 FirmwareMSC::~FirmwareMSC() {
   end();

cores/esp32/FunctionalInterrupt.cpp

@@ -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) {
+void ARDUINO_ISR_ATTR interruptFunctional(void *arg) {
-  InterruptArgStructure* localArg = (InterruptArgStructure*)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) {
+void cleanupFunctional(void *arg) {
-    delete (InterruptArgStructure*)arg;
+  delete (InterruptArgStructure *)arg;
-  }
+}
 }

cores/esp32/HEXBuilder.cpp

@@ -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))
+  return (c >= 'a' && c <= 'f')   ? (c - ((uint8_t)'a' - 0xa))
-                                                             : (c >= '0' && c <= '9') ? (c - (uint8_t)'0')
+         : (c >= 'A' && c <= 'F') ? (c - ((uint8_t)'A' - 0xA))
-                                                                                      : 0x10;  // unknown char is 16
+         : (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);

cores/esp32/HEXBuilder.h

@@ -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, 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, const char *in);
 
-  static String bytes2hex(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);
+  static size_t bytes2hex(char *out, size_t maxlen, const unsigned char *in, size_t len);
 };
 #endif

cores/esp32/HWCDC.cpp

@@ -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,
+      .queue_size = 5, .task_name = "arduino_hw_cdc_events", .task_priority = 5, .task_stack_size = 2048, .task_core_id = tskNO_AFFINITY
-      .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;

cores/esp32/HardwareSerial.cpp

@@ -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_nr(uart_nr), _uart(NULL), _rxBufferSize(256), _txBufferSize(0), _onReceiveCB(NULL), _onReceiveErrorCB(NULL), _onReceiveTimeout(false), _rxTimeout(2),
-    _uart(NULL),
+    _rxFIFOFull(0), _eventTask(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:
+          default: log_w("UART%d unknown event type %d.", uart->_uart_nr, event.type); break;
-            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);
+          }
         }
       }
     }

cores/esp32/HardwareSerial.h

@@ -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);

cores/esp32/HashBuilder.h

@@ -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 uint8_t *data, size_t len) = 0;
-  virtual void add(const char* data) {
+  virtual void add(const char *data) {
-    add((const uint8_t*)data, strlen(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 getBytes(uint8_t *output) = 0;
-  virtual void getChars(char* output) = 0;
+  virtual void getChars(char *output) = 0;
   virtual String toString() = 0;
 };
 

cores/esp32/IPAddress.cpp

@@ -22,8 +22,7 @@
 #include "lwip/netif.h"
 #include "StreamString.h"
 
-IPAddress::IPAddress()
+IPAddress::IPAddress() : IPAddress(IPv4) {}
-  : 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::IPAddress(const uint8_t *address) : IPAddress(IPv4, 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 {
+bool IPAddress::operator==(const IPAddress &addr) const {
-  return (addr._type == _type)
+  return (addr._type == _type) && (memcmp(addr._address.bytes, _address.bytes, sizeof(_address.bytes)) == 0);
-         && (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);

cores/esp32/IPAddress.h

@@ -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(const uint8_t *address);
-  IPAddress(IPType ip_type, const uint8_t* address, uint8_t z = 0);
+  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 char *address);
-  IPAddress(const IPAddress& address);
+  IPAddress(const IPAddress &address);
 
-  bool fromString(const char* address);
+  bool fromString(const char *address);
-  bool fromString(const String& 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 char *address);
-  IPAddress& operator=(const IPAddress& 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);
+  IPAddress(const ip_addr_t *addr);
-  void to_ip_addr_t(ip_addr_t* addr) const;
+  void to_ip_addr_t(ip_addr_t *addr) const;
-  IPAddress& from_ip_addr_t(const ip_addr_t* addr);
+  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 fromString4(const char *address);
-  bool fromString6(const char* address);
+  bool fromString6(const char *address);
 };
 
 extern const IPAddress IN6ADDR_ANY;

cores/esp32/MD5Builder.cpp

@@ -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);
 }
 

cores/esp32/MD5Builder.h

@@ -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 getBytes(uint8_t *output) override;
-  void getChars(char* output) override;
+  void getChars(char *output) override;
   String toString(void) override;
 };
 

cores/esp32/MacAddress.cpp

@@ -3,8 +3,7 @@
 #include <Print.h>
 
 //Default constructor, blank mac address.
-MacAddress::MacAddress()
+MacAddress::MacAddress() : MacAddress(MAC6) {}
-  : 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",
+    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]);
-                   _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",
+    return sprintf(
-                   _mac.bytes[0], _mac.bytes[1], _mac.bytes[2],
+      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[3], _mac.bytes[4], _mac.bytes[5],
+      _mac.bytes[7]
-                   _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",
+    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]);
-             _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",
+    snprintf(
-             _mac.bytes[0], _mac.bytes[1], _mac.bytes[2],
+      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[3], _mac.bytes[4], _mac.bytes[5],
+      _mac.bytes[6], _mac.bytes[7]
-             _mac.bytes[6], _mac.bytes[7]);
+    );
   }
   return String(buf);
 }

cores/esp32/MacAddress.h

@@ -50,10 +50,8 @@ public:
   MacAddress(MACType mac_type, const uint8_t *macbytearray);
 
   //Default MAC6
-  MacAddress(uint64_t mac)
+  MacAddress(uint64_t mac) : MacAddress(MAC6, mac) {}
-    : MacAddress(MAC6, mac) {}
+  MacAddress(const uint8_t *macbytearray) : MacAddress(MAC6, macbytearray) {}
-  MacAddress(const uint8_t *macbytearray)
-    : MacAddress(MAC6, macbytearray) {}
 
   MacAddress(const char *macstr);
   MacAddress(const String &macstr);

cores/esp32/Print.h

@@ -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()
+  Print() : write_error(0) {}
-    : 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

cores/esp32/Printable.h

@@ -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

cores/esp32/SHA1Builder.cpp

@@ -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) \
+#define PUT_UINT32_BE(n, b, i)           \
-  { \
+  {                                      \
-    (b)[(i)] = (uint8_t)((n) >> 24); \
+    (b)[(i)] = (uint8_t)((n) >> 24);     \
     (b)[(i) + 1] = (uint8_t)((n) >> 16); \
-    (b)[(i) + 2] = (uint8_t)((n) >> 8); \
+    (b)[(i) + 2] = (uint8_t)((n) >> 8);  \
-    (b)[(i) + 3] = (uint8_t)((n)); \
+    (b)[(i) + 3] = (uint8_t)((n));       \
   }
 #endif
 
 // Constants
 
-static const uint8_t sha1_padding[64] = {
+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,
-  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,
-  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) \
+#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)))
-  ( \
-    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);
 }
 

cores/esp32/SHA1Builder.h

@@ -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 getBytes(uint8_t *output) override;
-  void getChars(char* output) override;
+  void getChars(char *output) override;
   String toString() override;
 };
 

cores/esp32/Stream.cpp

@@ -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

cores/esp32/Stream.h

@@ -48,8 +48,7 @@ public:
   virtual int read() = 0;
   virtual int peek() = 0;
 
-  Stream()
+  Stream() : _startMillis(0) {
-    : _startMillis(0) {
     _timeout = 1000;
   }
   virtual ~Stream() {}

cores/esp32/StreamString.cpp

@@ -61,5 +61,4 @@ int StreamString::peek() {
   return -1;
 }
 
-void StreamString::flush() {
+void StreamString::flush() {}
-}

cores/esp32/StreamString.h

@@ -35,5 +35,4 @@ public:
   void flush() override;
 };
 
-
 #endif /* STREAMSTRING_H_ */

cores/esp32/Tone.cpp

@@ -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
+    }  // switch
-  }              // infinite loop
+  }  // infinite loop
 }
 
 static int tone_init() {

cores/esp32/USB.cpp

@@ -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] = {
+  uint8_t descriptor[TUD_DFU_RT_DESC_LEN] = {// Interface number, string index, attributes, detach timeout, transfer size */
-    // Interface number, string index, attributes, detach timeout, transfer size */
+                                             TUD_DFU_RT_DESCRIPTOR(*itf, str_index, DFU_ATTRS, 700, 64)
-    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,

cores/esp32/USB.h

@@ -79,17 +79,17 @@ public:
   bool webUSB(bool enabled);
   bool webUSB(void);
 
-  bool productName(const char* name);
+  bool productName(const char *name);
-  const char* productName(void);
+  const char *productName(void);
 
-  bool manufacturerName(const char* name);
+  bool manufacturerName(const char *name);
-  const char* manufacturerName(void);
+  const char *manufacturerName(void);
 
-  bool serialNumber(const char* name);
+  bool serialNumber(const char *name);
-  const char* serialNumber(void);
+  const char *serialNumber(void);
 
-  bool webUSBURL(const char* name);
+  bool webUSBURL(const char *name);
-  const char* webUSBURL(void);
+  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 */

cores/esp32/USBCDC.cpp

@@ -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] = {
+  uint8_t descriptor[TUD_CDC_DESC_LEN] = {// Interface number, string index, EP notification address and size, EP data address (out, in) and size.
-    // 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)
-    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,
+enum {
-       CDC_LINE_1,
+  CDC_LINE_IDLE,
-       CDC_LINE_2,
+  CDC_LINE_1,
-       CDC_LINE_3 };
+  CDC_LINE_2,
+  CDC_LINE_3
+};
 void USBCDC::_onLineState(bool _dtr, bool _rts) {
   static uint8_t lineState = CDC_LINE_IDLE;
 

cores/esp32/USBCDC.h

@@ -140,6 +140,5 @@ protected:
 extern USBCDC USBSerial;
 #endif
 
-
 #endif /* CONFIG_TINYUSB_CDC_ENABLED */
 #endif /* SOC_USB_OTG_SUPPORTED */

cores/esp32/USBMSC.cpp

@@ -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] = {
+  uint8_t descriptor[TUD_MSC_DESC_LEN] = {// Interface number, string index, EP Out & EP In address, EP size
-    // 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)
-    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 (*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 (*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);
 }
 

cores/esp32/USBMSC.h

@@ -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 vendorID(const char *vid);         //max 8 chars
-  void productID(const char* pid);        //max 16 chars
+  void productID(const char *pid);        //max 16 chars
-  void productRevision(const char* ver);  //max 4 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;
 };

cores/esp32/Udp.h

@@ -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();
   }
 };

cores/esp32/WCharacter.h

@@ -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));

cores/esp32/WString.cpp

@@ -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;
 }
 

cores/esp32/WString.h

@@ -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(const uint8_t *cstr, unsigned int length) : String(reinterpret_cast<const char *>(cstr), length) {}
-    : String(reinterpret_cast<const char *>(cstr), length) {}
 #endif
   String(const String &str);
-  String(const __FlashStringHelper *str)
+  String(const __FlashStringHelper *str) : String(reinterpret_cast<const char *>(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)
+  StringSumHelper(const String &s) : String(s) {}
-    : String(s) {
+  StringSumHelper(const char *p) : String(p) {}
-  }
+  StringSumHelper(char c) : String(c) {}
-  StringSumHelper(const char *p)
+  StringSumHelper(unsigned char num) : String(num) {}
-    : String(p) {
+  StringSumHelper(int num) : String(num) {}
-  }
+  StringSumHelper(unsigned int num) : String(num) {}
-  StringSumHelper(char c)
+  StringSumHelper(long num) : String(num) {}
-    : String(c) {
+  StringSumHelper(unsigned long num) : String(num) {}
-  }
+  StringSumHelper(float num) : String(num) {}
-  StringSumHelper(unsigned char num)
+  StringSumHelper(double num) : String(num) {}
-    : String(num) {
+  StringSumHelper(long long num) : String(num) {}
-  }
+  StringSumHelper(unsigned long long 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) {

cores/esp32/base64.h

@@ -3,10 +3,10 @@
 
 class base64 {
 public:
-  static String encode(const uint8_t* data, size_t length);
+  static String encode(const uint8_t *data, size_t length);
-  static String encode(const String& text);
+  static String encode(const String &text);
+
 private:
 };
 
-
 #endif /* CORE_BASE64_H_ */

cores/esp32/cbuf.cpp

@@ -27,28 +27,30 @@
 #define CBUF_MUTEX_UNLOCK()
 #define CBUF_MUTEX_DELETE()
 #else
-#define CBUF_MUTEX_CREATE() \
+#define CBUF_MUTEX_CREATE()            \
-  if (_lock == NULL) { \
+  if (_lock == NULL) {                 \
-    _lock = xSemaphoreCreateMutex(); \
+    _lock = xSemaphoreCreateMutex();   \
-    if (_lock == NULL) { log_e("failed to create mutex"); } \
+    if (_lock == NULL) {               \
+      log_e("failed to create mutex"); \
+    }                                  \
   }
-#define CBUF_MUTEX_LOCK() \
+#define CBUF_MUTEX_LOCK()                          \
-  if (_lock != NULL) { xSemaphoreTakeRecursive(_lock, portMAX_DELAY); }
+  if (_lock != NULL) {                             \
-#define CBUF_MUTEX_UNLOCK() \
+    xSemaphoreTakeRecursive(_lock, portMAX_DELAY); \
-  if (_lock != NULL) { xSemaphoreGiveRecursive(_lock); }
+  }
-#define CBUF_MUTEX_DELETE() \
+#define CBUF_MUTEX_UNLOCK()         \
-  if (_lock != NULL) { \
+  if (_lock != NULL) {              \
+    xSemaphoreGiveRecursive(_lock); \
+  }
+#define CBUF_MUTEX_DELETE()      \
+  if (_lock != NULL) {           \
     SemaphoreHandle_t l = _lock; \
-    _lock = NULL; \
+    _lock = NULL;                \
-    vSemaphoreDelete(l); \
+    vSemaphoreDelete(l);         \
   }
 #endif
 
-cbuf::cbuf(size_t size)
+cbuf::cbuf(size_t size) : next(NULL), has_peek(false), peek_byte(0), _buf(xRingbufferCreate(size, RINGBUF_TYPE_BYTEBUF)) {
-  : 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;
 }
 

cores/esp32/cbuf.h

@@ -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;
 

cores/esp32/chip-debug-report.cpp

@@ -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 b2kb(b)                ((float)b / 1024.0)
-#define b2mb(b) ((float)b / (1024.0 * 1024.0))
+#define b2mb(b)                ((float)b / (1024.0 * 1024.0))
-static void _printMemCapsInfo(uint32_t caps, const char* caps_str) {
+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_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_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_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_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_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 1:  chip_report_printf("FH16"); break;
-    case 2: chip_report_printf("FH32"); 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_OTA:       chip_report_printf("OTA"); break;
-            case ESP_PARTITION_SUBTYPE_DATA_PHY: chip_report_printf("PHY"); 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_NVS:       chip_report_printf("NVS"); break;
-            case ESP_PARTITION_SUBTYPE_DATA_COREDUMP: chip_report_printf("COREDUMP"); 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_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_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_ESPHTTPD:  chip_report_printf("ESPHTTPD"); break;
-            case ESP_PARTITION_SUBTYPE_DATA_FAT: chip_report_printf("FAT"); 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_SPIFFS:    chip_report_printf("SPIFFS"); break;
-            case ESP_PARTITION_SUBTYPE_DATA_LITTLEFS: chip_report_printf("LITTLEFS"); break;
+            case ESP_PARTITION_SUBTYPE_DATA_LITTLEFS:  chip_report_printf("LITTLEFS"); break;
-            default: chip_report_printf("0x%02X", partition->subtype); 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();

cores/esp32/esp32-hal-adc.c

@@ -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;

cores/esp32/esp32-hal-adc.h

@@ -28,104 +28,103 @@ extern "C" {
 
 #include "esp32-hal.h"
 
-  typedef enum {
+typedef enum {
-    ADC_0db,
+  ADC_0db,
-    ADC_2_5db,
+  ADC_2_5db,
-    ADC_6db,
+  ADC_6db,
-    ADC_11db,
+  ADC_11db,
-    ADC_ATTENDB_MAX
+  ADC_ATTENDB_MAX
-  } adc_attenuation_t;
+} 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 {
+typedef struct {
-    uint8_t pin;         /*!<ADC pin */
+  uint8_t pin;         /*!<ADC pin */
-    uint8_t channel;     /*!<ADC channel */
+  uint8_t channel;     /*!<ADC channel */
-    int avg_read_raw;    /*!<ADC average raw data */
+  int avg_read_raw;    /*!<ADC average raw data */
-    int avg_read_mvolts; /*!<ADC average voltage in mV */
+  int avg_read_mvolts; /*!<ADC average voltage in mV */
-  } adc_continuous_data_t;
+} 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
 }

cores/esp32/esp32-hal-bt.c

@@ -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:
+    case BT_MODE_BLE:        esp_bt_mode = ESP_BT_MODE_BLE; break;
-      esp_bt_mode = ESP_BT_MODE_BLE;
+    case BT_MODE_CLASSIC_BT: esp_bt_mode = ESP_BT_MODE_CLASSIC_BT; break;
-      break;
+    case BT_MODE_BTDM:       esp_bt_mode = ESP_BT_MODE_BTDM; break;
-    case BT_MODE_CLASSIC_BT:
+    default:                 esp_bt_mode = BT_MODE; break;
-      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()) {

cores/esp32/esp32-hal-bt.h

@@ -24,15 +24,17 @@
 extern "C" {
 #endif
 
-  typedef enum { BT_MODE_DEFAULT,
+typedef enum {
-                 BT_MODE_BLE,
+  BT_MODE_DEFAULT,
-                 BT_MODE_CLASSIC_BT,
+  BT_MODE_BLE,
-                 BT_MODE_BTDM } bt_mode;
+  BT_MODE_CLASSIC_BT,
+  BT_MODE_BTDM
+} bt_mode;
 
-  bool btStarted();
+bool btStarted();
-  bool btStart();
+bool btStart();
-  bool btStartMode(bt_mode mode);
+bool btStartMode(bt_mode mode);
-  bool btStop();
+bool btStop();
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-cpu.c

@@ -54,14 +54,13 @@
 #endif
 
 typedef struct apb_change_cb_s {
-  struct apb_change_cb_s* prev;
+  struct apb_change_cb_s *prev;
-  struct apb_change_cb_s* next;
+  struct apb_change_cb_s *next;
-  void* arg;
+  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
+    } else {  // run backwards through chain
-      while (r->next != NULL) r = r->next;  // find first added
+      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;
+    if (r->prev) {
-    else {  // this is first link
+      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;
 }

cores/esp32/esp32-hal-cpu.h

@@ -23,24 +23,26 @@ extern "C" {
 #include <stdbool.h>
 #include <stdlib.h>
 
-  typedef enum { APB_BEFORE_CHANGE,
+typedef enum {
-                 APB_AFTER_CHANGE } apb_change_ev_t;
+  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 addApbChangeCallback(void *arg, apb_change_cb_t cb);
-  bool removeApbChangeCallback(void* arg, apb_change_cb_t cb);
+bool removeApbChangeCallback(void *arg, apb_change_cb_t cb);
 
-  //function takes the following frequencies as valid values:
+//function takes the following frequencies as valid values:
-  //  240, 160, 80    <<< For all XTAL types
+//  240, 160, 80    <<< For all XTAL types
-  //  40, 20, 10      <<< For 40MHz XTAL
+//  40, 20, 10      <<< For 40MHz XTAL
-  //  26, 13          <<< For 26MHz XTAL
+//  26, 13          <<< For 26MHz XTAL
-  //  24, 12          <<< For 24MHz XTAL
+//  24, 12          <<< For 24MHz XTAL
-  bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz);
+bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz);
 
-  uint32_t getCpuFrequencyMhz();   // In MHz
+uint32_t getCpuFrequencyMhz();   // In MHz
-  uint32_t getXtalFrequencyMhz();  // In MHz
+uint32_t getXtalFrequencyMhz();  // In MHz
-  uint32_t getApbFrequency();      // In Hz
+uint32_t getApbFrequency();      // In Hz
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-dac.c

@@ -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 = {
+    dac_oneshot_config_t config = {.chan_id = channel};
-      .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);

cores/esp32/esp32-hal-dac.h

@@ -16,8 +16,8 @@ extern "C" {
 #include <stdint.h>
 #include <stdbool.h>
 
-  bool dacWrite(uint8_t pin, uint8_t value);
+bool dacWrite(uint8_t pin, uint8_t value);
-  bool dacDisable(uint8_t pin);
+bool dacDisable(uint8_t pin);
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-gpio.c

@@ -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) {
+static void ARDUINO_ISR_ATTR __onPinInterrupt(void *arg) {
-  InterruptHandle_t* isr = (InterruptHandle_t*)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")));

cores/esp32/esp32-hal-gpio.h

@@ -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_DAC1       17
-#define PIN_DAC2 18
+#define PIN_DAC2       18
 #else
 #define NUM_OUPUT_PINS 34
-#define PIN_DAC1 25
+#define PIN_DAC1       25
-#define PIN_DAC2 26
+#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 OUTPUT            0x03
-#define PULLUP 0x04
+#define PULLUP            0x04
-#define INPUT_PULLUP 0x05
+#define INPUT_PULLUP      0x05
-#define PULLDOWN 0x08
+#define PULLDOWN          0x08
-#define INPUT_PULLDOWN 0x09
+#define INPUT_PULLDOWN    0x09
-#define OPEN_DRAIN 0x10
+#define OPEN_DRAIN        0x10
 #define OUTPUT_OPEN_DRAIN 0x13
-#define ANALOG 0xC0
+#define ANALOG            0xC0
 
 //Interrupt Modes
-#define DISABLED 0x00
+#define DISABLED  0x00
-#define RISING 0x01
+#define RISING    0x01
-#define FALLING 0x02
+#define FALLING   0x02
-#define CHANGE 0x03
+#define CHANGE    0x03
-#define ONLOW 0x04
+#define ONLOW     0x04
-#define ONHIGH 0x05
+#define ONHIGH    0x05
-#define ONLOW_WE 0x0C
+#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 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 \
+#define digitalPinToDacChannel(pin) (((pin) == DAC_CHANNEL_1_GPIO_NUM) ? 0 : ((pin) == DAC_CHANNEL_2_GPIO_NUM) ? 1 : -1)
-                                                                                                               : -1)
 
-  void pinMode(uint8_t pin, uint8_t mode);
+void pinMode(uint8_t pin, uint8_t mode);
-  void digitalWrite(uint8_t pin, uint8_t val);
+void digitalWrite(uint8_t pin, uint8_t val);
-  int digitalRead(uint8_t pin);
+int digitalRead(uint8_t pin);
 
-  void attachInterrupt(uint8_t pin, void (*)(void), int mode);
+void attachInterrupt(uint8_t pin, void (*)(void), int mode);
-  void attachInterruptArg(uint8_t pin, void (*)(void*), void* arg, int mode);
+void attachInterruptArg(uint8_t pin, void (*)(void *), void *arg, int mode);
-  void detachInterrupt(uint8_t pin);
+void detachInterrupt(uint8_t pin);
-  void enableInterrupt(uint8_t pin);
+void enableInterrupt(uint8_t pin);
-  void disableInterrupt(uint8_t pin);
+void disableInterrupt(uint8_t pin);
 
-  int8_t digitalPinToTouchChannel(uint8_t pin);
+int8_t digitalPinToTouchChannel(uint8_t pin);
-  int8_t digitalPinToAnalogChannel(uint8_t pin);
+int8_t digitalPinToAnalogChannel(uint8_t pin);
-  int8_t analogChannelToDigitalPin(uint8_t channel);
+int8_t analogChannelToDigitalPin(uint8_t channel);
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-i2c-slave.c

@@ -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() \
+#define I2C_SLAVE_MUTEX_LOCK()                \
-  if (i2c->lock) { xSemaphoreTake(i2c->lock, portMAX_DELAY); }
+  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,
+    .pin_bit_mask = 1LL << pin, .mode = mode, .pull_up_en = GPIO_PULLUP_ENABLE, .pull_down_en = GPIO_PULLDOWN_DISABLE, .intr_type = GPIO_INTR_DISABLE
-    .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)
+      while (xQueueReceiveFromISR(i2c->tx_queue, &d, (BaseType_t *const)&pxHigherPriorityTaskWoken) == pdTRUE);  //flush partial write
-        ;  //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,
+  size_t dlen = 0, to_read = len, so_far = 0, available = 0;
-         to_read = len,
-         so_far = 0,
-         available = 0;
   uint8_t *rx_data = NULL;
 
   vRingbufferGetInfo(i2c->rx_ring_buf, NULL, NULL, NULL, NULL, &available);

cores/esp32/esp32-hal-i2c-slave.h

@@ -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_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);
+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 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 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);
+esp_err_t i2cSlaveDeinit(uint8_t num);
-  size_t i2cSlaveWrite(uint8_t num, const uint8_t *buf, uint32_t len, uint32_t timeout_ms);
+size_t i2cSlaveWrite(uint8_t num, const uint8_t *buf, uint32_t len, uint32_t timeout_ms);
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-i2c.c

@@ -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
   };
 

cores/esp32/esp32-hal-i2c.h

@@ -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 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 i2cDeinit(uint8_t i2c_num);
-  esp_err_t i2cSetClock(uint8_t i2c_num, uint32_t frequency);
+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 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 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 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);
+esp_err_t i2cWriteReadNonStop(
-  bool i2cIsInit(uint8_t i2c_num);
+  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
 }

cores/esp32/esp32-hal-ledc.c

@@ -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 = {
+  ledc_timer_config_t ledc_timer = {.speed_mode = group, .timer_num = timer, .duty_resolution = resolution, .freq_hz = freq, .clk_cfg = LEDC_DEFAULT_CLK};
-    .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,
+    .speed_mode = group, .channel = (channel % 8), .timer_sel = timer, .intr_type = LEDC_INTR_DISABLE, .gpio_num = pin, .duty = duty, .hpoint = 0
-    .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 = {
+    ledc_timer_config_t ledc_timer = {.speed_mode = group, .timer_num = timer, .duty_resolution = 10, .freq_hz = freq, .clk_cfg = LEDC_DEFAULT_CLK};
-      .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] = {
+  const uint16_t noteFrequencyBase[12] = {//   C        C#       D        Eb       E        F       F#        G       G#        A       Bb        B
-    //   C        C#       D        Eb       E        F       F#        G       G#        A       Bb        B
+                                          4186, 4435, 4699, 4978, 5274, 5588, 5920, 6272, 6645, 7040, 7459, 7902
-    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 = {
+    ledc_timer_config_t ledc_timer = {.speed_mode = group, .timer_num = timer, .duty_resolution = resolution, .freq_hz = freq, .clk_cfg = LEDC_DEFAULT_CLK};
-      .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 = {
+    ledc_cbs_t callbacks = {.fade_cb = ledcFnWrapper};
-      .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");

cores/esp32/esp32-hal-ledc.h

@@ -27,37 +27,37 @@ extern "C" {
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
 
-  typedef enum {
+typedef enum {
-    NOTE_C,
+  NOTE_C,
-    NOTE_Cs,
+  NOTE_Cs,
-    NOTE_D,
+  NOTE_D,
-    NOTE_Eb,
+  NOTE_Eb,
-    NOTE_E,
+  NOTE_E,
-    NOTE_F,
+  NOTE_F,
-    NOTE_Fs,
+  NOTE_Fs,
-    NOTE_G,
+  NOTE_G,
-    NOTE_Gs,
+  NOTE_Gs,
-    NOTE_A,
+  NOTE_A,
-    NOTE_Bb,
+  NOTE_Bb,
-    NOTE_B,
+  NOTE_B,
-    NOTE_MAX
+  NOTE_MAX
-  } note_t;
+} note_t;
 
-  typedef void (*voidFuncPtr)(void);
+typedef void (*voidFuncPtr)(void);
-  typedef void (*voidFuncPtrArg)(void*);
+typedef void (*voidFuncPtrArg)(void *);
 
-  typedef struct {
+typedef struct {
-    uint8_t pin;                 // Pin assigned to channel
+  uint8_t pin;                 // Pin assigned to channel
-    uint8_t channel;             // Channel number
+  uint8_t channel;             // Channel number
-    uint8_t channel_resolution;  // Resolution of channel
+  uint8_t channel_resolution;  // Resolution of channel
-    voidFuncPtr fn;
+  voidFuncPtr fn;
-    void* arg;
+  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
 }

cores/esp32/esp32-hal-log.h

@@ -21,11 +21,11 @@ extern "C" {
 #include "sdkconfig.h"
 #include "esp_timer.h"
 
-#define ARDUHAL_LOG_LEVEL_NONE (0)
+#define ARDUHAL_LOG_LEVEL_NONE    (0)
-#define ARDUHAL_LOG_LEVEL_ERROR (1)
+#define ARDUHAL_LOG_LEVEL_ERROR   (1)
-#define ARDUHAL_LOG_LEVEL_WARN (2)
+#define ARDUHAL_LOG_LEVEL_WARN    (2)
-#define ARDUHAL_LOG_LEVEL_INFO (3)
+#define ARDUHAL_LOG_LEVEL_INFO    (3)
-#define ARDUHAL_LOG_LEVEL_DEBUG (4)
+#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_BLACK   "30"
-#define ARDUHAL_LOG_COLOR_RED "31"     //ERROR
+#define ARDUHAL_LOG_COLOR_RED     "31"  //ERROR
-#define ARDUHAL_LOG_COLOR_GREEN "32"   //INFO
+#define ARDUHAL_LOG_COLOR_GREEN   "32"  //INFO
-#define ARDUHAL_LOG_COLOR_YELLOW "33"  //WARNING
+#define ARDUHAL_LOG_COLOR_YELLOW  "33"  //WARNING
-#define ARDUHAL_LOG_COLOR_BLUE "34"
+#define ARDUHAL_LOG_COLOR_BLUE    "34"
 #define ARDUHAL_LOG_COLOR_MAGENTA "35"
-#define ARDUHAL_LOG_COLOR_CYAN "36"  //DEBUG
+#define ARDUHAL_LOG_COLOR_CYAN    "36"  //DEBUG
-#define ARDUHAL_LOG_COLOR_GRAY "37"  //VERBOSE
+#define ARDUHAL_LOG_COLOR_GRAY    "37"  //VERBOSE
-#define ARDUHAL_LOG_COLOR_WHITE "38"
+#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_BOLD(COLOR)  "\033[1;" COLOR "m"
-#define ARDUHAL_LOG_RESET_COLOR "\033[0m"
+#define ARDUHAL_LOG_RESET_COLOR  "\033[0m"
 
-#define ARDUHAL_LOG_COLOR_E ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_RED)
+#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_W             ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_YELLOW)
-#define ARDUHAL_LOG_COLOR_I ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_GREEN)
+#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_D             ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_CYAN)
-#define ARDUHAL_LOG_COLOR_V ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_GRAY)
+#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, ...);
-  const char *pathToFileName(const char *path);
+void log_print_buf(const uint8_t *b, size_t len);
-  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) \
+#define log_buf_v(b, l)          \
-  do { \
+  do {                           \
-    ARDUHAL_LOG_COLOR_PRINT(V); \
+    ARDUHAL_LOG_COLOR_PRINT(V);  \
-    log_print_buf(b, l); \
+    log_print_buf(b, l);         \
     ARDUHAL_LOG_COLOR_PRINT_END; \
   } while (0)
 #else
-#define log_v(format, ...) \
+#define log_v(format, ...)                                            \
-  do { ESP_LOG_LEVEL_LOCAL(ESP_LOG_VERBOSE, TAG, format, ##__VA_ARGS__); } while (0)
+  do {                                                                \
-#define isr_log_v(format, ...) \
+    ESP_LOG_LEVEL_LOCAL(ESP_LOG_VERBOSE, TAG, format, ##__VA_ARGS__); \
-  do { ets_printf(LOG_FORMAT(V, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); } while (0)
+  } while (0)
-#define log_buf_v(b, l) \
+#define isr_log_v(format, ...)                                                  \
-  do { ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_VERBOSE); } while (0)
+  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) \
+#define log_buf_d(b, l)          \
-  do { \
+  do {                           \
-    ARDUHAL_LOG_COLOR_PRINT(D); \
+    ARDUHAL_LOG_COLOR_PRINT(D);  \
-    log_print_buf(b, l); \
+    log_print_buf(b, l);         \
     ARDUHAL_LOG_COLOR_PRINT_END; \
   } while (0)
 #else
-#define log_d(format, ...) \
+#define log_d(format, ...)                                          \
-  do { ESP_LOG_LEVEL_LOCAL(ESP_LOG_DEBUG, TAG, format, ##__VA_ARGS__); } while (0)
+  do {                                                              \
-#define isr_log_d(format, ...) \
+    ESP_LOG_LEVEL_LOCAL(ESP_LOG_DEBUG, TAG, format, ##__VA_ARGS__); \
-  do { ets_printf(LOG_FORMAT(D, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); } while (0)
+  } while (0)
-#define log_buf_d(b, l) \
+#define isr_log_d(format, ...)                                                  \
-  do { ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_DEBUG); } while (0)
+  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) \
+#define log_buf_i(b, l)          \
-  do { \
+  do {                           \
-    ARDUHAL_LOG_COLOR_PRINT(I); \
+    ARDUHAL_LOG_COLOR_PRINT(I);  \
-    log_print_buf(b, l); \
+    log_print_buf(b, l);         \
     ARDUHAL_LOG_COLOR_PRINT_END; \
   } while (0)
 #else
-#define log_i(format, ...) \
+#define log_i(format, ...)                                         \
-  do { ESP_LOG_LEVEL_LOCAL(ESP_LOG_INFO, TAG, format, ##__VA_ARGS__); } while (0)
+  do {                                                             \
-#define isr_log_i(format, ...) \
+    ESP_LOG_LEVEL_LOCAL(ESP_LOG_INFO, TAG, format, ##__VA_ARGS__); \
-  do { ets_printf(LOG_FORMAT(I, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); } while (0)
+  } while (0)
-#define log_buf_i(b, l) \
+#define isr_log_i(format, ...)                                                  \
-  do { ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_INFO); } while (0)
+  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) \
+#define log_buf_w(b, l)          \
-  do { \
+  do {                           \
-    ARDUHAL_LOG_COLOR_PRINT(W); \
+    ARDUHAL_LOG_COLOR_PRINT(W);  \
-    log_print_buf(b, l); \
+    log_print_buf(b, l);         \
     ARDUHAL_LOG_COLOR_PRINT_END; \
   } while (0)
 #else
-#define log_w(format, ...) \
+#define log_w(format, ...)                                         \
-  do { ESP_LOG_LEVEL_LOCAL(ESP_LOG_WARN, TAG, format, ##__VA_ARGS__); } while (0)
+  do {                                                             \
-#define isr_log_w(format, ...) \
+    ESP_LOG_LEVEL_LOCAL(ESP_LOG_WARN, TAG, format, ##__VA_ARGS__); \
-  do { ets_printf(LOG_FORMAT(W, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); } while (0)
+  } while (0)
-#define log_buf_w(b, l) \
+#define isr_log_w(format, ...)                                                  \
-  do { ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_WARN); } while (0)
+  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) \
+#define log_buf_e(b, l)          \
-  do { \
+  do {                           \
-    ARDUHAL_LOG_COLOR_PRINT(E); \
+    ARDUHAL_LOG_COLOR_PRINT(E);  \
-    log_print_buf(b, l); \
+    log_print_buf(b, l);         \
     ARDUHAL_LOG_COLOR_PRINT_END; \
   } while (0)
 #else
-#define log_e(format, ...) \
+#define log_e(format, ...)                                          \
-  do { ESP_LOG_LEVEL_LOCAL(ESP_LOG_ERROR, TAG, format, ##__VA_ARGS__); } while (0)
+  do {                                                              \
-#define isr_log_e(format, ...) \
+    ESP_LOG_LEVEL_LOCAL(ESP_LOG_ERROR, TAG, format, ##__VA_ARGS__); \
-  do { ets_printf(LOG_FORMAT(E, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); } while (0)
+  } while (0)
-#define log_buf_e(b, l) \
+#define isr_log_e(format, ...)                                                  \
-  do { ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_ERROR); } while (0)
+  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) \
+#define log_buf_n(b, l)          \
-  do { \
+  do {                           \
-    ARDUHAL_LOG_COLOR_PRINT(E); \
+    ARDUHAL_LOG_COLOR_PRINT(E);  \
-    log_print_buf(b, l); \
+    log_print_buf(b, l);         \
     ARDUHAL_LOG_COLOR_PRINT_END; \
   } while (0)
 #else
-#define log_n(format, ...) \
+#define log_n(format, ...)                                          \
-  do { ESP_LOG_LEVEL_LOCAL(ESP_LOG_ERROR, TAG, format, ##__VA_ARGS__); } while (0)
+  do {                                                              \
-#define isr_log_n(format, ...) \
+    ESP_LOG_LEVEL_LOCAL(ESP_LOG_ERROR, TAG, format, ##__VA_ARGS__); \
-  do { ets_printf(LOG_FORMAT(E, format), esp_log_timestamp(), TAG, ##__VA_ARGS__); } while (0)
+  } while (0)
-#define log_buf_n(b, l) \
+#define isr_log_n(format, ...)                                                  \
-  do { ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_ERROR); } while (0)
+  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_LOGE(tag, format, ...)       log_e("[%s] " format, tag, ##__VA_ARGS__)
-#define ESP_LOGW(tag, format, ...) log_w("[%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_LOGI(tag, format, ...)       log_i("[%s] " format, tag, ##__VA_ARGS__)
-#define ESP_LOGD(tag, format, ...) log_d("[%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_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__)

cores/esp32/esp32-hal-matrix.c

@@ -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);
 }

cores/esp32/esp32-hal-matrix.h

@@ -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 pinMatrixOutAttach(uint8_t pin, uint8_t function, bool invertOut, bool invertEnable);
-  void pinMatrixOutDetach(uint8_t pin, bool invertOut, bool invertEnable);
+void pinMatrixOutDetach(uint8_t pin, bool invertOut, bool invertEnable);
-  void pinMatrixInAttach(uint8_t pin, uint8_t signal, bool inverted);
+void pinMatrixInAttach(uint8_t pin, uint8_t signal, bool inverted);
-  void pinMatrixInDetach(uint8_t signal, bool high, bool inverted);
+void pinMatrixInDetach(uint8_t signal, bool high, bool inverted);
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-misc.c

@@ -176,13 +176,10 @@ void disableCore1WDT() {
 }
 #endif
 
-BaseType_t xTaskCreateUniversal(TaskFunction_t pxTaskCode,
+BaseType_t xTaskCreateUniversal(
-                                const char *const pcName,
+  TaskFunction_t pxTaskCode, const char *const pcName, const uint32_t usStackDepth, void *const pvParameters, UBaseType_t uxPriority,
-                                const uint32_t usStackDepth,
+  TaskHandle_t *const pxCreatedTask, const BaseType_t xCoreID
-                                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;
 

cores/esp32/esp32-hal-periman.c

@@ -10,8 +10,8 @@
 
 typedef struct ATTR_PACKED {
   peripheral_bus_type_t type;
-  const char* extra_type;
+  const char *extra_type;
-  void* bus;
+  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_INIT:     return "INIT";
-    case ESP32_BUS_TYPE_GPIO: return "GPIO";
+    case ESP32_BUS_TYPE_GPIO:     return "GPIO";
-    case ESP32_BUS_TYPE_UART_RX: return "UART_RX";
+    case ESP32_BUS_TYPE_UART_RX:  return "UART_RX";
-    case ESP32_BUS_TYPE_UART_TX: return "UART_TX";
+    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_CONT:    return "DAC_CONT";
-    case ESP32_BUS_TYPE_DAC_COSINE: return "DAC_COSINE";
+    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_MCLK:     return "I2S_STD_MCLK";
-    case ESP32_BUS_TYPE_I2S_STD_BCLK: return "I2S_STD_BCLK";
+    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_WS:       return "I2S_STD_WS";
-    case ESP32_BUS_TYPE_I2S_STD_DOUT: return "I2S_STD_DOUT";
+    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_STD_DIN:      return "I2S_STD_DIN";
-    case ESP32_BUS_TYPE_I2S_TDM_MCLK: return "I2S_TDM_MCLK";
+    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_BCLK:     return "I2S_TDM_BCLK";
-    case ESP32_BUS_TYPE_I2S_TDM_WS: return "I2S_TDM_WS";
+    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_DOUT:     return "I2S_TDM_DOUT";
-    case ESP32_BUS_TYPE_I2S_TDM_DIN: return "I2S_TDM_DIN";
+    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_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_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_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_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_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_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_SDA:  return "I2C_SLAVE_SDA";
-    case ESP32_BUS_TYPE_I2C_SLAVE_SCL: return "I2C_SLAVE_SCL";
+    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_D0:  return "SDMMC_D0";
-    case ESP32_BUS_TYPE_SDMMC_D1: return "SDMMC_D1";
+    case ESP32_BUS_TYPE_SDMMC_D1:  return "SDMMC_D1";
-    case ESP32_BUS_TYPE_SDMMC_D2: return "SDMMC_D2";
+    case ESP32_BUS_TYPE_SDMMC_D2:  return "SDMMC_D2";
-    case ESP32_BUS_TYPE_SDMMC_D3: return "SDMMC_D3";
+    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_CLK:  return "ETHERNET_CLK";
-    case ESP32_BUS_TYPE_ETHERNET_MCD: return "ETHERNET_MCD";
+    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_TX:  return "PPP_MODEM_TX";
-    case ESP32_BUS_TYPE_PPP_RX: return "PPP_MODEM_RX";
+    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;

cores/esp32/esp32-hal-periman.h

@@ -17,131 +17,131 @@ extern "C" {
 
 #define perimanClearPinBus(p) perimanSetPinBus(p, ESP32_BUS_TYPE_INIT, NULL, -1, -1)
 
-  typedef enum {
+typedef enum {
-    ESP32_BUS_TYPE_INIT,      // IO has not been attached to a bus yet
+  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_GPIO,      // IO is used as GPIO
-    ESP32_BUS_TYPE_UART_RX,   // IO is used as UART RX pin
+  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_TX,   // IO is used as UART TX pin
-    ESP32_BUS_TYPE_UART_CTS,  // IO is used as UART CTS 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
+  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_ONESHOT,  // IO is used as ADC OneShot input
-    ESP32_BUS_TYPE_ADC_CONT,     // IO is used as ADC continuous 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_ONESHOT,  // IO is used as DAC OneShot output
-    ESP32_BUS_TYPE_DAC_CONT,     // IO is used as DAC continuous 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_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_TX,  // IO is used as RMT output
-    ESP32_BUS_TYPE_RMT_RX,  // IO is used as RMT input
+  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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_CLK,  // IO is used as SDMMC CLK pin
-    ESP32_BUS_TYPE_SDMMC_CMD,  // IO is used as SDMMC CMD 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_D0,   // IO is used as SDMMC D0 pin
-    ESP32_BUS_TYPE_SDMMC_D1,   // IO is used as SDMMC D1 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_D2,   // IO is used as SDMMC D2 pin
-    ESP32_BUS_TYPE_SDMMC_D3,   // IO is used as SDMMC D3 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_DM,  // IO is used as USB DM (+) pin
-    ESP32_BUS_TYPE_USB_DP,  // IO is used as USB DP (-) 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_RMII,  // IO is used as ETHERNET RMII pin
-    ESP32_BUS_TYPE_ETHERNET_CLK,   // IO is used as ETHERNET CLK 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_MCD,   // IO is used as ETHERNET MCD pin
-    ESP32_BUS_TYPE_ETHERNET_MDIO,  // IO is used as ETHERNET MDIO 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_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_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_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_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_CTS,  // IO is used as PPP Modem CTS pin
 #endif
-    ESP32_BUS_TYPE_MAX
+  ESP32_BUS_TYPE_MAX
-  } peripheral_bus_type_t;
+} 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.
+// 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);
+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
+// 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);
+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
+// 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);
+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
+// Returns the bus number or unit of the bus for the given pin if set. -1 otherwise
-  int8_t perimanGetPinBusNum(uint8_t pin);
+int8_t perimanGetPinBusNum(uint8_t pin);
 
-  // Returns the bus channel of the bus for the given pin if set. -1 otherwise
+// Returns the bus channel of the bus for the given pin if set. -1 otherwise
-  int8_t perimanGetPinBusChannel(uint8_t pin);
+int8_t perimanGetPinBusChannel(uint8_t pin);
 
-  // Sets the peripheral destructor callback. Used to destroy bus when pin is assigned another function
+// 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);
+bool perimanSetBusDeinit(peripheral_bus_type_t type, peripheral_bus_deinit_cb_t cb);
 
-  // Check if given pin is a valid GPIO number
+// Check if given pin is a valid GPIO number
-  bool perimanPinIsValid(uint8_t pin);
+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().
+// 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);
+bool perimanSetPinBusExtraType(uint8_t pin, const char *extra_type);
 
-  // Returns the extra type of the bus for given pin if set. NULL otherwise
+// Returns the extra type of the bus for given pin if set. NULL otherwise
-  const char* perimanGetPinBusExtraType(uint8_t pin);
+const char *perimanGetPinBusExtraType(uint8_t pin);
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-psram.c

@@ -39,7 +39,6 @@ __attribute__((weak)) bool testSPIRAM(void) {
   return esp_psram_extram_test();
 }
 
-
 bool psramInit() {
   if (spiramDetected) {
     return true;

cores/esp32/esp32-hal-psram.h

@@ -30,12 +30,12 @@ extern "C" {
 #endif
 #endif
 
-  bool psramInit();
+bool psramInit();
-  bool psramFound();
+bool psramFound();
 
-  void *ps_malloc(size_t size);
+void *ps_malloc(size_t size);
-  void *ps_calloc(size_t n, size_t size);
+void *ps_calloc(size_t n, size_t size);
-  void *ps_realloc(void *ptr, size_t size);
+void *ps_realloc(void *ptr, size_t size);
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-rgb-led.c

@@ -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++) {

cores/esp32/esp32-hal-rgb-led.h

@@ -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
 }

cores/esp32/esp32-hal-rmt.c

@@ -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 */,
+          retCode = (xEventGroupWaitBits(bus->rmt_events, RMT_FLAG_TX_DONE, pdFALSE /* do not clear on exit */, pdFALSE /* wait for all bits */, timeout_ms)
-                                         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 */,
+    retCode = (xEventGroupWaitBits(bus->rmt_events, RMT_FLAG_RX_DONE, pdFALSE /* do not clear on exit */, pdFALSE /* wait for all bits */, timeout_ms)
-                                   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 =
+  peripheral_bus_type_t pinBusType = channel_direction == RMT_TX_MODE ? ESP32_BUS_TYPE_RMT_TX : ESP32_BUS_TYPE_RMT_RX;
-    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;

cores/esp32/esp32-hal-rmt.h

@@ -22,37 +22,37 @@
 extern "C" {
 #endif
 
-  typedef enum {
+typedef enum {
-    RMT_RX_MODE = 0,  // false
+  RMT_RX_MODE = 0,  // false
-    RMT_TX_MODE = 1,  // true
+  RMT_TX_MODE = 1,  // true
-  } rmt_ch_dir_t;
+} rmt_ch_dir_t;
 
-  typedef enum {
+typedef enum {
-    RMT_MEM_NUM_BLOCKS_1 = 1,
+  RMT_MEM_NUM_BLOCKS_1 = 1,
-    RMT_MEM_NUM_BLOCKS_2 = 2,
+  RMT_MEM_NUM_BLOCKS_2 = 2,
 #if SOC_RMT_TX_CANDIDATES_PER_GROUP > 2
-    RMT_MEM_NUM_BLOCKS_3 = 3,
+  RMT_MEM_NUM_BLOCKS_3 = 3,
-    RMT_MEM_NUM_BLOCKS_4 = 4,
+  RMT_MEM_NUM_BLOCKS_4 = 4,
 #if SOC_RMT_TX_CANDIDATES_PER_GROUP > 4
-    RMT_MEM_NUM_BLOCKS_5 = 5,
+  RMT_MEM_NUM_BLOCKS_5 = 5,
-    RMT_MEM_NUM_BLOCKS_6 = 6,
+  RMT_MEM_NUM_BLOCKS_6 = 6,
-    RMT_MEM_NUM_BLOCKS_7 = 7,
+  RMT_MEM_NUM_BLOCKS_7 = 7,
-    RMT_MEM_NUM_BLOCKS_8 = 8,
+  RMT_MEM_NUM_BLOCKS_8 = 8,
 #endif
 #endif
-  } rmt_reserve_memsize_t;
+} rmt_reserve_memsize_t;
 
-  // Each RMT Symbols has 4 bytes
+// Each RMT Symbols has 4 bytes
-  // Total number of bytes per RMT_MEM_BLOCK is RMT_SYMBOLS_PER_CHANNEL_BLOCK * 4 bytes
+// Total number of bytes per RMT_MEM_BLOCK is RMT_SYMBOLS_PER_CHANNEL_BLOCK * 4 bytes
-  typedef union {
+typedef union {
-    struct {
+  struct {
-      uint32_t duration0 : 15;
+    uint32_t duration0 : 15;
-      uint32_t level0 : 1;
+    uint32_t level0    : 1;
-      uint32_t duration1 : 15;
+    uint32_t duration1 : 15;
-      uint32_t level1 : 1;
+    uint32_t level1    : 1;
-    };
+  };
-    uint32_t val;
+  uint32_t val;
-  } rmt_data_t;
+} 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
 }

cores/esp32/esp32-hal-sigmadelta.c

@@ -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 = {
+  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}};
-    .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);

cores/esp32/esp32-hal-sigmadelta.h

@@ -16,10 +16,10 @@ extern "C" {
 #include <stdint.h>
 #include <stdbool.h>
 
-  //freq 1220-312500 duty 0-255
+//freq 1220-312500 duty 0-255
-  bool sigmaDeltaAttach(uint8_t pin, uint32_t freq);
+bool sigmaDeltaAttach(uint8_t pin, uint32_t freq);
-  bool sigmaDeltaWrite(uint8_t pin, uint8_t duty);
+bool sigmaDeltaWrite(uint8_t pin, uint8_t duty);
-  bool sigmaDeltaDetach(uint8_t pin);
+bool sigmaDeltaDetach(uint8_t pin);
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-spi.c

@@ -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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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 mosi_dlen        ms_dlen
-#define miso_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) \
+#define MSB_32_SET(var, val)                                  \
-  { \
+  {                                                           \
-    uint8_t *d = (uint8_t *)&(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) \
+#define MSB_24_SET(var, val)                   \
-  { \
+  {                                            \
-    uint8_t *d = (uint8_t *)&(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); }
+  { (var) = (((val) & 0xFF00) >> 8) | (((val) & 0xFF) << 8); }
-#define MSB_PIX_SET(var, val) \
+#define MSB_PIX_SET(var, val)                                 \
-  { \
+  {                                                           \
-    uint8_t *d = (uint8_t *)&(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(&reg);
 }
 
@@ -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;

cores/esp32/esp32-hal-spi.h

@@ -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_DIV2   0x00101001  //8 MHz
-#define SPI_CLOCK_DIV4 0x00241001    //4 MHz
+#define SPI_CLOCK_DIV4   0x00241001  //4 MHz
-#define SPI_CLOCK_DIV8 0x004c1001    //2 MHz
+#define SPI_CLOCK_DIV8   0x004c1001  //2 MHz
-#define SPI_CLOCK_DIV16 0x009c1001   //1 MHz
+#define SPI_CLOCK_DIV16  0x009c1001  //1 MHz
-#define SPI_CLOCK_DIV32 0x013c1001   //500 KHz
+#define SPI_CLOCK_DIV32  0x013c1001  //500 KHz
-#define SPI_CLOCK_DIV64 0x027c1001   //250 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_SS0         0
-#define SPI_SS1 1
+#define SPI_SS1         1
-#define SPI_SS2 2
+#define SPI_SS2         2
 #define SPI_SS_MASK_ALL 0x7
 
 #define SPI_LSBFIRST 0
 #define SPI_MSBFIRST 1
 
-  struct spi_struct_t;
+struct spi_struct_t;
-  typedef struct spi_struct_t spi_t;
+typedef struct spi_struct_t spi_t;
 
-  spi_t *spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder);
+spi_t *spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder);
-  void spiStopBus(spi_t *spi);
+void spiStopBus(spi_t *spi);
 
-  //Attach/Detach Signal Pins
+//Attach/Detach Signal Pins
-  bool spiAttachSCK(spi_t *spi, int8_t sck);
+bool spiAttachSCK(spi_t *spi, int8_t sck);
-  bool spiAttachMISO(spi_t *spi, int8_t miso);
+bool spiAttachMISO(spi_t *spi, int8_t miso);
-  bool spiAttachMOSI(spi_t *spi, int8_t mosi);
+bool spiAttachMOSI(spi_t *spi, int8_t mosi);
-  bool spiDetachSCK(spi_t *spi);
+bool spiDetachSCK(spi_t *spi);
-  bool spiDetachMISO(spi_t *spi);
+bool spiDetachMISO(spi_t *spi);
-  bool spiDetachMOSI(spi_t *spi);
+bool spiDetachMOSI(spi_t *spi);
 
-  //Attach/Detach SS pin to SPI_SSx signal
+//Attach/Detach SS pin to SPI_SSx signal
-  bool spiAttachSS(spi_t *spi, uint8_t ss_num, int8_t ss);
+bool spiAttachSS(spi_t *spi, uint8_t ss_num, int8_t ss);
-  bool spiDetachSS(spi_t *spi);
+bool spiDetachSS(spi_t *spi);
 
-  //Enable/Disable SPI_SSx pins
+//Enable/Disable SPI_SSx pins
-  void spiEnableSSPins(spi_t *spi, uint8_t ss_mask);
+void spiEnableSSPins(spi_t *spi, uint8_t ss_mask);
-  void spiDisableSSPins(spi_t *spi, uint8_t ss_mask);
+void spiDisableSSPins(spi_t *spi, uint8_t ss_mask);
 
-  //Enable/Disable hardware control of SPI_SSx pins
+//Enable/Disable hardware control of SPI_SSx pins
-  void spiSSEnable(spi_t *spi);
+void spiSSEnable(spi_t *spi);
-  void spiSSDisable(spi_t *spi);
+void spiSSDisable(spi_t *spi);
 
-  //Activate enabled SPI_SSx pins
+//Activate enabled SPI_SSx pins
-  void spiSSSet(spi_t *spi);
+void spiSSSet(spi_t *spi);
-  //Deactivate enabled SPI_SSx pins
+//Deactivate enabled SPI_SSx pins
-  void spiSSClear(spi_t *spi);
+void spiSSClear(spi_t *spi);
 
-  void spiWaitReady(spi_t *spi);
+void spiWaitReady(spi_t *spi);
 
-  uint32_t spiGetClockDiv(spi_t *spi);
+uint32_t spiGetClockDiv(spi_t *spi);
-  uint8_t spiGetDataMode(spi_t *spi);
+uint8_t spiGetDataMode(spi_t *spi);
-  uint8_t spiGetBitOrder(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 spiSetClockDiv(spi_t *spi, uint32_t clockDiv);
-  void spiSetDataMode(spi_t *spi, uint8_t dataMode);
+void spiSetDataMode(spi_t *spi, uint8_t dataMode);
-  void spiSetBitOrder(spi_t *spi, uint8_t bitOrder);
+void spiSetBitOrder(spi_t *spi, uint8_t bitOrder);
 
-  void spiWrite(spi_t *spi, const uint32_t *data, uint8_t len);
+void spiWrite(spi_t *spi, const uint32_t *data, uint8_t len);
-  void spiWriteByte(spi_t *spi, uint8_t data);
+void spiWriteByte(spi_t *spi, uint8_t data);
-  void spiWriteWord(spi_t *spi, uint16_t data);
+void spiWriteWord(spi_t *spi, uint16_t data);
-  void spiWriteLong(spi_t *spi, uint32_t data);
+void spiWriteLong(spi_t *spi, uint32_t data);
 
-  void spiTransfer(spi_t *spi, uint32_t *out, uint8_t len);
+void spiTransfer(spi_t *spi, uint32_t *out, uint8_t len);
-  uint8_t spiTransferByte(spi_t *spi, uint8_t data);
+uint8_t spiTransferByte(spi_t *spi, uint8_t data);
-  uint16_t spiTransferWord(spi_t *spi, uint16_t data);
+uint16_t spiTransferWord(spi_t *spi, uint16_t data);
-  uint32_t spiTransferLong(spi_t *spi, uint32_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 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 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 spiTransaction(spi_t *spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder);
-  void spiSimpleTransaction(spi_t *spi);
+void spiSimpleTransaction(spi_t *spi);
-  void spiEndTransaction(spi_t *spi);
+void spiEndTransaction(spi_t *spi);
 
-  void spiWriteNL(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 spiWriteByteNL(spi_t *spi, uint8_t data);
-  void spiWriteShortNL(spi_t *spi, uint16_t data);
+void spiWriteShortNL(spi_t *spi, uint16_t data);
-  void spiWriteLongNL(spi_t *spi, uint32_t data);
+void spiWriteLongNL(spi_t *spi, uint32_t data);
-  void spiWritePixelsNL(spi_t *spi, const void *data_in, uint32_t len);
+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);
+uint8_t spiTransferByteNL(spi_t *spi, uint8_t data);
-  uint16_t spiTransferShortNL(spi_t *spi, uint16_t data);
+uint16_t spiTransferShortNL(spi_t *spi, uint16_t data);
-  uint32_t spiTransferLongNL(spi_t *spi, uint32_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 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);
+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 spiFrequencyToClockDiv(uint32_t freq);
-  uint32_t spiClockDivToFrequency(uint32_t freq);
+uint32_t spiClockDivToFrequency(uint32_t freq);
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-time.c

@@ -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(0, (char *)server1);
-  sntp_setservername(1, (char*)server2);
+  sntp_setservername(1, (char *)server2);
-  sntp_setservername(2, (char*)server3);
+  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(0, (char *)server1);
-  sntp_setservername(1, (char*)server2);
+  sntp_setservername(1, (char *)server2);
-  sntp_setservername(2, (char*)server3);
+  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) {

cores/esp32/esp32-hal-timer.c

@@ -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) {

cores/esp32/esp32-hal-timer.h

@@ -29,29 +29,29 @@
 extern "C" {
 #endif
 
-  struct timer_struct_t;
+struct timer_struct_t;
-  typedef struct timer_struct_t hw_timer_t;
+typedef struct timer_struct_t hw_timer_t;
 
-  hw_timer_t* timerBegin(uint32_t frequency);
+hw_timer_t *timerBegin(uint32_t frequency);
-  void timerEnd(hw_timer_t* timer);
+void timerEnd(hw_timer_t *timer);
 
-  void timerStart(hw_timer_t* timer);
+void timerStart(hw_timer_t *timer);
-  void timerStop(hw_timer_t* timer);
+void timerStop(hw_timer_t *timer);
-  void timerRestart(hw_timer_t* timer);
+void timerRestart(hw_timer_t *timer);
-  void timerWrite(hw_timer_t* timer, uint64_t val);
+void timerWrite(hw_timer_t *timer, uint64_t val);
 
-  uint64_t timerRead(hw_timer_t* timer);
+uint64_t timerRead(hw_timer_t *timer);
-  uint64_t timerReadMicros(hw_timer_t* timer);
+uint64_t timerReadMicros(hw_timer_t *timer);
-  uint64_t timerReadMilis(hw_timer_t* timer);
+uint64_t timerReadMilis(hw_timer_t *timer);
-  double timerReadSeconds(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 timerAttachInterrupt(hw_timer_t *timer, void (*userFunc)(void));
-  void timerAttachInterruptArg(hw_timer_t* timer, void (*userFunc)(void*), void* arg);
+void timerAttachInterruptArg(hw_timer_t *timer, void (*userFunc)(void *), void *arg);
-  void timerDetachInterrupt(hw_timer_t* timer);
+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
 }

cores/esp32/esp32-hal-tinyusb.c

@@ -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 = {
+  usb_hal_context_t hal = {.use_external_phy = config->external_phy};
-    .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,
+  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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // sub-compatible
+  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(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(0x0007), U16_TO_U8S_LE(0x002A),  // wPropertyDataType, wPropertyNameLength and PropertyName "DeviceInterfaceGUIDs\0" in UTF-16
+  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,
+  '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',
-  'r', 0x00, 'f', 0x00, 'a', 0x00, 'c', 0x00, 'e', 0x00, 'G', 0x00, 'U', 0x00, 'I', 0x00, 'D', 0x00, 's', 0x00, 0x00, 0x00,
+  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,
+  '{', 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, '-',
-  '0', 0x00, 'D', 0x00, '0', 0x00, '8', 0x00, '-', 0x00, '4', 0x00, '3', 0x00, 'F', 0x00, 'D', 0x00, '-', 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',
-  '8', 0x00, 'B', 0x00, '3', 0x00, 'E', 0x00, '-', 0x00, '1', 0x00, '2', 0x00, '7', 0x00, 'C', 0x00, 'A', 0x00,
+  0x00, 'A', 0x00, '8', 0x00, 'A', 0x00, 'F', 0x00, 'F', 0x00, 'F', 0x00, '9', 0x00, 'D', 0x00, '}', 0x00, 0x00, 0x00, 0x00, 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 (
+  if ((tinyusb_loaded_interfaces_mask & BIT(USB_INTERFACE_CDC)) && config->webusb_enabled && (config->usb_class != TUSB_CLASS_CDC)) {
-    (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;
 

cores/esp32/esp32-hal-tinyusb.h

@@ -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 {
+typedef struct {
-    uint16_t vid;
+  uint16_t vid;
-    uint16_t pid;
+  uint16_t pid;
-    const char *product_name;
+  const char *product_name;
-    const char *manufacturer_name;
+  const char *manufacturer_name;
-    const char *serial_number;
+  const char *serial_number;
-    uint16_t fw_version;
+  uint16_t fw_version;
 
-    uint16_t usb_version;
+  uint16_t usb_version;
-    uint8_t usb_class;
+  uint8_t usb_class;
-    uint8_t usb_subclass;
+  uint8_t usb_subclass;
-    uint8_t usb_protocol;
+  uint8_t usb_protocol;
-    uint8_t usb_attributes;
+  uint8_t usb_attributes;
-    uint16_t usb_power_ma;
+  uint16_t usb_power_ma;
 
-    bool webusb_enabled;
+  bool webusb_enabled;
-    const char *webusb_url;
+  const char *webusb_url;
-  } tinyusb_device_config_t;
+} tinyusb_device_config_t;
 
-#define TINYUSB_CONFIG_DEFAULT() \
+#define TINYUSB_CONFIG_DEFAULT()                                                                                                                               \
-  { \
+  {                                                                                                                                                            \
-    .vid = USB_ESPRESSIF_VID, \
+    .vid = USB_ESPRESSIF_VID, .pid = 0x0002, .product_name = CONFIG_TINYUSB_DESC_PRODUCT_STRING, .manufacturer_name = CONFIG_TINYUSB_DESC_MANUFACTURER_STRING, \
-    .pid = 0x0002, \
+    .serial_number = CONFIG_TINYUSB_DESC_SERIAL_STRING, .fw_version = CONFIG_TINYUSB_DESC_BCDDEVICE, .usb_version = 0x0200, .usb_class = TUSB_CLASS_MISC,      \
-    .product_name = CONFIG_TINYUSB_DESC_PRODUCT_STRING, \
+    .usb_subclass = MISC_SUBCLASS_COMMON, .usb_protocol = MISC_PROTOCOL_IAD, .usb_attributes = TUSB_DESC_CONFIG_ATT_SELF_POWERED, .usb_power_ma = 500,         \
-    .manufacturer_name = CONFIG_TINYUSB_DESC_MANUFACTURER_STRING, \
+    .webusb_enabled = false, .webusb_url = "espressif.github.io/arduino-esp32/webusb.html"                                                                     \
-    .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 {
+typedef enum {
-    RESTART_NO_PERSIST,
+  RESTART_NO_PERSIST,
-    RESTART_PERSIST,
+  RESTART_PERSIST,
-    RESTART_BOOTLOADER,
+  RESTART_BOOTLOADER,
-    RESTART_BOOTLOADER_DFU,
+  RESTART_BOOTLOADER_DFU,
-    RESTART_TYPE_MAX
+  RESTART_TYPE_MAX
-  } restart_type_t;
+} 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
+// The following definitions and functions are to be used only by the drivers
-  typedef enum {
+typedef enum {
-    USB_INTERFACE_MSC,
+  USB_INTERFACE_MSC,
-    USB_INTERFACE_DFU,
+  USB_INTERFACE_DFU,
-    USB_INTERFACE_HID,
+  USB_INTERFACE_HID,
-    USB_INTERFACE_VENDOR,
+  USB_INTERFACE_VENDOR,
-    USB_INTERFACE_CDC,
+  USB_INTERFACE_CDC,
-    USB_INTERFACE_MIDI,
+  USB_INTERFACE_MIDI,
-    USB_INTERFACE_CUSTOM,
+  USB_INTERFACE_CUSTOM,
-    USB_INTERFACE_MAX
+  USB_INTERFACE_MAX
-  } tinyusb_interface_t;
+} 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_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);
+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_add_string_descriptor(const char *str);
-  uint8_t tinyusb_get_free_duplex_endpoint(void);
+uint8_t tinyusb_get_free_duplex_endpoint(void);
-  uint8_t tinyusb_get_free_in_endpoint(void);
+uint8_t tinyusb_get_free_in_endpoint(void);
-  uint8_t tinyusb_get_free_out_endpoint(void);
+uint8_t tinyusb_get_free_out_endpoint(void);
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-touch.c

@@ -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
 */

cores/esp32/esp32-hal-touch.h

@@ -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 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 touchAttachInterruptArg(uint8_t pin, void (*userFunc)(void *), void *arg, touch_value_t threshold);
-  void touchDetachInterrupt(uint8_t pin);
+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
+// returns true if touch pad has been and continues pressed and false otherwise
-  bool touchInterruptGetLastStatus(uint8_t pin);
+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
 }

cores/esp32/esp32-hal-uart.c

@@ -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);
+      ret &= perimanSetPinBus(rxPin, ESP32_BUS_TYPE_UART_RX, (void *)uart, uart_num, -1);
-      if (ret) uart->_rxPin = rxPin;
+      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);
+      ret &= perimanSetPinBus(txPin, ESP32_BUS_TYPE_UART_TX, (void *)uart, uart_num, -1);
-      if (ret) uart->_txPin = txPin;
+      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);
+      ret &= perimanSetPinBus(ctsPin, ESP32_BUS_TYPE_UART_CTS, (void *)uart, uart_num, -1);
-      if (ret) uart->_ctsPin = ctsPin;
+      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);
+      ret &= perimanSetPinBus(rtsPin, ESP32_BUS_TYPE_UART_RTS, (void *)uart, uart_num, -1);
-      if (ret) uart->_rtsPin = rtsPin;
+      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"
+          log_v("UART%d changed parity to %s", uart_nr, parity == 0 ? "NONE" : parity == 2 ? "EVEN" : "ODD");
-                                                                                           : "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) {
-void uartSetRxInvert(uart_t* uart, bool invert) {
+  if (uart == NULL) {
-  if (uart == NULL)
     return;
+  }
 #if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
-    // POTENTIAL ISSUE :: original code only set/reset rxd_inv bit
+  // POTENTIAL ISSUE :: original code only set/reset rxd_inv bit
-    // IDF or LL set/reset the whole inv_mask!
+  // IDF or LL set/reset the whole inv_mask!
-    // if (invert)
+  // if (invert)
-    //     ESP_ERROR_CHECK(uart_set_line_inverse(uart->num, UART_SIGNAL_RXD_INV));
+  //     ESP_ERROR_CHECK(uart_set_line_inverse(uart->num, UART_SIGNAL_RXD_INV));
-    // else
+  // else
-    //     ESP_ERROR_CHECK(uart_set_line_inverse(uart->num, UART_SIGNAL_INV_DISABLE));
+  //     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);
+  uart_dev_t *hw = UART_LL_GET_HW(uart->num);
-  if (invert)
+  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)
+  while (uart_ll_get_txfifo_len(&UART0) == 0);
-    ;
+  uart_ll_write_txfifo(&UART0, (const uint8_t *)&c, 1);
-  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)
+  while (uart_ll_get_txfifo_len(&UART1) == 0);
-    ;
+  uart_ll_write_txfifo(&UART1, (const uint8_t *)&c, 1);
-  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)
+  while (uart_ll_get_txfifo_len(&UART2) == 0);
-    ;
+  uart_ll_write_txfifo(&UART2, (const uint8_t *)&c, 1);
-  uart_ll_write_txfifo(&UART2, (const uint8_t*)&c, 1);
 }
 #endif
 
 void uart_install_putc() {
   switch (s_uart_debug_nr) {
-    case 0:
+    case 0: ets_install_putc1((void (*)(char)) & uart0_write_char); break;
-      ets_install_putc1((void (*)(char)) & uart0_write_char);
-      break;
 #if SOC_UART_NUM > 1
-    case 1:
+    case 1: ets_install_putc1((void (*)(char)) & uart1_write_char); break;
-      ets_install_putc1((void (*)(char)) & uart1_write_char);
-      break;
 #endif
 #if SOC_UART_NUM > 2
-    case 2:
+    case 2: ets_install_putc1((void (*)(char)) & uart2_write_char); break;
-      ets_install_putc1((void (*)(char)) & uart2_write_char);
-      break;
 #endif
-    default:
+    default: ets_install_putc1(NULL); break;
-      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)
+  if (s_uart_debug_nr != -1) {
-    while (!uart_ll_is_tx_idle(UART_LL_GET_HW(s_uart_debug_nr)))
+    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 */

cores/esp32/esp32-hal-uart.h

@@ -29,87 +29,91 @@ extern "C" {
 #include "freertos/queue.h"
 #include "hal/uart_types.h"
 
-  struct uart_struct_t;
+struct uart_struct_t;
-  typedef struct uart_struct_t uart_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);
+bool _testUartBegin(
-  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);
+  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,
-  void uartEnd(uint8_t uart_num);
+  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
+// 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);
+void uartGetEventQueue(uart_t *uart, QueueHandle_t *q);
 
-  uint32_t uartAvailable(uart_t* uart);
+uint32_t uartAvailable(uart_t *uart);
-  uint32_t uartAvailableForWrite(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);
+size_t uartReadBytes(uart_t *uart, uint8_t *buffer, size_t size, uint32_t timeout_ms);
-  uint8_t uartRead(uart_t* uart);
+uint8_t uartRead(uart_t *uart);
-  uint8_t uartPeek(uart_t* uart);
+uint8_t uartPeek(uart_t *uart);
 
-  void uartWrite(uart_t* uart, uint8_t c);
+void uartWrite(uart_t *uart, uint8_t c);
-  void uartWriteBuf(uart_t* uart, const uint8_t* data, size_t len);
+void uartWriteBuf(uart_t *uart, const uint8_t *data, size_t len);
 
-  void uartFlush(uart_t* uart);
+void uartFlush(uart_t *uart);
-  void uartFlushTxOnly(uart_t* uart, bool txOnly);
+void uartFlushTxOnly(uart_t *uart, bool txOnly);
 
-  void uartSetBaudRate(uart_t* uart, uint32_t baud_rate);
+void uartSetBaudRate(uart_t *uart, uint32_t baud_rate);
-  uint32_t uartGetBaudRate(uart_t* uart);
+uint32_t uartGetBaudRate(uart_t *uart);
 
-  void uartSetRxInvert(uart_t* uart, bool invert);
+void uartSetRxInvert(uart_t *uart, bool invert);
-  bool uartSetRxTimeout(uart_t* uart, uint8_t numSymbTimeout);
+bool uartSetRxTimeout(uart_t *uart, uint8_t numSymbTimeout);
-  bool uartSetRxFIFOFull(uart_t* uart, uint8_t numBytesFIFOFull);
+bool uartSetRxFIFOFull(uart_t *uart, uint8_t numBytesFIFOFull);
-  void uartSetFastReading(uart_t* uart);
+void uartSetFastReading(uart_t *uart);
 
-  void uartSetDebug(uart_t* uart);
+void uartSetDebug(uart_t *uart);
-  int uartGetDebug();
+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
+// Negative Pin Number will keep it unmodified, thus this function can set individual pins
-  // When pins are changed, it will detach the previous ones
+// When pins are changed, it will detach the previous ones
-  // Can be called before or after begin()
+// 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);
+bool uartSetPins(uint8_t uart_num, int8_t rxPin, int8_t txPin, int8_t ctsPin, int8_t rtsPin);
 
-  // helper functions
+// helper functions
-  int8_t uart_get_RxPin(uint8_t uart_num);
+int8_t uart_get_RxPin(uint8_t uart_num);
-  int8_t uart_get_TxPin(uint8_t uart_num);
+int8_t uart_get_TxPin(uint8_t uart_num);
-  void uart_init_PeriMan(void);
+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
+// Used to set RS485 function -- needs to disable HW Flow Control and set RTS pin to use
-  //    UART_HW_FLOWCTRL_DISABLE = 0x0   disable hardware flow control
+// RTS pin becomes RS485 half duplex RE/DE
-  //    UART_HW_FLOWCTRL_RTS     = 0x1   enable RX hardware flow control (rts)
+//    UART_MODE_UART                   = 0x00    mode: regular UART mode
-  //    UART_HW_FLOWCTRL_CTS     = 0x2   enable TX hardware flow control (cts)
+//    UART_MODE_RS485_HALF_DUPLEX      = 0x01    mode: half duplex RS485 UART mode control by RTS pin
-  //    UART_HW_FLOWCTRL_CTS_RTS = 0x3   enable hardware flow control
+//    UART_MODE_IRDA                   = 0x02    mode: IRDA  UART mode
-  bool uartSetHwFlowCtrlMode(uart_t* uart, uart_hw_flowcontrol_t mode, uint8_t threshold);
+//    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
+void uartStartDetectBaudrate(uart_t *uart);
-  // RTS pin becomes RS485 half duplex RE/DE
+unsigned long uartDetectBaudrate(uart_t *uart);
-  //    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);
-
-  /*
     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
+// 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
+// This creates a loop that lets us receive anything we send on the UART
-  void uart_internal_loopback(uint8_t uartNum, int8_t rxPin);
+void uart_internal_loopback(uint8_t uartNum, int8_t rxPin);
 
-  // Routines that generate BREAK in the UART for testing purpose
+// 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);
 
+// 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
 }

cores/esp32/esp32-hal.h

@@ -61,13 +61,13 @@ extern "C" {
 #define ARDUINO_EVENT_RUNNING_CORE CONFIG_ARDUINO_EVENT_RUNNING_CORE
 #endif
 
-  //forward declaration from freertos/portmacro.h
+//forward declaration from freertos/portmacro.h
-  void vPortYield(void);
+void vPortYield(void);
-  void yield(void);
+void yield(void);
 #define optimistic_yield(u)
 
-#define ESP_REG(addr) *((volatile uint32_t*)(addr))
+#define ESP_REG(addr) *((volatile uint32_t *)(addr))
-#define NOP() asm volatile("nop")
+#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 analogWrite(uint8_t pin, int value);
-  void analogWriteFrequency(uint8_t pin, uint32_t freq);
+void analogWriteFrequency(uint8_t pin, uint32_t freq);
-  void analogWriteResolution(uint8_t pin, uint8_t bits);
+void analogWriteResolution(uint8_t pin, uint8_t bits);
 
-  //returns chip temperature in Celsius
+//returns chip temperature in Celsius
-  float temperatureRead();
+float temperatureRead();
 
-  //allows user to bypass SPI RAM test routine
+//allows user to bypass SPI RAM test routine
-  bool testSPIRAM(void);
+bool testSPIRAM(void);
 
 #if CONFIG_AUTOSTART_ARDUINO
-  //enable/disable WDT for Arduino's setup and loop functions
+//enable/disable WDT for Arduino's setup and loop functions
-  void enableLoopWDT();
+void enableLoopWDT();
-  void disableLoopWDT();
+void disableLoopWDT();
-  //feed WDT for the loop task
+//feed WDT for the loop task
-  void feedLoopWDT();
+void feedLoopWDT();
 #endif
 
-  //enable/disable WDT for the IDLE task on Core 0 (SYSTEM)
+//enable/disable WDT for the IDLE task on Core 0 (SYSTEM)
-  void enableCore0WDT();
+void enableCore0WDT();
-  void disableCore0WDT();
+void disableCore0WDT();
 #ifndef CONFIG_FREERTOS_UNICORE
-  //enable/disable WDT for the IDLE task on Core 1 (Arduino)
+//enable/disable WDT for the IDLE task on Core 1 (Arduino)
-  void enableCore1WDT();
+void enableCore1WDT();
-  void disableCore1WDT();
+void disableCore1WDT();
 #endif
 
-  //if xCoreID < 0 or CPU is unicore, it will use xTaskCreate, else xTaskCreatePinnedToCore
+//if xCoreID < 0 or CPU is unicore, it will use xTaskCreate, else xTaskCreatePinnedToCore
-  //allows to easily handle all possible situations without repetitive code
+//allows to easily handle all possible situations without repetitive code
-  BaseType_t xTaskCreateUniversal(TaskFunction_t pxTaskCode,
+BaseType_t xTaskCreateUniversal(
-                                  const char* const pcName,
+  TaskFunction_t pxTaskCode, const char *const pcName, const uint32_t usStackDepth, void *const pvParameters, UBaseType_t uxPriority,
-                                  const uint32_t usStackDepth,
+  TaskHandle_t *const pxCreatedTask, const BaseType_t xCoreID
-                                  void* const pvParameters,
+);
-                                  UBaseType_t uxPriority,
-                                  TaskHandle_t* const pxCreatedTask,
-                                  const BaseType_t xCoreID);
 
-  unsigned long micros();
+unsigned long micros();
-  unsigned long millis();
+unsigned long millis();
-  void delay(uint32_t);
+void delay(uint32_t);
-  void delayMicroseconds(uint32_t us);
+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 {
+typedef struct {
-    int core;                    // core which triggered panic
+  int core;                    // core which triggered panic
-    const char* reason;          // exception string
+  const char *reason;          // exception string
-    const void* pc;              // instruction address that triggered the exception
+  const void *pc;              // instruction address that triggered the exception
-    bool backtrace_corrupt;      // if backtrace is corrupt
+  bool backtrace_corrupt;      // if backtrace is corrupt
-    bool backtrace_continues;    // if backtrace continues, but did not fit
+  bool backtrace_continues;    // if backtrace continues, but did not fit
-    unsigned int backtrace_len;  // number of backtrace addresses
+  unsigned int backtrace_len;  // number of backtrace addresses
-    unsigned int backtrace[60];  // backtrace addresses array
+  unsigned int backtrace[60];  // backtrace addresses array
-  } arduino_panic_info_t;
+} 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);
+void set_arduino_panic_handler(arduino_panic_handler_t handler, void *arg);
-  arduino_panic_handler_t get_arduino_panic_handler(void);
+arduino_panic_handler_t get_arduino_panic_handler(void);
-  void* get_arduino_panic_handler_arg(void);
+void *get_arduino_panic_handler_arg(void);
 
 #ifdef __cplusplus
 }

cores/esp32/esp8266-compat.h

@@ -20,5 +20,4 @@
 #define ICACHE_FLASH_ATTR
 #define ICACHE_RAM_ATTR ARDUINO_ISR_ATTR
 
-
 #endif /* _ESP8266_COMPAT_H_ */

cores/esp32/esp_arduino_version.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, \
+#define ESP_ARDUINO_VERSION ESP_ARDUINO_VERSION_VAL(ESP_ARDUINO_VERSION_MAJOR, ESP_ARDUINO_VERSION_MINOR, ESP_ARDUINO_VERSION_PATCH)
-                                                    ESP_ARDUINO_VERSION_MINOR, \
-                                                    ESP_ARDUINO_VERSION_PATCH)
 
 /**
  * Current ARDUINO version, as string
  */
-#define df2xstr(s) #s
+#define df2xstr(s)              #s
-#define df2str(s) df2xstr(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

cores/esp32/extra_attr.h

@@ -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)))

cores/esp32/firmware_msc_fat.c

@@ -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',
   };

cores/esp32/firmware_msc_fat.h

@@ -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_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_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_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_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_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_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_READ_ONLY    0x01
-#define FAT_FILE_ATTR_HIDDEN 0x02
+#define FAT_FILE_ATTR_HIDDEN       0x02
-#define FAT_FILE_ATTR_SYSTEM 0x04
+#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_ARCHIVE      0x20
-#define FAT_FILE_ATTR_DEVICE 0x40
+#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)) {
+typedef struct __attribute__((packed)) {
-    uint8_t jump_instruction[3];
+  uint8_t jump_instruction[3];
-    char oem_name[8];                 //padded with spaces (0x20)
+  char oem_name[8];                 //padded with spaces (0x20)
-    uint16_t bytes_per_sector;        //DISK_SECTOR_SIZE usually 512
+  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
+  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
+  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
+  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 max_root_dir_entries;    //FAT12 and FAT16
-    uint16_t fat12_sector_num;        //DISK_SECTOR_NUM FAT12 and FAT16
+  uint16_t fat12_sector_num;        //DISK_SECTOR_NUM FAT12 and FAT16
-    uint8_t media_descriptor;
+  uint8_t media_descriptor;
-    uint16_t sectors_per_alloc_table;  //FAT12 and FAT16
+  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 sectors_per_track;        //A value of 0 may indicate LBA-only access
-    uint16_t num_heads;
+  uint16_t num_heads;
-    uint32_t hidden_sectors_count;
+  uint32_t hidden_sectors_count;
-    uint32_t total_sectors_32;
+  uint32_t total_sectors_32;
-    uint8_t physical_drive_number;  //0x00 for (first) removable media, 0x80 for (first) fixed disk
+  uint8_t physical_drive_number;  //0x00 for (first) removable media, 0x80 for (first) fixed disk
-    uint8_t reserved0;
+  uint8_t reserved0;
-    uint8_t extended_boot_signature;  //should be 0x29
+  uint8_t extended_boot_signature;  //should be 0x29
-    uint32_t serial_number;           //0x1234 => 1234
+  uint32_t serial_number;           //0x1234 => 1234
-    char volume_label[11];            //padded with spaces (0x20)
+  char volume_label[11];            //padded with spaces (0x20)
-    char file_system_type[8];         //padded with spaces (0x20)
+  char file_system_type[8];         //padded with spaces (0x20)
-    uint8_t reserved[448];
+  uint8_t reserved[448];
-    uint16_t signature;  //should be 0xAA55
+  uint16_t signature;  //should be 0xAA55
-  } fat_boot_sector_t;
+} fat_boot_sector_t;
 
-  typedef struct __attribute__((packed)) {
+typedef struct __attribute__((packed)) {
-    union {
+  union {
-      struct {
+    struct {
-        char file_name[8];       //padded with spaces (0x20)
+      char file_name[8];       //padded with spaces (0x20)
-        char file_extension[3];  //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)
     };
-    uint8_t file_attr;           //mask of FAT_FILE_ATTR_*
+    struct {
-    uint8_t reserved;            //always 0
+      uint8_t file_magic;  // 0xE5:deleted, 0x05:will_be_deleted, 0x00:end_marker, 0x2E:dot_marker(. or ..)
-    uint8_t creation_time_ms;    //ms * 10; max 1990 (1s 990ms)
+      char file_magic_data[10];
-    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
     };
-    uint16_t name0[5];
+    char volume_label[11];  //padded with spaces (0x20)
-    uint8_t attr;  //ALWAYS 0x0F
+  };
-    uint8_t type;  //ALWAYS 0x00
+  uint8_t file_attr;           //mask of FAT_FILE_ATTR_*
-    uint8_t dos_checksum;
+  uint8_t reserved;            //always 0
-    uint16_t name1[6];
+  uint8_t creation_time_ms;    //ms * 10; max 1990 (1s 990ms)
-    uint16_t first_cluster;  //ALWAYS 0x0000
+  uint16_t creation_time_hms;  // [5:6:5] => h:m:(s/2)
-    uint16_t name2[2];
+  uint16_t creation_time_ymd;  // [7:4:5] => (y+1980):m:d
-  } fat_lfn_entry_t;
+  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 {
+typedef struct __attribute__((packed)) {
-    fat_dir_entry_t dir;
+  union {
-    fat_lfn_entry_t lfn;
+    struct {
-  } fat_entry_t;
+      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);
+typedef union {
-  uint16_t fat_sectors_per_alloc_table(uint32_t sector_num, bool fat16);
+  fat_dir_entry_t dir;
-  uint8_t *fat_add_table(uint8_t *dst, fat_boot_sector_t *boot, bool fat16);
+  fat_lfn_entry_t lfn;
-  void fat_set_table_index(uint8_t *table, uint16_t index, uint16_t value, bool fat16);
+} fat_entry_t;
-  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);
+const char *fat_file_system_type(bool 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);
+uint16_t fat_sectors_per_alloc_table(uint32_t sector_num, bool fat16);
-  uint8_t fat_lfn_checksum(const uint8_t *short_filename);
+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
 }

cores/esp32/io_pin_remap.h

@@ -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 pulseIn(pin, args...)     pulseIn(digitalPinToGPIONumber(pin), args)
-#define noTone(_pin) noTone(digitalPinToGPIONumber(_pin))
+#define noTone(_pin)              noTone(digitalPinToGPIONumber(_pin))
-#define tone(_pin, args...) tone(digitalPinToGPIONumber(_pin), args)
+#define tone(_pin, args...)       tone(digitalPinToGPIONumber(_pin), args)
 
 // cores/esp32/esp32-hal.h
-#define analogGetChannel(pin) analogGetChannel(digitalPinToGPIONumber(pin))
+#define analogGetChannel(pin)            analogGetChannel(digitalPinToGPIONumber(pin))
-#define analogWrite(pin, value) analogWrite(digitalPinToGPIONumber(pin), value)
+#define analogWrite(pin, value)          analogWrite(digitalPinToGPIONumber(pin), value)
-#define analogWriteFrequency(pin, freq) analogWriteFrequency(digitalPinToGPIONumber(pin), freq)
+#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 analogRead(pin)                           analogRead(digitalPinToGPIONumber(pin))
-#define analogReadMilliVolts(pin) analogReadMilliVolts(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 analogChannelToDigitalPin(channel)      gpioNumberToDigitalPin(analogChannelToDigitalPin(channel))
-#define digitalPinToAnalogChannel(pin) digitalPinToAnalogChannel(digitalPinToGPIONumber(pin))
+#define digitalPinToAnalogChannel(pin)          digitalPinToAnalogChannel(digitalPinToGPIONumber(pin))
-#define digitalPinToTouchChannel(pin) digitalPinToTouchChannel(digitalPinToGPIONumber(pin))
+#define digitalPinToTouchChannel(pin)           digitalPinToTouchChannel(digitalPinToGPIONumber(pin))
-#define digitalRead(pin) digitalRead(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 attachInterrupt(pin, fcn, mode)         attachInterrupt(digitalPinToGPIONumber(pin), fcn, mode)
-#define detachInterrupt(pin) detachInterrupt(digitalPinToGPIONumber(pin))
+#define detachInterrupt(pin)                    detachInterrupt(digitalPinToGPIONumber(pin))
-#define digitalWrite(pin, val) digitalWrite(digitalPinToGPIONumber(pin), val)
+#define digitalWrite(pin, val)                  digitalWrite(digitalPinToGPIONumber(pin), val)
-#define pinMode(pin, mode) pinMode(digitalPinToGPIONumber(pin), mode)
+#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 ledcWrite(pin, duty)                              ledcWrite(digitalPinToGPIONumber(pin), duty)
-#define ledcWriteTone(pin, freq) ledcWriteTone(digitalPinToGPIONumber(pin), freq)
+#define ledcWriteTone(pin, freq)                          ledcWriteTone(digitalPinToGPIONumber(pin), freq)
-#define ledcWriteNote(pin, note, octave) ledcWriteNote(digitalPinToGPIONumber(pin), note, octave)
+#define ledcWriteNote(pin, note, octave)                  ledcWriteNote(digitalPinToGPIONumber(pin), note, octave)
-#define ledcRead(pin) ledcRead(digitalPinToGPIONumber(pin))
+#define ledcRead(pin)                                     ledcRead(digitalPinToGPIONumber(pin))
-#define ledcReadFreq(pin) ledcReadFreq(digitalPinToGPIONumber(pin))
+#define ledcReadFreq(pin)                                 ledcReadFreq(digitalPinToGPIONumber(pin))
-#define ledcDetach(pin) ledcDetach(digitalPinToGPIONumber(pin))
+#define ledcDetach(pin)                                   ledcDetach(digitalPinToGPIONumber(pin))
-#define ledcChangeFrequency(pin, freq, resolution) ledcChangeFrequency(digitalPinToGPIONumber(pin), freq, resolution)
+#define ledcChangeFrequency(pin, freq, resolution)        ledcChangeFrequency(digitalPinToGPIONumber(pin), freq, resolution)
-#define ledcOutputInvert(pin, out_invert) ledcOutputInvert(digitalPinToGPIONumber(pin), out_invert)
+#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 ledcFadeWithInterrupt(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)
+  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 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 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 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 rmtWriteLooping(pin, data, num_rmt_symbols)            rmtWriteLooping(digitalPinToGPIONumber(pin), data, num_rmt_symbols)
-#define rmtTransmitCompleted(pin) rmtTransmitCompleted(digitalPinToGPIONumber(pin))
+#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 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 rmtReadAsync(pin, data, num_rmt_symbols)               rmtReadAsync(digitalPinToGPIONumber(pin), data, num_rmt_symbols)
-#define rmtReceiveCompleted(pin) rmtReceiveCompleted(digitalPinToGPIONumber(pin))
+#define rmtReceiveCompleted(pin)                               rmtReceiveCompleted(digitalPinToGPIONumber(pin))
-#define rmtSetRxMaxThreshold(pin, idle_thres_ticks) rmtSetRxMaxThreshold(digitalPinToGPIONumber(pin), idle_thres_ticks)
+#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 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 sigmaDeltaWrite(pin, duty)  sigmaDeltaWrite(digitalPinToGPIONumber(pin), duty)
-#define sigmaDeltaDetach(pin) sigmaDeltaDetach(digitalPinToGPIONumber(pin))
+#define sigmaDeltaDetach(pin)       sigmaDeltaDetach(digitalPinToGPIONumber(pin))
 
 // cores/esp32/esp32-hal-spi.h
-#define spiAttachSCK(spi, sck) spiAttachSCK(spi, digitalPinToGPIONumber(sck))
+#define spiAttachSCK(spi, sck)       spiAttachSCK(spi, digitalPinToGPIONumber(sck))
-#define spiAttachMISO(spi, miso) spiAttachMISO(spi, digitalPinToGPIONumber(miso))
+#define spiAttachMISO(spi, miso)     spiAttachMISO(spi, digitalPinToGPIONumber(miso))
-#define spiAttachMOSI(spi, mosi) spiAttachMOSI(spi, digitalPinToGPIONumber(mosi))
+#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 touchInterruptGetLastStatus(pin)                       touchInterruptGetLastStatus(digitalPinToGPIONumber(pin))
-#define touchRead(pin) touchRead(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 touchAttachInterrupt(pin, userFunc, threshold)         touchAttachInterrupt(digitalPinToGPIONumber(pin), userFunc, threshold)
-#define touchDetachInterrupt(pin) touchDetachInterrupt(digitalPinToGPIONumber(pin))
+#define touchDetachInterrupt(pin)                              touchDetachInterrupt(digitalPinToGPIONumber(pin))
-#define touchSleepWakeUpEnable(pin, threshold) touchSleepWakeUpEnable(digitalPinToGPIONumber(pin), threshold)
+#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) \
+#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)
+  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) \

cores/esp32/libb64/cdecode.c

@@ -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) {
+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;
+  const int8_t *codechar = code_in;
-  int8_t* plainchar = plaintext_out;
+  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) {
+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);
+  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) {
+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);
+  return base64_decode_chars_signed((int8_t *)code_in, length_in, (int8_t *)plaintext_out);
 }

cores/esp32/libb64/cdecode.h

@@ -14,25 +14,25 @@ For details, see http://sourceforge.net/projects/libb64
 extern "C" {
 #endif
 
-  typedef enum {
+typedef enum {
-    step_a,
+  step_a,
-    step_b,
+  step_b,
-    step_c,
+  step_c,
-    step_d
+  step_d
-  } base64_decodestep;
+} base64_decodestep;
 
-  typedef struct {
+typedef struct {
-    base64_decodestep step;
+  base64_decodestep step;
-    char plainchar;
+  char plainchar;
-  } base64_decodestate;
+} 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"

cores/esp32/libb64/cencode.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) {
+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 *plainchar = plaintext_in;
-  const char* const plaintextend = plaintext_in + length_in;
+  const char *const plaintextend = plaintext_in + length_in;
-  char* codechar = code_out;
+  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) {
+int base64_encode_blockend(char *code_out, base64_encodestate *state_in) {
-  char* codechar = code_out;
+  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:
+    case step_A: break;
-      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);

cores/esp32/libb64/cencode.h

@@ -14,27 +14,27 @@ For details, see http://sourceforge.net/projects/libb64
 extern "C" {
 #endif
 
-  typedef enum {
+typedef enum {
-    step_A,
+  step_A,
-    step_B,
+  step_B,
-    step_C
+  step_C
-  } base64_encodestep;
+} base64_encodestep;
 
-  typedef struct {
+typedef struct {
-    base64_encodestep step;
+  base64_encodestep step;
-    char result;
+  char result;
-    int stepcount;
+  int stepcount;
-  } base64_encodestate;
+} 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"

cores/esp32/main.cpp

@@ -71,7 +71,9 @@ void loopTask(void *pvParameters) {
       esp_task_wdt_reset();
     }
     loop();
-    if (serialEventRun) serialEventRun();
+    if (serialEventRun) {
+      serialEventRun();
+    }
   }
 }
 

cores/esp32/pgmspace.h

@@ -30,60 +30,64 @@ typedef long prog_int32_t;
 typedef unsigned long prog_uint32_t;
 
 #define PROGMEM
-#define PGM_P const char *
+#define PGM_P        const char *
-#define PGM_VOID_P const void *
+#define PGM_VOID_P   const void *
-#define PSTR(s) (s)
+#define PSTR(s)      (s)
 #define _SFR_BYTE(n) (n)
 
 #define pgm_read_byte(addr) (*(const unsigned char *)(addr))
-#define pgm_read_word(addr) ({ \
+#define pgm_read_word(addr)           \
-  typeof(addr) _addr = (addr); \
+  ({                                  \
-  *(const unsigned short *)(_addr); \
+    typeof(addr) _addr = (addr);      \
-})
+    *(const unsigned short *)(_addr); \
-#define pgm_read_dword(addr) ({ \
+  })
-  typeof(addr) _addr = (addr); \
+#define pgm_read_dword(addr)         \
-  *(const unsigned long *)(_addr); \
+  ({                                 \
-})
+    typeof(addr) _addr = (addr);     \
-#define pgm_read_float(addr) ({ \
+    *(const unsigned long *)(_addr); \
-  typeof(addr) _addr = (addr); \
+  })
-  *(const float *)(_addr); \
+#define pgm_read_float(addr)     \
-})
+  ({                             \
-#define pgm_read_ptr(addr) ({ \
+    typeof(addr) _addr = (addr); \
-  typeof(addr) _addr = (addr); \
+    *(const float *)(_addr);     \
-  *(void *const *)(_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_byte_near(addr)  pgm_read_byte(addr)
-#define pgm_read_word_near(addr) pgm_read_word(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_ptr_near(addr)   pgm_read_ptr(addr)
-#define pgm_read_byte_far(addr) pgm_read_byte(addr)
+#define pgm_read_byte_far(addr)   pgm_read_byte(addr)
-#define pgm_read_word_far(addr) pgm_read_word(addr)
+#define pgm_read_word_far(addr)   pgm_read_word(addr)
-#define pgm_read_dword_far(addr) pgm_read_dword(addr)
+#define pgm_read_dword_far(addr)  pgm_read_dword(addr)
-#define pgm_read_float_far(addr) pgm_read_float(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_far(addr)    pgm_read_ptr(addr)
 
-#define memcmp_P memcmp
+#define memcmp_P      memcmp
-#define memccpy_P memccpy
+#define memccpy_P     memccpy
-#define memmem_P memmem
+#define memmem_P      memmem
-#define memcpy_P memcpy
+#define memcpy_P      memcpy
-#define strcpy_P strcpy
+#define strcpy_P      strcpy
-#define strncpy_P strncpy
+#define strncpy_P     strncpy
-#define strcat_P strcat
+#define strcat_P      strcat
-#define strncat_P strncat
+#define strncat_P     strncat
-#define strcmp_P strcmp
+#define strcmp_P      strcmp
-#define strncmp_P strncmp
+#define strncmp_P     strncmp
-#define strcasecmp_P strcasecmp
+#define strcasecmp_P  strcasecmp
 #define strncasecmp_P strncasecmp
-#define strlen_P strlen
+#define strlen_P      strlen
-#define strnlen_P strnlen
+#define strnlen_P     strnlen
-#define strstr_P strstr
+#define strstr_P      strstr
-#define printf_P printf
+#define printf_P      printf
-#define sprintf_P sprintf
+#define sprintf_P     sprintf
-#define snprintf_P snprintf
+#define snprintf_P    snprintf
-#define vsnprintf_P vsnprintf
+#define vsnprintf_P   vsnprintf
 
 #endif

cores/esp32/stdlib_noniso.c

@@ -30,9 +30,9 @@
 #include "stdlib_noniso.h"
 #include "esp_system.h"
 
-static void reverse(char* begin, char* end) {
+static void reverse(char *begin, char *end) {
-  char* is = begin;
+  char *is = begin;
-  char* ie = end - 1;
+  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++ = '.';

cores/esp32/stdlib_noniso.h

@@ -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

cores/esp32/wiring_private.h

@@ -34,9 +34,9 @@
 extern "C" {
 #endif
 
-  typedef void (*voidFuncPtr)(void);
+typedef void (*voidFuncPtr)(void);
 
-  void initPins();
+void initPins();
 
 #ifdef __cplusplus
 }  // extern "C"