Run clang-tidy

MaartenS11 · MaartenS11 · commit f1e563df257b · 2025-04-28T17:52:30.000+02:00
diff --git a/src/Primitives/Mindstorms/Motor.cpp b/src/Primitives/Mindstorms/Motor.cpp
@@ -1,7 +1,9 @@
 #include "Motor.h"
+
 #include "../../Utils/macros.h"
 
-MotorEncoder::MotorEncoder(gpio_dt_spec pin5_encoder_spec, gpio_dt_spec pin6_encoder_spec, const char *name)
+MotorEncoder::MotorEncoder(gpio_dt_spec pin5_encoder_spec,
+                           gpio_dt_spec pin6_encoder_spec, const char *name)
     : pin5_encoder_spec(pin5_encoder_spec),
       pin6_encoder_spec(pin6_encoder_spec),
       angle(0),
@@ -14,10 +16,11 @@ MotorEncoder::MotorEncoder(gpio_dt_spec pin5_encoder_spec, gpio_dt_spec pin6_enc
         FATAL("Failed to configure GPIO encoder pin6\n");
     }
 
-    int result = gpio_pin_interrupt_configure_dt(&pin6_encoder_spec,
-                                             GPIO_INT_EDGE_RISING | GPIO_INT_EDGE_FALLING);
+    int result = gpio_pin_interrupt_configure_dt(
+        &pin6_encoder_spec, GPIO_INT_EDGE_RISING | GPIO_INT_EDGE_FALLING);
     if (result != 0) {
-        printf("Failed to configure interrupt on pin6 for %s, error code %d\n", name, result);
+        printf("Failed to configure interrupt on pin6 for %s, error code %d\n",
+               name, result);
     }
     gpio_init_callback(&pin6_encoder_cb_data,
                        MotorEncoder::encoder_pin6_edge_rising,
@@ -55,9 +58,7 @@ Motor::Motor(pwm_dt_spec pwm1_spec, pwm_dt_spec pwm2_spec,
              MotorEncoder *encoder)
     : pwm1_spec(pwm1_spec), pwm2_spec(pwm2_spec), encoder(encoder) {}
 
-void Motor::halt() {
-    drive_pwm(pwm1_spec, pwm2_spec, 1.0f, 1.0f);
-}
+void Motor::halt() { drive_pwm(pwm1_spec, pwm2_spec, 1.0f, 1.0f); }
 
 bool Motor::set_speed(float speed) {
     float pwm1 = 0;
@@ -72,29 +73,31 @@ bool Motor::set_speed(float speed) {
 }
 
 void Motor::drive_to_target(int32_t speed) {
-    printf("drift = %d\n",
-           abs(get_drift()));
+    printf("drift = %d\n", abs(get_drift()));
 
     int drift = get_drift();
     // Reset stall timer, otherwise it will instantly think it's not moving.
     encoder->last_update = k_uptime_get();
     while (abs(drift) > 0) {
         int speed_sign = std::signbit(drift) ? -1 : 1;
         set_speed(speed_sign * speed / 10000.0f);
-        while (speed_sign *
-                       (get_drift()) >
-                   0 &&
+        while (speed_sign * (get_drift()) > 0 &&
                k_uptime_get() - encoder->get_last_update() < 150) {
         }
         bool not_moving = k_uptime_get() - encoder->get_last_update() >= 150;
         if (not_moving) {
             speed += 100;
-            printf("Not moving, increasing speed to %d, %llims since last movement\n", speed, k_uptime_get() - encoder->get_last_update());
+            printf(
+                "Not moving, increasing speed to %d, %llims since last "
+                "movement\n",
+                speed, k_uptime_get() - encoder->get_last_update());
             set_speed(speed_sign * speed / 10000.0f);
 
             // Wait for 10ms or movement.
             uint64_t start_time = k_uptime_get();
-            while (k_uptime_get() - start_time < 10 && k_uptime_get() - encoder->get_last_update() >= 150) {}
+            while (k_uptime_get() - start_time < 10 &&
+                   k_uptime_get() - encoder->get_last_update() >= 150) {
+            }
             continue;
         }
         encoder->last_update = k_uptime_get();
diff --git a/src/Primitives/Mindstorms/Motor.h b/src/Primitives/Mindstorms/Motor.h
@@ -1,18 +1,19 @@
 #ifndef WARDUINO_MOTOR_H
 #define WARDUINO_MOTOR_H
 
-#include <cstdint>
-#include <cmath>
-
 #include <zephyr/drivers/gpio.h>
 #include <zephyr/drivers/pwm.h>
 #include <zephyr/kernel.h>
 
+#include <cmath>
+#include <cstdint>
+
 class MotorEncoder {
     static void encoder_pin6_edge_rising(const struct device *dev,
                                          struct gpio_callback *cb,
                                          uint32_t pins) {
-        MotorEncoder *encoder = CONTAINER_OF(cb, MotorEncoder, pin6_encoder_cb_data);
+        MotorEncoder *encoder =
+            CONTAINER_OF(cb, MotorEncoder, pin6_encoder_cb_data);
 
         int rising = gpio_pin_get_raw(encoder->pin6_encoder_spec.port,
                                       encoder->pin6_encoder_spec.pin);
@@ -35,8 +36,9 @@ class MotorEncoder {
         encoder->last_update = k_uptime_get();
     }
 
-public:
-    MotorEncoder(gpio_dt_spec pin5_encoder_spec, gpio_dt_spec pin6_encoder_spec, const char *name);
+   public:
+    MotorEncoder(gpio_dt_spec pin5_encoder_spec, gpio_dt_spec pin6_encoder_spec,
+                 const char *name);
 
     ~MotorEncoder();
 
@@ -52,20 +54,20 @@ class MotorEncoder {
 
     [[nodiscard]] inline int64_t get_last_update() const { return last_update; }
 
-private:
+   private:
     gpio_dt_spec pin5_encoder_spec;
     gpio_dt_spec pin6_encoder_spec;
     struct gpio_callback pin5_encoder_cb_data;
     struct gpio_callback pin6_encoder_cb_data;
     volatile int angle;
     int target_angle;
 
-public:
+   public:
     volatile int64_t last_update;
 };
 
 class Motor {
-public:
+   public:
     Motor(pwm_dt_spec pwm1_spec, pwm_dt_spec pwm2_spec, MotorEncoder *encoder);
 
     pwm_dt_spec pwm1_spec;
@@ -87,6 +89,7 @@ bool drive_pwm(pwm_dt_spec pwm1_spec, pwm_dt_spec pwm2_spec, float pwm1,
 
 bool drive_motor(pwm_dt_spec pwm1_spec, pwm_dt_spec pwm2_spec, float speed);
 
-void drive_motor_to_target(pwm_dt_spec pwm1_spec, pwm_dt_spec pwm2_spec, MotorEncoder *encoder, int32_t speed);
+void drive_motor_to_target(pwm_dt_spec pwm1_spec, pwm_dt_spec pwm2_spec,
+                           MotorEncoder *encoder, int32_t speed);
 
 #endif  // WARDUINO_MOTOR_H
diff --git a/src/Primitives/Mindstorms/uart_sensor.cpp b/src/Primitives/Mindstorms/uart_sensor.cpp
@@ -1,10 +1,11 @@
 #include "uart_sensor.h"
 
-#include <cstdio>
 #include <zephyr/drivers/uart.h>
 
+#include <cstdio>
+
 void serial_cb(const struct device *dev, void *user_data) {
-    auto *sensor = static_cast<UartSensor*>(user_data);
+    auto *sensor = static_cast<UartSensor *>(user_data);
     uint8_t data;
 
     if (!uart_irq_update(dev)) {
@@ -16,6 +17,8 @@ void serial_cb(const struct device *dev, void *user_data) {
     }
 
     while (uart_fifo_read(dev, &data, 1) == 1) {
+        // printf("data: 0x%02x %c\n", data, data);
+
         if (sensor->receive_state == ReceiveState::data) {
             if (sensor->data_byte) {
                 sensor->sensor_value = data;
@@ -34,20 +37,22 @@ void serial_cb(const struct device *dev, void *user_data) {
             sensor->payload_bytes--;
 
             if (sensor->payload_bytes > 1) {
-                if (sensor->receive_state == ReceiveState::final_mode_format && sensor->payload_bytes == 5 && data != 0x80) {
+                if (sensor->receive_state == ReceiveState::final_mode_format &&
+                    sensor->payload_bytes == 5 && data != 0x80) {
                     sensor->receive_state = ReceiveState::advertise;
                     sensor->payload_bytes = 0;
                 }
                 sensor->checksum ^= data;
-                sensor->current_payload = sensor->current_payload |
-                                  (((unsigned long)data) << sensor->payload_index * 8);
+                sensor->current_payload =
+                    sensor->current_payload |
+                    (((unsigned long)data) << sensor->payload_index * 8);
                 sensor->payload_index++;
             } else if (sensor->checksum == data) {
                 if (sensor->receive_state == ReceiveState::advertise) {
                     printf("Baudrate = %d\n", sensor->current_payload);
-                    sensor->baudrate = (int) sensor->current_payload;
-                }
-                else if (sensor->receive_state == ReceiveState::final_mode_format){
+                    sensor->baudrate = (int)sensor->current_payload;
+                } else if (sensor->receive_state ==
+                           ReceiveState::final_mode_format) {
                     sensor->receive_state = ReceiveState::modes_complete;
                 }
             }
@@ -58,7 +63,8 @@ void serial_cb(const struct device *dev, void *user_data) {
             // If we receive an ACK after the final format message and we
             // know which speed to communicate at then we should send an ACK to
             // switch to data mode.
-            if (sensor->receive_state == ReceiveState::modes_complete && sensor->baudrate > 0) {
+            if (sensor->receive_state == ReceiveState::modes_complete &&
+                sensor->baudrate > 0) {
                 printf("Completing pairing sequence\n");
                 uart_poll_out(dev, 0b00000100);  // Send ACK back
                 sensor->receive_state = ReceiveState::data;
@@ -93,8 +99,8 @@ void set_sensor_mode(UartSensor *sensor, uint8_t new_mode) {
     uart_poll_out(sensor->dev, new_mode);
     uart_poll_out(sensor->dev, 0xff ^ 0x43 ^ new_mode);
 
-    // Invalidate current sensor values. This prevents the program reading values that it normally cannot read in a
-    // particular mode.
+    // Invalidate current sensor values. This prevents the program reading
+    // values that it normally cannot read in a particular mode.
     sensor->sensor_value = -1;
 }
 
@@ -117,7 +123,8 @@ bool configure_uart_sensor(UartSensor *sensor, uint8_t new_mode) {
         return false;
     }
     uart_irq_rx_enable(sensor->dev);
-    if (sensor->receive_state == ReceiveState::data && sensor->mode != new_mode) {
+    if (sensor->receive_state == ReceiveState::data &&
+        sensor->mode != new_mode) {
         set_sensor_mode(sensor, new_mode);
     }
     sensor->mode = new_mode;
@@ -153,9 +160,7 @@ void uartHeartbeat(UartSensor *sensor) {
     uart_poll_out(sensor->dev, 0b00000010);
 }
 
-bool sensor_ready(UartSensor *sensor) {
-    return device_is_ready(sensor->dev);
-}
+bool sensor_ready(UartSensor *sensor) { return device_is_ready(sensor->dev); }
 
 int get_sensor_value(UartSensor *sensor) {
     if (!sensor->baudrate_configured || sensor->sensor_value < 0) {
diff --git a/src/Primitives/Mindstorms/uart_sensor.h b/src/Primitives/Mindstorms/uart_sensor.h
@@ -1,13 +1,9 @@
 #pragma once
-#include <cstdint>
 #include <zephyr/device.h>
 
-enum ReceiveState {
-    advertise,
-    final_mode_format,
-    modes_complete,
-    data
-};
+#include <cstdint>
+
+enum ReceiveState { advertise, final_mode_format, modes_complete, data };
 
 struct UartSensor {
     // Variables used for setting up the sensor.
diff --git a/src/Primitives/zephyr.cpp b/src/Primitives/zephyr.cpp
@@ -27,13 +27,13 @@
 #include "../Memory/mem.h"
 #include "../Utils/macros.h"
 #include "../Utils/util.h"
-#include "primitives.h"
 #include "Mindstorms/Motor.h"
 #include "Mindstorms/uart_sensor.h"
+#include "primitives.h"
 
 #define OBB_PRIMITIVES 0
 #ifdef CONFIG_BOARD_STM32L496G_DISCO
-    #define OBB_PRIMITIVES 6
+#define OBB_PRIMITIVES 6
 #endif
 #define ALL_PRIMITIVES OBB_PRIMITIVES + 6
 
@@ -304,18 +304,19 @@ MotorEncoder *encoders[] = {new MotorEncoder(specs[51], specs[50], "Port A"),
                             new MotorEncoder(specs[17], specs[13], "Port C"),
                             new MotorEncoder(specs[27], specs[26], "Port D")};
 
-#define PWM_SPEC_GETTER(node_id, prop, idx) PWM_DT_SPEC_GET_BY_IDX(DT_PATH(zephyr_user), idx)
-struct pwm_dt_spec pwm_specs[] = {
-    DT_FOREACH_PROP_ELEM_SEP(DT_PATH(zephyr_user), pwms,
-                             PWM_SPEC_GETTER, (,))
-};
+#define PWM_SPEC_GETTER(node_id, prop, idx) \
+    PWM_DT_SPEC_GET_BY_IDX(DT_PATH(zephyr_user), idx)
+struct pwm_dt_spec pwm_specs[] = {DT_FOREACH_PROP_ELEM_SEP(
+    DT_PATH(zephyr_user), pwms, PWM_SPEC_GETTER, (, ))};
 
 std::optional<Motor> get_motor(uint32_t motor_index) {
-    if (motor_index > sizeof(encoders)/sizeof(*encoders)) {
+    if (motor_index > sizeof(encoders) / sizeof(*encoders)) {
         return {};
     }
 
-    return std::make_optional<Motor>(pwm_specs[motor_index * 2 + 1], pwm_specs[motor_index * 2], encoders[motor_index]);
+    return std::make_optional<Motor>(pwm_specs[motor_index * 2 + 1],
+                                     pwm_specs[motor_index * 2],
+                                     encoders[motor_index]);
 }
 
 def_prim(drive_motor, twoToNoneU32) {
@@ -364,17 +365,20 @@ def_prim(drive_motor_ms, threeToNoneU32) {
     return false;
 }
 
-bool drive_motor_degrees_absolute(uint32_t motor_index, int32_t degrees, int32_t speed) {
+bool drive_motor_degrees_absolute(uint32_t motor_index, int32_t degrees,
+                                  int32_t speed) {
     if (auto motor = get_motor(motor_index)) {
         motor->drive_to_angle(speed, degrees);
         return true;
     }
     return false;
 }
 
-bool drive_motor_degrees_relative(uint32_t motor_index, int32_t degrees, int32_t speed) {
+bool drive_motor_degrees_relative(uint32_t motor_index, int32_t degrees,
+                                  int32_t speed) {
     MotorEncoder *encoder = encoders[motor_index];
-    return drive_motor_degrees_absolute(motor_index, encoder->get_target_angle() + degrees, speed);
+    return drive_motor_degrees_absolute(
+        motor_index, encoder->get_target_angle() + degrees, speed);
 }
 
 def_prim(drive_motor_degrees, threeToNoneU32) {
@@ -398,7 +402,8 @@ def_prim_reverse(drive_motor_degrees) {
             // primitives instead of after and just not restore io when
             // restoring the last snapshot and transfer overrides from a future
             // snapshot when doing forward execution.
-            drive_motor_degrees_absolute(motor_index, (int32_t) state.value, motor_index == 0 ? 10000 : 2000);
+            drive_motor_degrees_absolute(motor_index, (int32_t)state.value,
+                                         motor_index == 0 ? 10000 : 2000);
         }
     }
 }
@@ -414,7 +419,7 @@ def_prim_serialize(drive_motor_degrees) {
 }
 
 static const struct device *const uart_dev =
-        DEVICE_DT_GET(DT_PROP(DT_PATH(zephyr_user), warduino_uarts));
+    DEVICE_DT_GET(DT_PROP(DT_PATH(zephyr_user), warduino_uarts));
 
 UartSensor sensor(uart_dev);
 
@@ -439,9 +444,7 @@ def_prim(color_sensor, oneToOneU32) {
 
 extern void read_debug_messages();
 
-void debug_work_handler(struct k_work *work) {
-    read_debug_messages();
-}
+void debug_work_handler(struct k_work *work) { read_debug_messages(); }
 
 K_WORK_DEFINE(debug_work, debug_work_handler);
 
