Diff: main.cpp

Revision:

8:2980205ae631

Parent:

7:661ef6a3c052

Child:

9:0882a5d7c0a3

--- a/main.cpp	Thu Oct 22 16:48:09 2020 +0000
+++ b/main.cpp	Fri Nov 20 16:32:25 2020 +0000
@@ -4,7 +4,7 @@
 #include "PTC3471.h"
 
 #define Ts 0.01                                                       //periodo de amostragem
-#define pi 3.14159
+#define Pi 3.14159265
 
 /******************************************************************************/
 /****************  Definição de Variaveis, Objetos e Funções ******************/
@@ -51,6 +51,11 @@
 
 float  u=0;
 float K[4] = {0.0, 0.0, 0.0, 0.0};
+
+float t_end = 30.0;                                                   // Duração do Experimento
+float tempo=0;                                                        // acumula o tempo de execução do experimento
+
+int N_plot =  (int) t_end/(Ts*10);                                    //Numero de amostras a ser armazenada para plot
                                                                                 
 void Init(void);                                                      // Função de Inicialização
 void Control_Function(void);                                          // Função de flag do controle, a ser chamada pela interrupção
@@ -71,6 +76,11 @@
 // esporádico.
 int main() {
 
+    
+    int ap = 0;                                                        // Indice dos vetores da dado
+    int16_t th0_f_int[N_plot], th1_f_int[N_plot];                      // Vetores para armazenar dados e 
+    int16_t dth0_f_int[N_plot], dth1_f_int[N_plot], u_int[N_plot];     // serem transmitidos via serial  
+
     /*********************************************************************************/
     /** Inicialização do algoritmo de proteção. NUNCA DEVE SER RETIRADO DO PROGRAMA **/
     /**/                                wait(5);                                   /**/
@@ -92,21 +102,29 @@
                 // As variáveis serão multiplicadas por 1000 e convertidas para inteiro
                 // antes de serem trasmitidas. Ao receber, deve-se dividir por 1000 antes
                 // de fazer o plot. OBS: a precisão no gráfico será de 3 casas decimais
-                th0_f_int = th0_f*1000;
-                th1_f_int = th1_f*1000;
-                dth0_f_int = dth0_f*1000;
-                dth1_f_int = dth1_f*1000;
-                u_int = u*1000;
+                th0_f_int[ap] = th0_f*1000;
+                th1_f_int[ap] = th1_f*1000;
+                dth0_f_int[ap] = dth0_f*1000;
+                dth1_f_int[ap] = dth1_f*1000;
+                u_int[ap] = u*1000;
+               
+                ap = ap+1;
+                PlotCount = 0;
+           }
+            // Após t_end segundos, o experimento é interrompido e os dados são transmitidos via serial
+            if (tempo >= t_end) {
+                int ii;
+                Control_Interrupt.detach();
+                Motor = 0;
+                Horario = 0;
+                AntiHorario = 0;
+                for (ii=0; ii<N_plot; ii++)
+                    pc.printf("%d \t %d \t %d \t %d \t %d\n\r", th0_f_int[ii], th1_f_int[ii], dth0_f_int[ii], dth1_f_int[ii], u_int[ii]);
                 
-                PlotCount = 0;
-                
-                pc.printf("%d \t %d \t %d \t %d \t %d\n\r", th0_f_int, th1_f_int, dth0_f_int, dth1_f_int, u_int);
-                
-                 
             }
             
-            Flag_Controle = false;                                      // Sinaliza que deve-se esperar o próximo sinal da interrupção  
-                                                                        // de tempo para executar o próximo passo de controle
+            Flag_Controle = false;                                   // Sinaliza que deve-se esperar o próximo sinal da interrupção  
+                                                                     // de tempo para executar o próximo passo de controle
         }
     }
 }
@@ -174,17 +192,17 @@
     th1_a=th1;                                                    
     
     /** Leituras cruas dos ângulos do encoder **/
-    phi0 = pi*Encoder_Motor.getPulses()/600.0;                           // (eventos_lidos/eventos_por_volta)*2*pi = angulo_em_radianos
-    phi1 = pi*Encoder_Pendulo.getPulses()/1200.0;                        // (eventos_lidos/eventos_por_volta)*360  = angulo_em_graus
+    phi0 = Pi*Encoder_Motor.getPulses()/600.0;                           // (eventos_lidos/eventos_por_volta)*2*pi = angulo_em_radianos
+    phi1 = Pi*Encoder_Pendulo.getPulses()/1200.0;                        // (eventos_lidos/eventos_por_volta)*360  = angulo_em_graus
     
     th0 = phi0;
     /** Tratamento do ângulo lido para ser zero na vertical para cima **/    
                                                                         // Como o encoder é incremental quando inicializamos o programa com o pêndulo na posição
     if(phi1>0)                                                          // vertical para baixo esta passa a ser lida como 0º. Porém, para o algoritmo de controle
-        th1 = phi1-pi;                                                  // funcionar corretamente 0º deve ser o pêndulo na posição vertical para cima. Para 
+        th1 = phi1-Pi;                                                  // funcionar corretamente 0º deve ser o pêndulo na posição vertical para cima. Para 
                                                                         // garantir que isso aconteça subido o pêndulo no sentido horário ou anti-horário fazemos
     else if(phi1<=0)                                                    // th1 = th1-sgn(th1)*pi, onde sgn(x) é o sinal de x.
-        th1 = phi1+pi;                                                  // Para ficar mais claro o funcionamento destes "if else" plote o sinal de th1 no tera term
+        th1 = phi1+Pi;                                                  // Para ficar mais claro o funcionamento destes "if else" plote o sinal de th1 no tera term
     
     // Filtro (1/tau*s +1) nos angulos
     th0_f = (tau/(Ts+tau))*th0_f + (Ts/(Ts+tau))*th0;
@@ -199,5 +217,5 @@
 void Control_Function(void){
     
     Flag_Controle = true;
-    
+    tempo = tempo+Ts;  
 }
\ No newline at end of file