meira nýtt

include/initialization_state.h

@@ -0,0 +1,35 @@
+#include "initialization_state.h"
+#include "motor_controller.h"
+
+#include <Arduino.h>
+
+
+void InitializationState::enter()
+{
+    Serial.println();
+    Serial.println("State: Initialization");
+
+    digitalWrite(LED_BUILTIN, LOW);
+
+    context->stop_motor();
+
+    context->reset_speed_measurement();
+
+    Serial.println("Boot-up");
+}
+
+
+void InitializationState::update()
+{
+    context->to_operational();
+}
+
+
+void InitializationState::command(char c)
+{
+}
+
+
+void InitializationState::exit()
+{
+}

include/motor_controller.h

@@ -0,0 +1,61 @@
+#ifndef MOTOR_CONTROLLER_H
+#define MOTOR_CONTROLLER_H
+
+#include "rotary_encoder_driver.h"
+#include "motor_driver.h"
+#include "p_controller.h"
+
+class State;
+
+
+class MotorController
+{
+private:
+    State* current_state;
+
+    State* initialization_state;
+    State* operational_state;
+
+    RotaryEncoderDriver& encoder;
+    MotorDriver& motor;
+    P_controller& controller;
+
+    double reference_rpm;
+
+
+public:
+    MotorController(
+        RotaryEncoderDriver& encoder,
+        MotorDriver& motor,
+        P_controller& controller
+    );
+
+
+    void set_states(
+        State* initialization,
+        State* operational
+    );
+
+
+    void begin();
+
+    void update();
+
+    void command(char c);
+
+    void transition_to(State* new_state);
+
+
+    void to_initialization();
+
+    void to_operational();
+
+
+    void run_speed_controller();
+
+    void stop_motor();
+
+    void reset_speed_measurement();
+};
+
+#endif

include/operational_state.h

@@ -0,0 +1,19 @@
+#ifndef OPERATIONAL_STATE_H
+#define OPERATIONAL_STATE_H
+
+#include "state.h"
+
+
+class OperationalState : public State
+{
+public:
+    void enter() override;
+
+    void update() override;
+
+    void command(char c) override;
+
+    void exit() override;
+};
+
+#endif

src/main.cpp

@@ -1,28 +1,81 @@
+#include <Arduino.h>
+#include <avr/interrupt.h>
+
+#include "rotary_encoder_driver.h"
+#include "motor_driver.h"
+#include "p_controller.h"
+
+#include "motor_controller.h"
+
+#include "initialization_state.h"
+#include "operational_state.h"
+
+
+RotaryEncoderDriver encoder;
+
+MotorDriver motor;
+
+P_controller controller(12.5);
+
+
+MotorController system(
+    encoder,
+    motor,
+    controller
+);
+
+
+InitializationState initialization_state;
+
+OperationalState operational_state;
+
+
 int main()
 {
     init();
 
     Serial.begin(115200);
 
+
+    pinMode(LED_BUILTIN, OUTPUT);
+
+    digitalWrite(LED_BUILTIN, LOW);
+
+
     cli();
 
     encoder.begin();
+
     motor.begin();
 
     sei();
 
+
+    system.set_states(
+        &initialization_state,
+        &operational_state
+    );
+
+
     system.begin();
 
+
     while (true)
     {
-        if (Serial.available())
+        if (Serial.available() > 0)
         {
             char c = Serial.read();
+
+            if (c != '\n' && c != '\r')
+            {
                 system.command(c);
             }
+        }
+
 
         system.update();
     }
 
+
     return 0;
 }

src/motor_controller.cpp

@@ -0,0 +1,110 @@
+#include "motor_controller.h"
+#include "state.h"
+
+#include <Arduino.h>
+
+
+MotorController::MotorController(
+    RotaryEncoderDriver& encoder,
+    MotorDriver& motor,
+    P_controller& controller
+)
+    : current_state(nullptr),
+      initialization_state(nullptr),
+      operational_state(nullptr),
+      encoder(encoder),
+      motor(motor),
+      controller(controller),
+      reference_rpm(30.0)
+{
+}
+
+
+void MotorController::set_states(
+    State* initialization,
+    State* operational
+)
+{
+    initialization_state = initialization;
+    operational_state = operational;
+}
+
+
+void MotorController::begin()
+{
+    transition_to(initialization_state);
+}
+
+
+void MotorController::transition_to(State* new_state)
+{
+    if (current_state != nullptr)
+    {
+        current_state->exit();
+    }
+
+    current_state = new_state;
+
+    current_state->set_context(this);
+
+    current_state->enter();
+}
+
+
+void MotorController::update()
+{
+    if (current_state != nullptr)
+    {
+        current_state->update();
+    }
+}
+
+
+void MotorController::command(char c)
+{
+    if (current_state != nullptr)
+    {
+        current_state->command(c);
+    }
+}
+
+
+void MotorController::to_initialization()
+{
+    transition_to(initialization_state);
+}
+
+
+void MotorController::to_operational()
+{
+    transition_to(operational_state);
+}
+
+
+void MotorController::run_speed_controller()
+{
+    if (encoder.new_speed_available())
+    {
+        double actual = encoder.rpm();
+
+        double pwm_percent =
+            controller.update(reference_rpm, actual);
+
+        double pwm =
+            pwm_percent * 2.55;
+
+        motor.set(pwm);
+    }
+}
+
+
+void MotorController::stop_motor()
+{
+    motor.stop();
+}
+
+
+void MotorController::reset_speed_measurement()
+{
+    encoder.reset_speed_measurement();
+}

src/operational_state.cpp

@@ -0,0 +1,37 @@
+#include "operational_state.h"
+#include "motor_controller.h"
+
+#include <Arduino.h>
+
+
+void OperationalState::enter()
+{
+    Serial.println("State: Operational");
+
+    digitalWrite(LED_BUILTIN, HIGH);
+}
+
+
+void OperationalState::update()
+{
+    context->run_speed_controller();
+}
+
+
+void OperationalState::command(char c)
+{
+    if (c == 'r' || c == 'R')
+    {
+        Serial.println("Command: reset");
+
+        context->to_initialization();
+    }
+}
+
+
+void OperationalState::exit()
+{
+    context->stop_motor();
+
+    digitalWrite(LED_BUILTIN, LOW);
+}