Clang format pass

.clang-format

@@ -0,0 +1,67 @@
+# Generated from CLion C/C++ Code Style settings
+BasedOnStyle: LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignOperands: true
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Always
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Always
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterReturnType: None
+AlwaysBreakTemplateDeclarations: Yes
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: true
+  AfterControlStatement: Always
+  AfterEnum: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterUnion: true
+  AfterStruct: true
+  BeforeCatch: false
+  BeforeElse: false
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: true
+BreakBeforeBinaryOperators: None
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeColon
+BreakInheritanceList: BeforeComma
+ColumnLimit: 0
+CompactNamespaces: false
+ContinuationIndentWidth: 8
+IndentCaseLabels: true
+IndentPPDirectives: None
+IndentWidth: 2
+KeepEmptyLinesAtTheStartOfBlocks: true
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: None
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PointerAlignment: Left
+ReflowComments: false
+SpaceAfterCStyleCast: true
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 0
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+TabWidth: 2
+UseTab: Never

Messaging/CMakeLists.txt

@@ -8,6 +8,6 @@ target_include_directories(messaging
         INTERFACE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/Inc>
         $<INSTALL_INTERFACE:include>
-)
+        )
 
 skullc_install_packages(skullc messaging ${version})

Messaging/Inc/messaging_packet.hpp

@@ -8,9 +8,9 @@
 #ifndef MESSAGING_INC_MESSAGING_PACKET_HPP_
 #define MESSAGING_INC_MESSAGING_PACKET_HPP_
 
-#include <cstring>
-#include <cstdint>
 #include <array>
+#include <cstdint>
+#include <cstring>
 
 namespace Messaging
 {
@@ -20,8 +20,8 @@ struct Packet
 {
   using length_type = std::uint32_t;
 
-  static constexpr std::uint8_t preamble[] = { 'A', 'A' };
+  static constexpr std::uint8_t preamble[] = {'A', 'A'};
-  std::array<std::uint8_t, N> data = { 0 };
+  std::array<std::uint8_t, N> data = {0};
   std::uint32_t data_length = 0;
 
   const std::uint32_t max_data_length = N;
@@ -34,13 +34,16 @@ struct Packet
   }
 
   Packet() = default;
+
   Packet(const Packet&) = default;
+
   Packet(Packet&&) noexcept = default;
 
   template<std::size_t data_in_length>
   void copy_data_in(const std::uint8_t (&data_in)[data_in_length])
   {
-    const std::uint32_t to_copy_length = std::min(std::uint32_t(data_in_length), max_data_length);
+    const std::uint32_t to_copy_length =
+            std::min(std::uint32_t(data_in_length), max_data_length);
 
     std::memcpy(data.data(), data_in, to_copy_length);
     data_length = to_copy_length;
@@ -49,7 +52,8 @@ struct Packet
   template<std::size_t data_in_length>
   void copy_data_in(const std::array<std::uint8_t, data_in_length>& data_in)
   {
-    const std::uint32_t to_copy_length = std::min(std::uint32_t(data_in_length), max_data_length);
+    const std::uint32_t to_copy_length =
+            std::min(std::uint32_t(data_in_length), max_data_length);
 
     std::memcpy(data.data(), data_in.data(), to_copy_length);
     data_length = to_copy_length;
@@ -57,7 +61,8 @@ struct Packet
 
   bool serialize(std::uint8_t* buffer, const std::uint32_t max_length)
   {
-    const std::uint32_t required_size = preamble_length + data_length_length + data_length;
+    const std::uint32_t required_size =
+            preamble_length + data_length_length + data_length;
 
     if (max_length < required_size)
       return false;
@@ -96,10 +101,9 @@ struct Packet
   }
 };
 
-template <std::size_t N>
+template<std::size_t N>
 constexpr std::uint8_t Packet<N>::preamble[2];
 
-}
+}// namespace Messaging
-
 
 #endif /* MESSAGING_INC_MESSAGING_PACKET_HPP_ */

Messaging/Inc/messaging_parser.hpp

@@ -5,9 +5,9 @@
 #ifndef SKULLC_MESSAGING_PARSER_HPP
 #define SKULLC_MESSAGING_PARSER_HPP
 
+#include <array>
 #include <cstdint>
 #include <cstring>
-#include <array>
 
 namespace Messaging
 {
@@ -19,11 +19,10 @@ public:
   using Packet = P;
   const std::size_t buffer_length = N;
 
-  Parser()
+  Parser() { reset(); }
-  {
+
-    reset();
-  }
   Parser(const Parser&) = delete;
+
   Parser(Parser&&) = delete;
 
   void reset()
@@ -65,10 +64,7 @@ public:
     }
   }
 
-  bool packetReady() const
+  bool packetReady() const { return _state == _State::Done; }
-  {
-    return _state == _State::Done;
-  }
 
   bool getPacket(Packet& packet) const
   {
@@ -126,6 +122,6 @@ private:
   }
 };
 
-}
+}// namespace Messaging
 
-#endif //SKULLC_MESSAGING_PARSER_HPP
+#endif// SKULLC_MESSAGING_PARSER_HPP

Peripherals/Inc/peripherals_adc.hpp

@@ -8,8 +8,8 @@
 #ifndef PERIPHERALS_INC_PERIPHERALS_ADC_HPP_
 #define PERIPHERALS_INC_PERIPHERALS_ADC_HPP_
 
-#include <cstdint>
 #include <array>
+#include <cstdint>
 
 #include <adc.h>
 
@@ -19,19 +19,14 @@ namespace Peripherals
 template<std::size_t N>
 struct Adc
 {
-  std::array<std::uint16_t, N> readings = { 0 };
+  std::array<std::uint16_t, N> readings = {0};
   ADC_HandleTypeDef* hadc = nullptr;
 
-  static constexpr std::uint32_t readingsCount()
+  static constexpr std::uint32_t readingsCount() { return N; }
-  {
-    return N;
-  }
 
   Adc() = delete;
 
-  explicit Adc(ADC_HandleTypeDef* hadc)
+  explicit Adc(ADC_HandleTypeDef* hadc) : hadc(hadc) {}
-    : hadc(hadc)
-  { }
 
   Adc(const Adc&) = delete;
   Adc(Adc&&) = delete;
@@ -56,16 +51,13 @@ struct Adc
 
   void startDma()
   {
-    HAL_ADC_Start_DMA(hadc, reinterpret_cast<std::uint32_t*>(readings.data()), readingsCount());
+    HAL_ADC_Start_DMA(hadc, reinterpret_cast<std::uint32_t*>(readings.data()),
+                      readingsCount());
   }
 
-  void stopDma()
+  void stopDma() { HAL_ADC_Stop_DMA(hadc); }
-  {
-    HAL_ADC_Stop_DMA(hadc);
-  }
 };
 
-}
+}// namespace Peripherals
-
 
 #endif /* PERIPHERALS_INC_PERIPHERALS_ADC_HPP_ */

Peripherals/Inc/peripherals_hal_st.hpp

@@ -22,16 +22,14 @@ namespace St
 {
 
 template<typename Origin>
-using IsrCallbackFn = void(*)(Origin*);
+using IsrCallbackFn = void (*)(Origin*);
 
-template<typename Origin, typename Handler, void (Handler::*func)(), typename Tag>
+template<typename Origin, typename Handler, void (Handler::*func)(),
+         typename Tag>
 IsrCallbackFn<Origin> createCallback(Handler& h_in)
 {
   static Handler* h = &h_in;
-  return +[](Origin*)
+  return +[](Origin*) { (h->*func)(); };
-    {
-      (h->*func)();
-    };
 }
 
 struct StaticHal
@@ -56,21 +54,16 @@ struct StaticHal
     const std::uint32_t tick_start = DWT->CYCCNT;
     const std::uint32_t ticks_delay = micros * (SystemCoreClock / 1'000'000);
 
-  while (DWT->CYCCNT - tick_start < ticks_delay);
+    while (DWT->CYCCNT - tick_start < ticks_delay)
+      ;
 #else
-  (void)micros;
+    (void) micros;
 #endif
   }
 
-  static void enableInterrupts()
+  static void enableInterrupts() { __enable_irq(); }
-  {
-    __enable_irq();
-  }
 
-  static void disableInterrupts()
+  static void disableInterrupts() { __disable_irq(); }
-  {
-    __disable_irq();
-  }
 };
 
 #ifdef HAL_GPIO_MODULE_ENABLED
@@ -82,40 +75,33 @@ struct Gpio
 
   Gpio() = delete;
   explicit Gpio(GPIO_TypeDef* port, const std::uint16_t pin)
-    : port(port)
+      : port(port), pin(pin) {}
-    , pin(pin)
-  { }
 
   void Set(const bool& state)
   {
     HAL_GPIO_WritePin(port, pin, GPIO_PinState(state));
   }
 
-  void Toggle()
+  void Toggle() { HAL_GPIO_TogglePin(port, pin); }
-  {
-    HAL_GPIO_TogglePin(port, pin);
-  }
 
-  bool Read() const
+  bool Read() const { return HAL_GPIO_ReadPin(port, pin); }
-  {
-    return HAL_GPIO_ReadPin(port, pin);
-  }
 };
 
-#endif // HAL_GPIO_MODULE_ENABLED
+#endif// HAL_GPIO_MODULE_ENABLED
 
-template<typename T,
+template<
-        HAL_StatusTypeDef (*transmit)(T*, std::uint8_t* data, std::uint16_t data_len, std::uint32_t timeout),
+        typename T,
-        HAL_StatusTypeDef (*receive)(T*, std::uint8_t* data, std::uint16_t data_len, std::uint32_t timeout)>
+        HAL_StatusTypeDef (*transmit)(
+                T*, std::uint8_t* data, std::uint16_t data_len, std::uint32_t timeout),
+        HAL_StatusTypeDef (*receive)(T*, std::uint8_t* data,
+                                     std::uint16_t data_len, std::uint32_t timeout)>
 struct SerialInterface
 {
   using underlying_handle_type = T;
   underlying_handle_type* handle;
 
   SerialInterface() = delete;
-  explicit SerialInterface(underlying_handle_type* handle)
+  explicit SerialInterface(underlying_handle_type* handle) : handle(handle) {}
-    : handle(handle)
-  { }
 
   bool Transmit(std::uint8_t* data, const std::uint32_t data_len)
   {
@@ -129,8 +115,10 @@ struct SerialInterface
 };
 
 template<typename T,
-        HAL_StatusTypeDef (*transmit)(T*, std::uint8_t* data, std::uint16_t data_len),
+         HAL_StatusTypeDef (*transmit)(T*, std::uint8_t* data,
-        HAL_StatusTypeDef (*receive)(T*, std::uint8_t* data, std::uint16_t data_len)>
+                                       std::uint16_t data_len),
+         HAL_StatusTypeDef (*receive)(T*, std::uint8_t* data,
+                                      std::uint16_t data_len)>
 struct SerialInterfaceAsync
 {
   using underlying_handle_type = T;
@@ -138,8 +126,7 @@ struct SerialInterfaceAsync
 
   SerialInterfaceAsync() = delete;
   explicit SerialInterfaceAsync(underlying_handle_type* handle)
-    : handle(handle)
+      : handle(handle) {}
-  { }
 
   bool Transmit(std::uint8_t* data, const std::uint32_t data_len)
   {
@@ -154,7 +141,8 @@ struct SerialInterfaceAsync
 
 #ifdef HAL_SPI_MODULE_ENABLED
 
-using SpiInterface = SerialInterface<SPI_HandleTypeDef, HAL_SPI_Transmit, HAL_SPI_Receive>;
+using SpiInterface =
+        SerialInterface<SPI_HandleTypeDef, HAL_SPI_Transmit, HAL_SPI_Receive>;
 
 struct SpiRegisters
 {
@@ -163,9 +151,7 @@ struct SpiRegisters
 
   SpiRegisters() = delete;
   explicit SpiRegisters(const SpiInterface& handle, const Gpio& chip_select)
-    : handle(handle)
+      : handle(handle), chip_select(chip_select) {}
-    , chip_select(chip_select)
-  { }
 
   void WriteRegister(std::uint8_t reg, uint8_t data)
   {
@@ -177,7 +163,8 @@ struct SpiRegisters
     chip_select.Set(true);
   }
 
-  void WriteRegisterMultibyte(std::uint8_t reg, std::uint8_t* data, const std::uint32_t len)
+  void WriteRegisterMultibyte(std::uint8_t reg, std::uint8_t* data,
+                              const std::uint32_t len)
   {
     chip_select.Set(false);
 
@@ -187,7 +174,8 @@ struct SpiRegisters
     chip_select.Set(true);
   }
 
-  std::uint8_t ReadRegister(std::uint8_t reg, const std::uint32_t read_delay = 0)
+  std::uint8_t ReadRegister(std::uint8_t reg,
+                            const std::uint32_t read_delay = 0)
   {
     chip_select.Set(false);
 
@@ -205,7 +193,9 @@ struct SpiRegisters
     return output;
   }
 
-  void ReadRegisterMultibyte(std::uint8_t reg, std::uint8_t* data, const std::uint32_t len, const std::uint32_t read_delay = 0)
+  void ReadRegisterMultibyte(std::uint8_t reg, std::uint8_t* data,
+                             const std::uint32_t len,
+                             const std::uint32_t read_delay = 0)
   {
     chip_select.Set(false);
 
@@ -220,14 +210,17 @@ struct SpiRegisters
   }
 };
 
-#endif // HAL_SPI_MODULE_ENABLED
+#endif// HAL_SPI_MODULE_ENABLED
 
 #ifdef HAL_UART_MODULE_ENABLED
 
-using UartInterface = SerialInterface<UART_HandleTypeDef, HAL_UART_Transmit, HAL_UART_Receive>;
+using UartInterface =
-using UartInterfaceDMA = SerialInterfaceAsync<UART_HandleTypeDef, HAL_UART_Transmit_DMA, HAL_UART_Receive_DMA>;
+        SerialInterface<UART_HandleTypeDef, HAL_UART_Transmit, HAL_UART_Receive>;
+using UartInterfaceDMA =
+        SerialInterfaceAsync<UART_HandleTypeDef, HAL_UART_Transmit_DMA,
+                             HAL_UART_Receive_DMA>;
 
-#endif // HAL_UART_MODULE_ENABLED
+#endif// HAL_UART_MODULE_ENABLED
 
 #ifdef HAL_TIM_MODULE_ENABLED
 
@@ -238,32 +231,21 @@ struct PwmChannel
 
   PwmChannel() = delete;
   explicit PwmChannel(TIM_HandleTypeDef* handle, const std::uint32_t channel)
-    : handle(handle)
+      : handle(handle), channel(channel) {}
-    , channel(channel)
-  { }
 
-  void Enable()
+  void Enable() { HAL_TIM_PWM_Start(handle, channel); }
-  {
-    HAL_TIM_PWM_Start(handle, channel);
-  }
 
-  void Disable()
+  void Disable() { HAL_TIM_PWM_Stop(handle, channel); }
-  {
-    HAL_TIM_PWM_Stop(handle, channel);
-  }
 
   void SetCompare(const std::uint32_t compare)
   {
     __HAL_TIM_SET_COMPARE(handle, channel, compare);
   }
 
-  std::uint32_t MaxValue()
+  std::uint32_t MaxValue() { return handle->Init.Period; }
-  {
-    return handle->Init.Period;
-  }
 };
 
-#endif // HAL_TIM_MODULE_ENABLED
+#endif// HAL_TIM_MODULE_ENABLED
 
 struct ItmSerialInterface
 {
@@ -277,8 +259,8 @@ struct ItmSerialInterface
   }
 };
 
-}
+}// namespace St
-}
+}// namespace Hal
-}
+}// namespace Peripherals
 
 #endif /* PERIPHERALS_INC_PERIPHERALS_HAL_ST_HPP_ */

Peripherals/Inc/peripherals_imu.hpp

@@ -33,7 +33,6 @@ public:
   virtual void ReadAccelerometerRaw(std::int16_t* output) = 0;
 };
 
-}
+}// namespace Peripherals
-
 
 #endif /* PERIPHERALS_IMU_HPP_ */

Peripherals/Inc/peripherals_imu_icm.hpp

@@ -43,25 +43,29 @@ public:
   registers_handle registers;
 
   ImuIcm() = delete;
-	ImuIcm(const registers_handle& registers)
+  ImuIcm(const registers_handle& registers) : registers(registers) {}
-	  : registers(registers)
-	{ }
 
   void Setup() override
   {
-	  registers.WriteRegister(_Registers::PWR_MGMT_1 & _Registers::WRITE_MASK, 0b10000000);
+    registers.WriteRegister(_Registers::PWR_MGMT_1 & _Registers::WRITE_MASK,
+                            0b10000000);
     hal::Delay(10);
 
-	  registers.WriteRegister(_Registers::USER_CTRL & _Registers::WRITE_MASK, 0b00010000);
+    registers.WriteRegister(_Registers::USER_CTRL & _Registers::WRITE_MASK,
+                            0b00010000);
     hal::Delay(10);
 
-	  registers.WriteRegister(_Registers::PWR_MGMT_1 & _Registers::WRITE_MASK, 0b00000000);
+    registers.WriteRegister(_Registers::PWR_MGMT_1 & _Registers::WRITE_MASK,
+                            0b00000000);
     hal::Delay(10);
 
-	  registers.WriteRegister(_Registers::PWR_MGMT_1 & _Registers::WRITE_MASK, 0b00000001);
+    registers.WriteRegister(_Registers::PWR_MGMT_1 & _Registers::WRITE_MASK,
+                            0b00000001);
     hal::Delay(10);
 
-	  registers.WriteRegister(_Registers::CONFIG & _Registers::WRITE_MASK, 0x03); // DLPF_CFG = 3, gyro filter = 41/59.0, gyro rate = 1KHz, temp filter = 42
+    registers.WriteRegister(_Registers::CONFIG & _Registers::WRITE_MASK,
+                            0x03);// DLPF_CFG = 3, gyro filter = 41/59.0, gyro
+                                  // rate = 1KHz, temp filter = 42
     hal::Delay(10);
 
     SetGyroscopeScale(_scale_gyro);
@@ -69,10 +73,12 @@ public:
     SetAccelerometerScale(_scale_accel);
 
     // ACCEL_FCHOICE_B = 0, A_DLPF_CFG = 3 filter=44.8/61.5 rate=1KHz
-	  registers.WriteRegister(_Registers::ACCEL_CONFIG2 & _Registers::WRITE_MASK, 0x03);
+    registers.WriteRegister(_Registers::ACCEL_CONFIG2 & _Registers::WRITE_MASK,
+                            0x03);
     hal::Delay(10);
 
-	  // SAMPLE_RATE = INTERNAL_SAMPLE_RATE / (1 + SMPLRT_DIV) Where INTERNAL_SAMPLE_RATE = 1kHz
+    // SAMPLE_RATE = INTERNAL_SAMPLE_RATE / (1 + SMPLRT_DIV) Where
+    // INTERNAL_SAMPLE_RATE = 1kHz
     registers.WriteRegister(_Registers::SMPLRT_DIV & _Registers::WRITE_MASK, 0);
     hal::Delay(10);
 
@@ -82,7 +88,8 @@ public:
     // INT/DRDY pin is configured as push-pull.
     // INT/DRDY pin indicates interrupt pulse's width is 50us.
     // Interrupt status is cleared only by reading INT_STATUS register
-	  registers.WriteRegister(_Registers::INT_PIN_CFG & _Registers::WRITE_MASK, 0);
+    registers.WriteRegister(_Registers::INT_PIN_CFG & _Registers::WRITE_MASK,
+                            0);
     hal::Delay(10);
 
     registers.WriteRegister(_Registers::INT_ENABLE & _Registers::WRITE_MASK, 1);
@@ -97,8 +104,7 @@ public:
     for (std::uint32_t i = 0; i < samples; i++)
     {
       std::array<std::int16_t, 3> raw;
-	    auto add_to_avg = [&raw](std::array<std::int32_t, 3>& out)
+      auto add_to_avg = [&raw](std::array<std::int32_t, 3>& out) {
-	    {
         for (std::uint32_t j = 0; j < 3; j++)
           out[j] += raw[j];
       };
@@ -124,26 +130,33 @@ public:
 
   void SetGyroscopeScale(const GyroScale scale)
   {
-	  const std::uint8_t current_config = registers.ReadRegister(_Registers::GYRO_CONFIG | _Registers::READ_MASK);
+    const std::uint8_t current_config =
-	  const std::uint8_t new_config = (current_config & 0xE7) | (std::uint8_t(scale) << 3);
+            registers.ReadRegister(_Registers::GYRO_CONFIG | _Registers::READ_MASK);
-	  registers.WriteRegister(_Registers::GYRO_CONFIG & _Registers::WRITE_MASK, new_config);
+    const std::uint8_t new_config =
+            (current_config & 0xE7) | (std::uint8_t(scale) << 3);
+    registers.WriteRegister(_Registers::GYRO_CONFIG & _Registers::WRITE_MASK,
+                            new_config);
 
     _scale_gyro = scale;
   }
 
   void SetAccelerometerScale(const AccelerometerScale scale)
   {
-	  const std::uint8_t current_config = registers.ReadRegister(_Registers::ACCEL_CONFIG | _Registers::READ_MASK);
+    const std::uint8_t current_config = registers.ReadRegister(
-	  const std::uint8_t new_config = (current_config & 0xE7) | (std::uint8_t(scale) << 3);
+            _Registers::ACCEL_CONFIG | _Registers::READ_MASK);
-	  registers.WriteRegister(_Registers::ACCEL_CONFIG & _Registers::WRITE_MASK, new_config);
+    const std::uint8_t new_config =
+            (current_config & 0xE7) | (std::uint8_t(scale) << 3);
+    registers.WriteRegister(_Registers::ACCEL_CONFIG & _Registers::WRITE_MASK,
+                            new_config);
 
     _scale_accel = scale;
   }
 
   void ReadGyro(float* output) override
   {
-	  uint8_t data[6] = { 0 };
+    uint8_t data[6] = {0};
-	  registers.ReadRegisterMultibyte(_Registers::GYRO_XOUT_H | _Registers::READ_MASK, data, 6);
+    registers.ReadRegisterMultibyte(
+            _Registers::GYRO_XOUT_H | _Registers::READ_MASK, data, 6);
 
     for (std::uint32_t i = 0; i < 3; i++)
     {
@@ -154,8 +167,9 @@ public:
 
   void ReadGyroRaw(std::int16_t* output) override
   {
-	  uint8_t data[6] = { 0 };
+    uint8_t data[6] = {0};
-	  registers.ReadRegisterMultibyte(_Registers::GYRO_XOUT_H | _Registers::READ_MASK, data, 6);
+    registers.ReadRegisterMultibyte(
+            _Registers::GYRO_XOUT_H | _Registers::READ_MASK, data, 6);
 
     for (std::uint32_t i = 0; i < 3; i++)
     {
@@ -165,8 +179,9 @@ public:
 
   void ReadAccelerometer(float* output) override
   {
-	  uint8_t data[6] = { 0 };
+    uint8_t data[6] = {0};
-	  registers.ReadRegisterMultibyte(_Registers::ACCEL_XOUT_H | _Registers::READ_MASK, data, 6);
+    registers.ReadRegisterMultibyte(
+            _Registers::ACCEL_XOUT_H | _Registers::READ_MASK, data, 6);
 
     for (std::uint32_t i = 0; i < 3; i++)
     {
@@ -177,8 +192,9 @@ public:
 
   void ReadAccelerometerRaw(std::int16_t* output) override
   {
-	  uint8_t data[6] = { 0 };
+    uint8_t data[6] = {0};
-	  registers.ReadRegisterMultibyte(_Registers::ACCEL_XOUT_H | _Registers::READ_MASK, data, 6);
+    registers.ReadRegisterMultibyte(
+            _Registers::ACCEL_XOUT_H | _Registers::READ_MASK, data, 6);
 
     for (std::uint32_t i = 0; i < 3; i++)
     {
@@ -214,18 +230,12 @@ private:
   std::array<std::int16_t, 3> _bias_accel;
 
   static constexpr float _accel_fs_to_bit_constants[4] = {
-	  (2.0f / 32768.0f),
+          (2.0f / 32768.0f), (4.0f / 32768.0f), (8.0f / 32768.0f),
-	  (4.0f / 32768.0f),
+          (16.0f / 32768.0f)};
-	  (8.0f / 32768.0f),
-	  (16.0f / 32768.0f)
-	};
 
   static constexpr float _gyro_fs_to_bit_constants[4] = {
-	  (250.0f / 32768.0f),
+          (250.0f / 32768.0f), (500.0f / 32768.0f), (1000.0f / 32768.0f),
-	  (500.0f / 32768.0f),
+          (2000.0f / 32768.0f)};
-	  (1000.0f / 32768.0f),
-	  (2000.0f / 32768.0f)
-	};
 
   struct _Registers
   {
@@ -237,8 +247,8 @@ private:
     static constexpr std::uint8_t SMPLRT_DIV = 0x19;
     static constexpr std::uint8_t CONFIG = 0x1A;
     static constexpr std::uint8_t GYRO_CONFIG = 0x1B;
-	  static constexpr std::uint8_t ACCEL_CONFIG =0x1C;
+    static constexpr std::uint8_t ACCEL_CONFIG = 0x1C;
-	  static constexpr std::uint8_t ACCEL_CONFIG2=0x1D;
+    static constexpr std::uint8_t ACCEL_CONFIG2 = 0x1D;
 
     static constexpr std::uint8_t INT_PIN_CFG = 0x37;
     static constexpr std::uint8_t INT_ENABLE = 0x38;
@@ -251,12 +261,12 @@ private:
     static constexpr std::uint8_t GYRO_ZOUT_H = 0x47;
     static constexpr std::uint8_t GYRO_ZOUT_L = 0x48;
 
-	  static constexpr std::uint8_t ACCEL_XOUT_H =0x3B;
+    static constexpr std::uint8_t ACCEL_XOUT_H = 0x3B;
-	  static constexpr std::uint8_t ACCEL_XOUT_L =0x3C;
+    static constexpr std::uint8_t ACCEL_XOUT_L = 0x3C;
-	  static constexpr std::uint8_t ACCEL_YOUT_H =0x3D;
+    static constexpr std::uint8_t ACCEL_YOUT_H = 0x3D;
-	  static constexpr std::uint8_t ACCEL_YOUT_L =0x3E;
+    static constexpr std::uint8_t ACCEL_YOUT_L = 0x3E;
-	  static constexpr std::uint8_t ACCEL_ZOUT_H =0x3F;
+    static constexpr std::uint8_t ACCEL_ZOUT_H = 0x3F;
-	  static constexpr std::uint8_t ACCEL_ZOUT_L =0x40;
+    static constexpr std::uint8_t ACCEL_ZOUT_L = 0x40;
 
     static constexpr std::uint8_t USER_CTRL = 0x6A;
     static constexpr std::uint8_t PWR_MGMT_1 = 0x6B;
@@ -285,6 +295,6 @@ constexpr float ImuIcm<T, HAL>::_accel_fs_to_bit_constants[4];
 template<typename T, typename HAL>
 constexpr float ImuIcm<T, HAL>::_gyro_fs_to_bit_constants[4];
 
-}
+}// namespace Peripherals
 
 #endif /* PERIPHERALS_IMU_ICM_HPP_ */

Peripherals/Inc/peripherals_motors.hpp

@@ -34,10 +34,9 @@ public:
   using single_motor = TwoChannelMotorData<T>;
   using gpio = I;
 
-	DualDrvMotors(const single_motor& left, const single_motor& right, const gpio& sleep_pin)
+  DualDrvMotors(const single_motor& left, const single_motor& right,
-    : _left(left)
+                const gpio& sleep_pin)
-    , _right(right)
+      : _left(left), _right(right), _sleep_pin(sleep_pin)
-    , _sleep_pin(sleep_pin)
   {
     _left.forward.Enable();
     _left.backward.Enable();
@@ -53,8 +52,7 @@ public:
     {
       _left.forward.SetCompare(left);
       _left.backward.SetCompare(0);
-	  }
+    } else
-	  else
     {
       _left.forward.SetCompare(0);
       _left.backward.SetCompare(-1 * left);
@@ -64,8 +62,7 @@ public:
     {
       _right.forward.SetCompare(right);
       _right.backward.SetCompare(0);
-	  }
+    } else
-	  else
     {
       _right.forward.SetCompare(0);
       _right.backward.SetCompare(-1 * right);
@@ -96,7 +93,6 @@ private:
   gpio _sleep_pin;
 };
 
-}
+}// namespace Peripherals
-
 
 #endif /* PERIPHERALS_MOTORS_HPP_ */

Peripherals/Inc/peripherals_pwm_channel.hpp

@@ -26,10 +26,8 @@ struct PwmChannel
 
   PwmChannel() = delete;
 
-	PwmChannel(TIM_HandleTypeDef* timer,
+  PwmChannel(TIM_HandleTypeDef* timer, const std::uint32_t channel,
-		const std::uint32_t channel,
+             const std::uint32_t timer_code, const Io& pin);
-		const std::uint32_t timer_code,
-		const Io& pin);
 
   void PinToPwm();
   void PinToGpio();
@@ -40,7 +38,6 @@ struct PwmChannel
   void SetCompare(const std::uint32_t compare);
 };
 
-}
+}// namespace Peripherals
-
 
 #endif /* PERIPHERALS_PWM_CHANNEL_HPP_ */

Peripherals/Inc/peripherals_rgb.hpp

@@ -36,9 +36,7 @@ struct Rgb
 
   Rgb() = delete;
   Rgb(const IOType& r, const IOType& g, const IOType& b)
-    : red(r)
+      : red(r), green(g), blue(b)
-    , green(g)
-    , blue(b)
   {
     Set(RgbColor::OFF);
   }
@@ -93,7 +91,6 @@ struct Rgb
   }
 };
 
-}
+}// namespace Peripherals
-
 
 #endif /* PERIPHERALS_INC_PERIPHERALS_RGB_HPP_ */

Peripherals/Inc/peripherals_utility.hpp

@@ -13,7 +13,7 @@
 namespace Peripherals
 {
 
-#define SKULLC_CONCAT_IMPL(x, y) x ## y
+#define SKULLC_CONCAT_IMPL(x, y) x##y
 #define SKULLC_CONCAT(x, y) SKULLC_CONCAT_IMPL(x, y)
 #define SKULLC_TAG struct SKULLC_CONCAT(SkullCTag_, __COUNTER__)
 
@@ -54,7 +54,6 @@ T ByteToTypeLE(const std::uint8_t a[N])
   return t;
 }
 
-}
+}// namespace Peripherals
-
 
 #endif /* PERIPHERALS_UTILITY_HPP_ */

Tests/main.cpp

@@ -2,5 +2,6 @@
 // Created by erki on 13.03.21.
 //
 
-#define CATCH_CONFIG_MAIN  // This tells Catch to provide a main() - only do this in one cpp file
+#define CATCH_CONFIG_MAIN// This tells Catch to provide a main() - only do this \
+                         // in one cpp file
 #include <catch2/catch.hpp>

Tests/packet.cpp

@@ -12,7 +12,7 @@ TEST_CASE("Packet copy_data_in copies data in.", "[messaging],[packet]")
 
   SECTION("Plain C-array data copies properly.")
   {
-    const std::uint8_t data[2] = { 'C', 'D' };
+    const std::uint8_t data[2] = {'C', 'D'};
     const std::uint32_t data_size = sizeof(data);
 
     packet.copy_data_in(data);
@@ -24,7 +24,7 @@ TEST_CASE("Packet copy_data_in copies data in.", "[messaging],[packet]")
 
   SECTION("STL data copies properly.")
   {
-    const std::array<std::uint8_t, 2> data = { 'C', 'D' };
+    const std::array<std::uint8_t, 2> data = {'C', 'D'};
 
     packet.copy_data_in(data);
 
@@ -34,11 +34,12 @@ TEST_CASE("Packet copy_data_in copies data in.", "[messaging],[packet]")
   }
 }
 
-TEST_CASE("Packet copying data in cuts off excess bytes.", "[messaging],[packet]")
+TEST_CASE("Packet copying data in cuts off excess bytes.",
+          "[messaging],[packet]")
 {
   Messaging::Packet<2> packet;
 
-  const std::uint8_t data[4] = { 'C', 'D', 'E', 'F' };
+  const std::uint8_t data[4] = {'C', 'D', 'E', 'F'};
 
   packet.copy_data_in(data);
 
@@ -51,7 +52,7 @@ TEST_CASE("Packet gets serialized properly.", "[messaging],[packet]")
 {
   Messaging::Packet<2> packet;
 
-  const std::uint8_t data[2] = { 'C', 'D' };
+  const std::uint8_t data[2] = {'C', 'D'};
   const std::uint32_t data_size = sizeof(data);
 
   packet.copy_data_in(data);
@@ -82,14 +83,15 @@ TEST_CASE("Packet gets serialized properly.", "[messaging],[packet]")
   }
 }
 
-TEST_CASE("Packet serialization fails if buffer too small.", "[messaging],[packet]")
+TEST_CASE("Packet serialization fails if buffer too small.",
+          "[messaging],[packet]")
 {
   Messaging::Packet<2> packet;
 
-  const std::uint8_t data[2] = { 'C', 'D' };
+  const std::uint8_t data[2] = {'C', 'D'};
   packet.copy_data_in(data);
 
-  std::uint8_t output[4] = { 0 };
+  std::uint8_t output[4] = {0};
   REQUIRE(packet.serialize(output, sizeof(output)) == false);
 
   SECTION("Output buffer is left unmodified.")
@@ -103,9 +105,7 @@ TEST_CASE("Packet serialization fails if buffer too small.", "[messaging],[packe
 
 TEST_CASE("Packet deserialization works as expected.", "[messaging],[packet]")
 {
-  std::uint8_t data[] = {
+  std::uint8_t data[] = {'A', 'A', 0, 0, 0, 0, 'C', 'D'};
-      'A', 'A', 0, 0, 0, 0, 'C', 'D'
-  };
 
   const std::uint32_t data_length = 2;
   std::memcpy(data + 2, &data_length, sizeof(data_length));
@@ -118,11 +118,10 @@ TEST_CASE("Packet deserialization works as expected.", "[messaging],[packet]")
   REQUIRE(packet.data[1] == 'D');
 }
 
-TEST_CASE("Packet deserialization fails with invalid conditions.", "[messaging],[packet]")
+TEST_CASE("Packet deserialization fails with invalid conditions.",
+          "[messaging],[packet]")
 {
-  std::uint8_t data[] = {
+  std::uint8_t data[] = {'A', 'A', 0, 0, 0, 0, 'C', 'D'};
-      'A', 'A', 0, 0, 0, 0, 'C', 'D'
-  };
 
   const std::uint32_t data_length = 2;
   std::memcpy(data + 2, &data_length, sizeof(data_length));

Tests/parser.cpp

@@ -4,21 +4,20 @@
 
 #include <catch2/catch.hpp>
 
-#include <messaging_parser.hpp>
 #include <messaging_packet.hpp>
+#include <messaging_parser.hpp>
 
 using Packet = Messaging::Packet<2>;
 
 namespace
 {
 
-std::array<std::uint8_t, 2> test_data = { 'C', 'D' };
+std::array<std::uint8_t, 2> test_data = {'C', 'D'};
 
-std::array<std::uint8_t, 8> getRawData(const std::array<std::uint8_t, 2>& data)
+std::array<std::uint8_t, 8>
+getRawData(const std::array<std::uint8_t, 2>& data)
 {
-  std::array<std::uint8_t, 8> raw = {
+  std::array<std::uint8_t, 8> raw = {'A', 'A', 0, 0, 0, 0, data[0], data[1]};
-          'A', 'A', 0, 0, 0, 0, data[0], data[1]
-  };
 
   const std::uint32_t len = 2;
   std::memcpy(raw.data() + 2, &len, 4);
@@ -26,12 +25,9 @@ std::array<std::uint8_t, 8> getRawData(const std::array<std::uint8_t, 2>& data)
   return raw;
 }
 
-std::array<std::uint8_t, 8> getRawData()
+std::array<std::uint8_t, 8> getRawData() { return getRawData({'C', 'D'}); }
-{
-  return getRawData({'C', 'D'});
-}
 
-}
+}// namespace
 
 TEST_CASE("Parser parses raw message successfully.", "[messaging],[parser]")
 {
@@ -66,7 +62,7 @@ TEST_CASE("Parser ignores extra bytes when done.", "[messaging],[parser]")
 
   REQUIRE(parser.packetReady());
 
-  for (const std::uint8_t& byte : getRawData({ 'E', 'F' }))
+  for (const std::uint8_t& byte : getRawData({'E', 'F'}))
   {
     parser.pushByte(byte);
   }
@@ -82,12 +78,12 @@ TEST_CASE("Parser ignores extra bytes when done.", "[messaging],[parser]")
   }
 }
 
-TEST_CASE("Parser ignores junk data until header is spotted.", "[messaging],[parser]")
+TEST_CASE("Parser ignores junk data until header is spotted.",
+          "[messaging],[parser]")
 {
   Messaging::Parser<Packet, Packet::totalLength()> parser;
-  const std::array<std::uint8_t, 8> junk_data = {
+  const std::array<std::uint8_t, 8> junk_data = {'E', 'F', 'A', 'H',
-          'E', 'F', 'A', 'H', 'I', 'J', 'K', 'L'
+                                                 'I', 'J', 'K', 'L'};
-  };
 
   for (const std::uint8_t& byte : junk_data)
   {

Tests/ringbuffer.cpp

@@ -155,15 +155,9 @@ TEST_CASE("Ringbuffer adding single element.", "[utility],[ringbuffer]")
     REQUIRE(!buffer.empty());
   }
 
-  SECTION("Updates end() appropriately.")
+  SECTION("Updates end() appropriately.") { REQUIRE(old_end != buffer.end()); }
-  {
-    REQUIRE(old_end != buffer.end());
-  }
 
-  SECTION("begin() remains the same.")
+  SECTION("begin() remains the same.") { REQUIRE(old_begin == buffer.begin()); }
-  {
-    REQUIRE(old_begin == buffer.begin());
-  }
 
   SECTION("Makes begin() refer to the inserted member.")
   {
@@ -224,7 +218,8 @@ TEST_CASE("Ringbuffer adding multiple elements.", "[utility],[ringbuffer]")
   }
 }
 
-TEST_CASE("Ringbuffer removing elements from the ringbuffer.", "[utility],[ringbuffer]")
+TEST_CASE("Ringbuffer removing elements from the ringbuffer.",
+          "[utility],[ringbuffer]")
 {
   Ringbuffer<10> buffer;
   const auto old_begin = buffer.begin();
@@ -245,30 +240,21 @@ TEST_CASE("Ringbuffer removing elements from the ringbuffer.", "[utility],[ringb
     REQUIRE(buffer.begin() - old_begin == 1);
   }
 
-  SECTION("Updates size() appropriately.")
+  SECTION("Updates size() appropriately.") { REQUIRE(buffer.size() == 2); }
-  {
-    REQUIRE(buffer.size() == 2);
-  }
 
   SECTION("Erasing remaining elements")
   {
     buffer.pop_front();
     buffer.pop_front();
 
-    SECTION("Updates empty() appropriately.")
+    SECTION("Updates empty() appropriately.") { REQUIRE(buffer.empty()); }
-    {
-      REQUIRE(buffer.empty());
-    }
 
     SECTION("Updates begin() and end() appropriately.")
     {
       REQUIRE(buffer.begin() == buffer.end());
     }
 
-    SECTION("Updates size() appropriately.")
+    SECTION("Updates size() appropriately.") { REQUIRE(buffer.size() == 0); }
-    {
-      REQUIRE(buffer.size() == 0);
-    }
   }
 }
 
@@ -295,7 +281,8 @@ TEST_CASE("Ringbuffer clearing a ringbuffer works.", "[utility],[ringbuffer]")
   }
 }
 
-TEST_CASE("Ringbuffer manually incrementing tail works.", "[utility],[ringbuffer]")
+TEST_CASE("Ringbuffer manually incrementing tail works.",
+          "[utility],[ringbuffer]")
 {
   Ringbuffer<10> buffer;
 
@@ -314,7 +301,8 @@ TEST_CASE("Ringbuffer manually incrementing tail works.", "[utility],[ringbuffer
   }
 }
 
-TEST_CASE("Ringbuffer manually incrementing tail from empty state works.", "[utility],[ringbuffer]")
+TEST_CASE("Ringbuffer manually incrementing tail from empty state works.",
+          "[utility],[ringbuffer]")
 {
   Ringbuffer<10> buffer;
 
@@ -362,7 +350,8 @@ TEST_CASE("Ringbuffer manually incrementing tail from empty state works.", "[uti
   }
 }
 
-TEST_CASE("Ringbuffer manually incrementing tail when full deletes data.", "[utility],[ringbuffer]")
+TEST_CASE("Ringbuffer manually incrementing tail when full deletes data.",
+          "[utility],[ringbuffer]")
 {
   Ringbuffer<2> buffer;
 

Utility/Inc/utility_asynclogger.hpp

@@ -9,8 +9,8 @@
 #define UTILITY_INC_UTILITY_ASYNCLOGGER_HPP_
 
 #include "utility_atomicscopeguard.hpp"
-#include "utility_ringbuffer.hpp"
 #include "utility_ilogger.hpp"
+#include "utility_ringbuffer.hpp"
 
 #include <array>
 #include <cstdarg>
@@ -19,7 +19,8 @@
 namespace Utility
 {
 
-template<typename T, typename H, std::size_t BufferCount, std::size_t BufferSize>
+template<typename T, typename H, std::size_t BufferCount,
+         std::size_t BufferSize>
 class AsyncLogger : public ILogger
 {
 public:
@@ -27,9 +28,7 @@ public:
   using hal = H;
 
   AsyncLogger() = delete;
-  explicit AsyncLogger(const serial_interface& serial)
+  explicit AsyncLogger(const serial_interface& serial) : _serial(serial) {}
-    : _serial(serial)
-  { }
 
   AsyncLogger(const AsyncLogger&) = delete;
   AsyncLogger(AsyncLogger&&) = delete;
@@ -49,7 +48,8 @@ public:
     va_start(args, format);
 
     _Data& tail = (*_buffer_queue.end());
-    tail.length = vsnprintf(tail.buffer.data(), tail.buffer.size(), format, args);
+    tail.length =
+            vsnprintf(tail.buffer.data(), tail.buffer.size(), format, args);
 
     {
       AtomicScopeGuard<hal> s;
@@ -86,12 +86,12 @@ private:
     _in_flight = true;
 
     _Data& head = _buffer_queue.front();
-    _serial.Transmit(reinterpret_cast<uint8_t*>(head.buffer.data()), head.length);
+    _serial.Transmit(reinterpret_cast<uint8_t*>(head.buffer.data()),
+                     head.length);
     _buffer_queue.pop_front();
   }
 };
 
-}
+}// namespace Utility
-
 
 #endif /* UTILITY_INC_UTILITY_ASYNCLOGGER_HPP_ */

Utility/Inc/utility_atomicscopeguard.hpp

@@ -36,7 +36,6 @@ struct AtomicScopeGuard
       hal::enableInterrupts();
   }
 
-
 private:
   static std::int32_t _reentrancy_counter;
 };
@@ -44,6 +43,6 @@ private:
 template<typename H>
 std::int32_t AtomicScopeGuard<H>::_reentrancy_counter = 0;
 
-}
+}// namespace Utility
 
 #endif /* UTILITY_INC_UTILITY_ATOMICSCOPEGUARD_HPP_ */

Utility/Inc/utility_ilogger.hpp

@@ -26,14 +26,8 @@ public:
     LOG_FATAL
   };
 
-  constexpr static const char* level_strs[] = {
+  constexpr static const char* level_strs[] = {"DEBUG", "INFO", "NOTICE",
-    "DEBUG",
+                                               "WARNING", "ERROR", "FATAL"};
-    "INFO",
-    "NOTICE",
-    "WARNING",
-    "ERROR",
-    "FATAL"
-  };
 
   ILogger() = default;
   ILogger(const ILogger&) = delete;
@@ -44,6 +38,6 @@ public:
   virtual void log(const char* format, ...) = 0;
 };
 
-}
+}// namespace Utility
 
-#endif //SKULLC_UTILITY_ILOGGER_HPP_
+#endif// SKULLC_UTILITY_ILOGGER_HPP_

Utility/Inc/utility_logging.hpp

@@ -7,13 +7,22 @@
 
 #include "utility_ilogger.hpp"
 
-#define SKULLC_LOG(sev, msg, ...) Utility::skullc_logger->log("%s: "  msg  "\n\r", Utility::ILogger::level_strs[std::uint8_t(sev)], ## __VA_ARGS__)
+#define SKULLC_LOG(sev, msg, ...)                                              \
-#define SKULLC_LOG_DEBUG(msg, ...) SKULLC_LOG(Utility::ILogger::LogLevel::LOG_DEBUG, msg, ## __VA_ARGS__)
+  Utility::skullc_logger->log("%s: " msg "\n\r",                               \
-#define SKULLC_LOG_INFO(msg, ...) SKULLC_LOG(Utility::ILogger::LogLevel::LOG_INFO, msg, ## __VA_ARGS__)
+                              Utility::ILogger::level_strs[std::uint8_t(sev)], \
-#define SKULLC_LOG_NOTICE(msg, ...) SKULLC_LOG(Utility::ILogger::LogLevel::LOG_NOTICE, msg, ## __VA_ARGS__)
+                              ##__VA_ARGS__)
-#define SKULLC_LOG_WARNING(msg, ...) SKULLC_LOG(Utility::ILogger::LogLevel::LOG_WARNING, msg, ## __VA_ARGS__)
+#define SKULLC_LOG_DEBUG(msg, ...) \
-#define SKULLC_LOG_ERROR(msg, ...) SKULLC_LOG(Utility::ILogger::LogLevel::LOG_ERROR, msg, ## __VA_ARGS__)
+  SKULLC_LOG(Utility::ILogger::LogLevel::LOG_DEBUG, msg, ##__VA_ARGS__)
-#define SKULLC_LOG_FATAL(msg, ...) SKULLC_LOG(Utility::ILogger::LogLevel::LOG_FATAL, msg, ## __VA_ARGS__)
+#define SKULLC_LOG_INFO(msg, ...) \
+  SKULLC_LOG(Utility::ILogger::LogLevel::LOG_INFO, msg, ##__VA_ARGS__)
+#define SKULLC_LOG_NOTICE(msg, ...) \
+  SKULLC_LOG(Utility::ILogger::LogLevel::LOG_NOTICE, msg, ##__VA_ARGS__)
+#define SKULLC_LOG_WARNING(msg, ...) \
+  SKULLC_LOG(Utility::ILogger::LogLevel::LOG_WARNING, msg, ##__VA_ARGS__)
+#define SKULLC_LOG_ERROR(msg, ...) \
+  SKULLC_LOG(Utility::ILogger::LogLevel::LOG_ERROR, msg, ##__VA_ARGS__)
+#define SKULLC_LOG_FATAL(msg, ...) \
+  SKULLC_LOG(Utility::ILogger::LogLevel::LOG_FATAL, msg, ##__VA_ARGS__)
 
 namespace Utility
 {
@@ -23,6 +32,6 @@ extern ILogger* skullc_logger;
 void setLogger(ILogger* log);
 void setLogger(ILogger& log);
 
-}
+}// namespace Utility
 
-#endif //UTILITY_LOGGING_HPP_
+#endif// UTILITY_LOGGING_HPP_

Utility/Inc/utility_ringbuffer.hpp

@@ -9,8 +9,8 @@
 #define UTILITY_RINGBUFFER_HPP_
 
 #include <array>
-#include <iterator>
 #include <cstddef>
+#include <iterator>
 
 namespace Utility
 {
@@ -36,24 +36,15 @@ public:
     using reference = value_type&;
 
     iterator(const pointer ptr, const pointer begin, const pointer end)
-		  : _ptr(ptr)
+        : _ptr(ptr), _arr_begin(begin), _arr_end(end) {}
-		  , _arr_begin(begin)
-		  , _arr_end(end)
-		{ }
     iterator(const iterator&) = default;
     iterator(iterator&&) noexcept = default;
 
     iterator& operator=(const iterator&) = default;
 
-		reference operator*() const
+    reference operator*() const { return *_ptr; }
-		{
-			return *_ptr;
-		}
 
-		pointer operator->()
+    pointer operator->() { return _ptr; }
-		{
-			return _ptr;
-		}
 
     iterator& operator++()
     {
@@ -77,11 +68,11 @@ public:
       if (naive < _arr_end)
       {
         return iterator(naive, _arr_begin, _arr_end);
-      }
+      } else
-      else
       {
         const pointer remainder = pointer(naive - _arr_end);
-        return iterator(_arr_begin + difference_type(remainder), _arr_begin, _arr_end);
+        return iterator(_arr_begin + difference_type(remainder), _arr_begin,
+                        _arr_end);
       }
     }
 
@@ -91,11 +82,11 @@ public:
       if (naive >= _arr_begin)
       {
         return iterator(naive, _arr_begin, _arr_end);
-      }
+      } else
-		  else
       {
         const pointer remainder = pointer(_arr_begin - naive);
-		    return iterator(_arr_end - difference_type(remainder), _arr_begin, _arr_end);
+        return iterator(_arr_end - difference_type(remainder), _arr_begin,
+                        _arr_end);
       }
     }
 
@@ -125,28 +116,16 @@ public:
     pointer _arr_end;
   };
 
-	Ringbuffer()
+  Ringbuffer() : _head(&_data[0], &_data[0], &_data[N]), _tail(_head) {}
-	  : _head(&_data[0], &_data[0], &_data[N])
-	  , _tail(_head)
-	{ }
 
   Ringbuffer(const Ringbuffer&) = delete;
   Ringbuffer(Ringbuffer&&) noexcept = default;
 
-	iterator begin()
+  iterator begin() { return _head; }
-	{
-		return _head;
-	}
 
-	iterator end()
+  iterator end() { return _tail; }
-	{
-		return _tail;
-	}
 
-	void clear()
+  void clear() { _head = _tail; }
-  {
-	  _head = _tail;
-  }
 
   void push_back(const T& value)
   {
@@ -166,7 +145,7 @@ public:
     if (size() == N)
       return;
 
-		new (&*_tail)T(std::forward<Args>(args)...);
+    new (&*_tail) T(std::forward<Args>(args)...);
     ++_tail;
   }
 
@@ -187,15 +166,9 @@ public:
     _is_full = false;
   }
 
-	reference front()
+  reference front() { return *_head; }
-  {
-	  return *_head;
-  }
 
-  const_reference front() const
+  const_reference front() const { return *_head; }
-  {
-	  return *_head;
-  }
 
   reference back()
   {
@@ -223,27 +196,21 @@ public:
         return 0;
     }
 
-	  const typename Ringbuffer<T, N>::iterator::difference_type distance = _tail - _head;
+    const typename Ringbuffer<T, N>::iterator::difference_type distance =
+            _tail - _head;
 
     if (distance > 0)
     {
       return distance;
-    }
+    } else
-    else
     {
       return _head - _tail + 1;
     }
   }
 
-  constexpr size_type max_size() const
+  constexpr size_type max_size() const { return N; }
-  {
-    return N;
-  }
 
-  bool empty() const
+  bool empty() const { return size() == 0; }
-  {
-	  return size() == 0;
-  }
 
 private:
   std::array<T, N> _data;
@@ -253,7 +220,6 @@ private:
   iterator _tail;
 };
 
-}
+}// namespace Utility
-
 
 #endif /* UTILITY_RINGBUFFER_HPP_ */

Utility/Inc/utility_seriallogger.hpp

@@ -24,16 +24,15 @@ public:
   using serial_interface = T;
 
   SerialLogger() = delete;
-  explicit SerialLogger(const serial_interface& serial)
+  explicit SerialLogger(const serial_interface& serial) : _serial(serial) {}
-    : _serial(serial)
-  { }
 
   void log(const char* format, ...) override
   {
     std::va_list args;
     va_start(args, format);
 
-    const std::int32_t len = vsnprintf(_buffer.data(), _buffer.size(), format, args);
+    const std::int32_t len =
+            vsnprintf(_buffer.data(), _buffer.size(), format, args);
 
     if (len > 0)
       _serial.Transmit(reinterpret_cast<std::uint8_t*>(_buffer.data()), len);
@@ -46,7 +45,6 @@ private:
   std::array<char, N> _buffer;
 };
 
-}
+}// namespace Utility
-
 
 #endif /* UTILITY_INC_UTILITY_SERIALLOGGER_HPP_ */

Utility/Src/utility_logging.cpp

@@ -12,14 +12,8 @@ namespace Utility
 
 ILogger* skullc_logger = nullptr;
 
-void setLogger(ILogger* log)
+void setLogger(ILogger* log) { skullc_logger = log; }
-{
-  skullc_logger = log;
-}
 
-void setLogger(ILogger& log)
+void setLogger(ILogger& log) { skullc_logger = &log; }
-{
-  skullc_logger = &log;
-}
 
-}
+}// namespace Utility