Melhorias no tratamento de estados do Controlador e ajuste de pinagens

Henrique-BO · Jun 25, 2022 · 90bda3a · 90bda3a
1 parent 89cb341
commit 90bda3a
Show file tree

Hide file tree

Showing 13 changed files with 155 additions and 97 deletions.
diff --git a/data/gcode.txt b/data/gcode.txt
@@ -1,9 +1,3 @@
-G00 Z5.000000
-G00 X46.857647 Y218.081856
-G01 Z-1.000000 F100.0(Penetrate)
-G01 X162.416370 Y218.081856 Z-1.000000 F400.000000
-G01 X162.416370 Y117.672590 Z-1.000000
-G01 X46.857647 Y117.672590 Z-1.000000
-G01 X46.857647 Y218.081856 Z-1.000000
-G00 Z5.000000
-G00 X0.0000 Y0.0000
+G01 X100.00 Y0 Z0 F1000
+G01 X250.00 Y0 Z0 F1000
+G01 X200.00 Y0 Z0 F1000
diff --git a/include/controlador.h b/include/controlador.h
@@ -4,13 +4,21 @@
 #include "AccelStepper.h"
 #include "sensor_curso.h"
 
-#define MAX_SPEED 100.0
-#define MM_POR_STEP_X 1.0
-#define MM_POR_STEP_Y 1.0
-#define MM_POR_STEP_Z 1.0
-#define MARGEM_X 1
-#define CONTROLADOR_DELAY 10 // TODO calcular a frequencia necessaria
+// Velocidade máxima de deslocamento
+#define MAX_SPEED 30000.0
 
+// Resolução de passo de cada eixo
+#define STEPS_POR_MM_X 4.750893824 // 2pi/200*R
+#define STEPS_POR_MM_Y 4.486397268
+#define STEPS_POR_MM_Z 1.0
+
+// Margem de caibração no eixo X
+#define MARGEM_X 10
+
+// Período da Task do controlador
+#define CONTROLADOR_DELAY_MS 10
+
+// Wrapper da Task do controlador
 void vTaskControlador(void *param);
 
 class Controlador {
@@ -19,20 +27,27 @@ class Controlador {
         void iniciarControlador();
         void enviarComando(int G, float X, float Y, float Z);
         void calibrar();
+        void cancelar();
         void origem();
         void taskControlar();
-
-        bool chegou = false; // TODO semaforo/mutex
 
     private:
         AccelStepper *pStepperX;
         AccelStepper *pStepperY;
         AccelStepper *pStepperZ;
 
-        float speed = 100.0;
+        // velocidade de deslocamento
+        float speed = 5000.0;
+
+        // flags de controle
         bool calibrando = false;
+        bool flag_cancelar = false;
+        bool mover = false;
+        bool movendo = false;
 };
 
 extern Controlador controlador;
 
+extern SemaphoreHandle_t xSemaphoreControlador;
+
 #endif
diff --git a/include/credenciais.h b/include/credenciais.h
@@ -0,0 +1,7 @@
+#ifndef CREDENCIAIS_H
+#define CREDENCIAIS_H
+
+#define SSID "SSID da rede WiFi"
+#define PASSWORD "Senha da rede WiFi"
+
+#endif // CREDENCIAIS_H
diff --git a/include/definicoes_sistema.h b/include/definicoes_sistema.h
@@ -9,17 +9,15 @@
 #ifndef DEFINICOES_SISTEMA_H
 #define DEFINICOES_SISTEMA_H
 
-#include <Arduino.h>
+// Pinos dos motores de passo
+#define PIN_STEP_X 32
+#define PIN_DIR_X 33
 
-#include "maquina_estados.h"
+#define PIN_STEP_Y 25
+#define PIN_DIR_Y 26
 
-// Pinos dos motores de passo
-#define PIN_STEP_X 16
-#define PIN_DIR_X 17
-#define PIN_STEP_Y 18
-#define PIN_DIR_Y 19
-#define PIN_STEP_Z 20
-#define PIN_DIR_Z 21
+#define PIN_STEP_Z 27
+#define PIN_DIR_Z 14
 
 // Pinos dos sensores de fim de curso
 #define PIN_SENSOR_1 4

diff --git a/include/interface_wifi.h b/include/interface_wifi.h
@@ -3,10 +3,6 @@
 
 #include "ESPAsyncWebServer.h"
 
-#define SSID "Magdolna"
-#define PASSWORD "41308133"
-
-
 class InterfaceWiFi {
     public:
         InterfaceWiFi(): server(AsyncWebServer(80)) {}

diff --git a/include/interpretador_g.h b/include/interpretador_g.h
@@ -22,6 +22,7 @@ class InterpretadorG {
         File file;
         GCodeParser GCode;
         bool imprimindo = false;
+        int line_number = 1;
 };
 
 extern InterpretadorG interpretadorG;

diff --git a/include/maquina_estados.h b/include/maquina_estados.h
@@ -91,36 +91,18 @@ class MaquinaEstados {
         Estado getEstado();
 
     private:
-        /**
-         * @brief Verifica se algum evento ocorreu
-         * 
-         * @return O evento que ocorreu, ou NENHUM_EVENTO caso contrário
-         */
-        Evento obterEvento();
+        // Evento obterEvento();
         ProxEstadoAcao obterProxEstadoAcao(Estado estado, Evento evento);
         void executarAcao(Acao acao);
 
         ProxEstadoAcao matrizTransicaoEstados[NUM_ESTADOS][NUM_EVENTOS]; // matriz de transicao de estados
         Estado estado; // estado atual
 };
 
-/**
- * @brief Wrapper da função MaquinaEstados::taskExecutar para criação de task FreeRTOS
- * 
- * @param param Ponteiro para objeto MaquinaEstados
- */
 void vTaskMaquinaEstados(void *param);
 
-/**
- * @brief Fila de eventos
- * 
- */
-extern QueueHandle_t xQueueEventos;
-
-/**
- * @brief Máquina de Estados como uma variável global
- * 
- */
 extern MaquinaEstados maquinaEstados;
 
+extern QueueHandle_t xQueueEventos;
+
 #endif
diff --git a/platformio.ini b/platformio.ini
@@ -18,3 +18,5 @@ lib_deps =
 	tgolla/GCodeParser@^1.3.0
 	me-no-dev/ESP Async WebServer@^1.2.3
 monitor_speed = 115200
+upload_port = COM8
+monitor_port = COM8
diff --git a/src/controlador.cpp b/src/controlador.cpp
@@ -6,16 +6,17 @@
 #include "controlador.h"
 #include "sensor_curso.h"
 
+SemaphoreHandle_t xSemaphoreControlador;
+
 Controlador::Controlador(int pinStepX, int pinDirX, int pinStepY, int pinDirY, int pinStepZ, int pinDirZ) 
 {
     pStepperX = new AccelStepper(AccelStepper::DRIVER, pinStepX, pinDirX);
     pStepperY = new AccelStepper(AccelStepper::DRIVER, pinStepY, pinDirY);
     pStepperZ = new AccelStepper(AccelStepper::DRIVER, pinStepZ, pinDirZ);
-
+    
     pStepperX->setMaxSpeed(MAX_SPEED);
     pStepperY->setMaxSpeed(MAX_SPEED);
     pStepperZ->setMaxSpeed(MAX_SPEED);
-
 }
 
 void Controlador::iniciarControlador()
@@ -26,21 +27,23 @@ void Controlador::iniciarControlador()
     xTaskCreate(
         vTaskControlador,
         "Controlador",
-        1000,
+        10000,
         this,
         1,
         NULL
     );
 }
 
-
 void Controlador::enviarComando(int G, float X, float Y, float Z)
 {
-    int stepsX = (int) X / MM_POR_STEP_X;
-    int stepsY = (int) Y / MM_POR_STEP_Y;
-    int stepsZ = (int) Z / MM_POR_STEP_Z;
+    int stepsX = (int) round(X * STEPS_POR_MM_X);
+    int stepsY = (int) round(Y * STEPS_POR_MM_Y);
+    int stepsZ = (int) round(Z * STEPS_POR_MM_Z);
+
+    Serial.printf("[Controlador] G%d stepsX=%d stepsY=%d stepsZ=%d\n", G, stepsX, stepsY, stepsZ);
 
     if (G == 0) {
+        Serial.println("[Controlador] Movimentação rápida");
         pStepperX->moveTo(stepsX);
         pStepperY->moveTo(stepsY);
         pStepperZ->moveTo(stepsZ);
@@ -49,6 +52,7 @@ void Controlador::enviarComando(int G, float X, float Y, float Z)
         pStepperY->setSpeed(speed);
         pStepperZ->setSpeed(speed);
     } else if (G == 1) {
+        Serial.println("[Controlador] Movimento linear");
         pStepperX->moveTo(stepsX);
         pStepperY->moveTo(stepsY);
         pStepperZ->moveTo(stepsZ);
@@ -64,42 +68,96 @@ void Controlador::enviarComando(int G, float X, float Y, float Z)
         pStepperY->setSpeed(speedY);
         pStepperZ->setSpeed(speed);
     }
+
+    mover = true;
 }
 
 void Controlador::calibrar()
 {
     calibrando = true;
-    pStepperX->move(-1);
-    pStepperX->setSpeed(speed);
+    mover = false;
+    movendo = false;
+    flag_cancelar = false;
+
+    Serial.println("[Controlador] Iniciando calibração");
+    pStepperX->setSpeed(-speed);
+    pStepperY->setSpeed(-speed);
+    pStepperZ->setSpeed(-speed);
+}
+
+void Controlador::cancelar()
+{
+    movendo = false;
+    flag_cancelar = true;
 }
 
 void Controlador::taskControlar()
 {
+    xSemaphoreGive(xSemaphoreControlador);
+
+    TickType_t xLastWakeTime;
+    const TickType_t xFrequency = pdMS_TO_TICKS(CONTROLADOR_DELAY_MS);
+
+    while(xSemaphoreControlador == NULL) {
+        vTaskDelay(xFrequency);
+    }
+
     while(1) {
+        xLastWakeTime = xTaskGetTickCount();
         if (!calibrando) {
-            if ((pStepperX->distanceToGo() == 0) && (pStepperY->distanceToGo() == 0) && (pStepperZ->distanceToGo() == 0)) {
-                chegou = true;
-            } else {
-                chegou = false;
-                pStepperX->runSpeedToPosition();
-                pStepperY->runSpeedToPosition();
-                pStepperZ->runSpeedToPosition();
+            if (mover) {
+                if (xSemaphoreTake(xSemaphoreControlador, portMAX_DELAY) == pdTRUE) {
+                    Serial.println("[Controlador] Semáforo capturado, iniciando movimento");
+                    Serial.printf("[Controlador] dX=%d dY=%d dZ=%d\n", pStepperX->distanceToGo(), pStepperY->distanceToGo(), pStepperZ->distanceToGo());
+                    mover = false;
+                    movendo = true;
+                } else {
+                    Serial.println("[Controlador] Falha ao capturar semáforo");
+                }
+            }
+            if (flag_cancelar) {
+                if (xSemaphoreGive(xSemaphoreControlador) != pdTRUE) {
+                    Serial.println("[Controlador] Falha ao ceder semáforo");
+                }
+                Serial.println("[Controlador] Movimento cancelado");
+                flag_cancelar = false;
+            }
+            if (movendo) {
+                if ((pStepperX->distanceToGo() != 0) || (pStepperY->distanceToGo() != 0) || (pStepperZ->distanceToGo() != 0)) {
+                    pStepperX->runSpeedToPosition();
+                    pStepperY->runSpeedToPosition();
+                    pStepperZ->runSpeedToPosition();
+                } else {
+                    if (xSemaphoreGive(xSemaphoreControlador) != pdTRUE) {
+                        Serial.println("[Controlador] Falha ao ceder semáforo");
+                    }
+                    movendo = false;
+                    Serial.println("[Controlador] Chegou");
+                }
             }
         } else { // calibrando
             if (sensorCurso1.origem()) {
                 pStepperX->setCurrentPosition(-MARGEM_X);
-                pStepperX->move(1);
+                pStepperX->moveTo(0);
                 Evento evento = ORIGEM;
-                while(xQueueSendToBack(xQueueEventos, &evento, portMAX_DELAY) != pdTRUE);
+                if (xQueueSendToBack(xQueueEventos, &evento, portMAX_DELAY) != pdTRUE) {
+                    Serial.println("[Controlador] Erro ao enviar evento à fila");
+                }
                 calibrando = false;
             }
-            pStepperX->runSpeedToPosition();
+            pStepperX->runSpeed();
+            pStepperY->runSpeed();
+            pStepperZ->runSpeed();
         }
-        vTaskDelay(CONTROLADOR_DELAY / portTICK_PERIOD_MS);
+        // Delay para obter frequência constante
+        vTaskDelayUntil(&xLastWakeTime, xFrequency);
     }
 }
 
 void vTaskControlador(void *param)
 {
+    // Cria semáforo de controlador
+    xSemaphoreControlador = xSemaphoreCreateBinary();
+
     static_cast<Controlador *>(param)->taskControlar();
 }
diff --git a/src/interface_wifi.cpp b/src/interface_wifi.cpp
@@ -5,6 +5,7 @@
 
 #include "maquina_estados.h"
 #include "interface_wifi.h"
+#include "credenciais.h"
 
 
 void InterfaceWiFi::iniciarWiFi()
@@ -113,7 +114,7 @@ void InterfaceWiFi::carregarPrograma(AsyncWebServerRequest *request, String file
 }
 
 String InterfaceWiFi::processor(const String& var){
-  Serial.println("[InterfaceWiFi] " + var);
+//   Serial.println("[InterfaceWiFi] " + var);
   if(var == "ESTADO"){
     switch(maquinaEstados.getEstado()) {
     case IDLE: