Merge branch 'gpio'

Author: jasonyang-ee

Application/Inc/GPIO.hpp

@@ -1,6 +1,7 @@
 #ifndef APPLICATION_INC_GPIO
 #define APPLICATION_INC_GPIO
 
+#include "StateMachine.hpp"
 #include "main.h"
 
 /**
@@ -12,27 +13,41 @@
 class CustomGPIO {
    public:
     CustomGPIO();
-    CustomGPIO(uint16_t);
+    CustomGPIO(uint16_t PollPeriod);
     virtual ~CustomGPIO();
-    void setPort(GPIO_TypeDef *, uint16_t);
-
-	void on();
-	void off();
-	void toggle();
+    void setPort(GPIO_TypeDef *Port, uint16_t Pin);
 
+    // Public Methods
+    void on();
+    void off();
+    void toggle();
     bool getStatus();
+    void scheduler();
 
-    void schedulerLowActive();
-    void schedulerHighActive();
+    // Hardware Data
+   private:
+    GPIO_TypeDef *port;
+    uint16_t pin;
 
+    // State Machine
+   public:
+    enum class State { ON, OFF, LOW_INACTIVE, LOW_SETTLING, LOW_ACTIVE, HIGH_INACTIVE, HIGH_SETTLING, HIGH_ACTIVE };
+    enum class Event { ON, OFF, TOGGLE, POLL };
+    SM<CustomGPIO>::StateMachine gpio_sm;
+
+    // Action and Guard
    private:
-    GPIO_TypeDef *m_port;
-    uint16_t m_pin;
+    Action actionOn();
+    Action actionOff();
+    Action actionToggle();
+
+    Guard guardLowSense();
+    Guard guardHighSense();
+    Guard guardStable();
 
-    uint16_t m_roll_period{100};
-    uint16_t m_roll_timer{0};
-    bool m_stable{true};
-    bool m_pressed{false};
+    // State Machine Data
+    uint16_t roll_period{100};
+    uint16_t roll_timer{0};
 };
 
 #endif /* APPLICATION_INC_GPIO */

Application/Src/GPIO.cpp

@@ -2,74 +2,97 @@
 
 /// @brief Default constructor for CustomGPIO.
 /// Initializes rollover period and state variables.
-CustomGPIO::CustomGPIO() {}
+CustomGPIO::CustomGPIO() {
+    // State Machine
+    // clang-format off
+    gpio_sm = {
+        State::OFF,
+        { // Entry definition: (TargetState, GuardFunction, ActionFunction, Injection)
+			{ State::OFF, {}, actionOff(), {} },
+			{ State::LOW_INACTIVE, {}, {}, {} },
+			{ State::HIGH_INACTIVE, {}, {}, {} },
+        },
+        { // Transition definition: (CurrentState, Event, NextState, GuardFunction, ActionFunction, Injection)
+            { State::ON, Event::OFF, State::OFF, {}, actionOff(), {} },
+            { State::OFF, Event::ON, State::ON, {}, actionOn(), {} },
+            { State::ON, Event::TOGGLE, State::OFF, {}, actionToggle(), {} },
+            { State::OFF, Event::TOGGLE, State::ON, {}, actionToggle(), {} },
+            { State::LOW_INACTIVE, Event::POLL, State::LOW_SETTLING, guardLowSense(), {}, {} },
+            { State::LOW_SETTLING, Event::POLL, State::LOW_ACTIVE, guardStable(), {}, {} },
+            { State::LOW_ACTIVE, Event::POLL, State::LOW_INACTIVE, {}, guardHighSense(), {} },
+			{ State::HIGH_INACTIVE, Event::POLL, State::HIGH_SETTLING, guardHighSense(), {}, {} },
+			{ State::HIGH_SETTLING, Event::POLL, State::HIGH_ACTIVE, guardStable(), {}, {} },
+			{ State::HIGH_ACTIVE, Event::POLL, State::HIGH_INACTIVE, {}, guardLowSense(), {} },
+        }
+    };
+    // clang-format on
+}
 
 /// @brief Constructor with custom debounce period.
 /// @param value Number of ticks for stable state detection.
-CustomGPIO::CustomGPIO(uint16_t value) { m_roll_period = value; }
+CustomGPIO::CustomGPIO(uint16_t PollPeriod) { roll_period = PollPeriod; }
 
 /// @brief Destructor for CustomGPIO.
 CustomGPIO::~CustomGPIO() {}
 
 /// @brief Configure the GPIO port and pin for this instance.
 /// @param port Pointer to the GPIO port (e.g., GPIOA).
 /// @param pin GPIO pin identifier (e.g., GPIO_PIN_0).
-void CustomGPIO::setPort(GPIO_TypeDef *port, uint16_t pin) {
-    m_port = port;
-    m_pin = pin;
+void CustomGPIO::setPort(GPIO_TypeDef *Port, uint16_t Pin) {
+    port = Port;
+    pin = Pin;
 }
 
 /// @brief Set the GPIO pin to a high logic level.
-void CustomGPIO::on() { HAL_GPIO_WritePin(m_port, m_pin, GPIO_PIN_SET); }
+void CustomGPIO::on() { gpio_sm.triggerEvent(Event::ON); }
 
 /// @brief Set the GPIO pin to a low logic level.
-void CustomGPIO::off() { HAL_GPIO_WritePin(m_port, m_pin, GPIO_PIN_RESET); }
+void CustomGPIO::off() { gpio_sm.triggerEvent(Event::OFF); }
 
 /// @brief Toggle the current state of the GPIO pin.
-void CustomGPIO::toggle() { HAL_GPIO_TogglePin(m_port, m_pin); }
+void CustomGPIO::toggle() { gpio_sm.triggerEvent(Event::TOGGLE); }
 
-/// @brief Debounce scheduler for active-low inputs.
-/// Monitors pin for stable falling-edge and marks press event.
-/// @note Call periodically to update internal status.
-void CustomGPIO::schedulerLowActive() {
-    if (m_stable) {
-        if (!HAL_GPIO_ReadPin(m_port, m_pin))
-            m_stable = false;
-        else
-            m_roll_timer = 0;
+bool CustomGPIO::getStatus() {
+    if (gpio_sm.currentState == State::ON) {
+        return true;
+    } else if (gpio_sm.currentState == State::LOW_ACTIVE) {
+        return true;
+    } else if (gpio_sm.currentState == State::HIGH_ACTIVE) {
+        return true;
     }
+    return false;
+}
 
-    else if (HAL_GPIO_ReadPin(m_port, m_pin) || ++m_roll_timer > m_roll_period) {
-        m_stable = true;
-        m_pressed = true;
-        m_roll_timer = m_roll_period * 0.8;
-    }
+/// @brief Scheduler for state-driven GPIO updates.
+void CustomGPIO::scheduler() { gpio_sm.triggerEvent(Event::POLL); }
+
+Action CustomGPIO::actionOn() {
+    return [this]() { HAL_GPIO_WritePin(port, pin, GPIO_PIN_SET); };
 }
 
-/// @brief Debounce scheduler for active-high inputs.
-/// Monitors pin for stable rising-edge and marks press event.
-/// @note Call periodically to update internal status.
-void CustomGPIO::schedulerHighActive() {
-    if (m_stable) {
-        if (HAL_GPIO_ReadPin(m_port, m_pin))
-            m_stable = false;
-        else
-            m_roll_timer = 0;
-    }
+Action CustomGPIO::actionOff() {
+    return [this]() { HAL_GPIO_WritePin(port, pin, GPIO_PIN_RESET); };
+}
 
-    else if (!HAL_GPIO_ReadPin(m_port, m_pin) || ++m_roll_timer > m_roll_period) {
-        m_stable = true;
-        m_pressed = true;
-        m_roll_timer = m_roll_period * 0.8;
-    }
+Action CustomGPIO::actionToggle() {
+    return [this]() { HAL_GPIO_TogglePin(port, pin); };
 }
 
-/// @brief Retrieve and clear the press event flag.
-/// @return true if a press event was detected since last call; false otherwise.
-bool CustomGPIO::getStatus() {
-    if (m_pressed) {
-        m_pressed = !m_pressed;
-        return true;
-    } else
-        return false;
+Guard CustomGPIO::guardLowSense() {
+    return [this]() { return !HAL_GPIO_ReadPin(port, pin); };
+}
+
+Guard CustomGPIO::guardHighSense() {
+    return [this]() { return HAL_GPIO_ReadPin(port, pin); };
+}
+
+Guard CustomGPIO::guardStable() {
+    return [this]() {
+        if (roll_timer++ > roll_period) {
+            roll_timer = 0;
+            return true;
+        } else {
+            return false;
+        }
+    };
 }