Diff: main.cpp

Revision:

0:374ae6cd7a56

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Wed Jun 12 18:09:04 2019 +0000
@@ -0,0 +1,277 @@
+#include "mbed.h"
+#include "tsi_sensor.h"
+#include "Dht11.h"
+
+#define ELEC0 9
+#define ELEC1 10
+
+enum {RESET,    // Funcion enum que uso para establecer los estados de la maquina de estados como una palabra
+      LAZO_ABIERTO,
+      LAZO_CERRADO
+     };
+enum { NADA,    // Funcion enum que uso para establecer los estados de la maquina de estados como una palabra
+       PULSADO
+     };
+
+// Prototipos de funciones
+
+void MAQ_cooler();  // Maquina de estados que maneja al cooler en sus modos de funcionamiento
+
+void set_motor();   // Funcion que cada 1 segundo cambia el valor del PWM del motor, para no hacerlo a la velocidad del clock en el main
+
+void interrupcion();    // Funcion que se realiza cada vez que el pin establecido tenga un flanco. Usado para calcular los RPM
+
+void rpm_segundos();    // Funcion que multiplicará las revoluciones por segundo para obtener las RPM
+
+void MAQ_lecturaTSI();  //Prototipo funcion para solo leer 1 vez que se presiona el TSI
+
+void LEER_TSI();    //Prototipo funcion para guardar el valor analogico del TSI en todo momento
+
+void pulsacion_TSI();   //Prototipo funcion para leer 1 solo valor del TSI cada 2.5mseg
+
+void medir_temperatura();   // Funcion para leer el sensor de temperatura, en el tiempo especificado en datasheet
+
+
+// Configuracion de puertos
+
+TSIAnalogSlider tsi(ELEC0, ELEC1, 40);  // TSI
+
+InterruptIn velocidad(PTA13);   // Sensor de rpm
+
+PwmOut cooler(PTB3);    // Base del transistor que maneja el cooler
+
+AnalogIn pote(PTB0);    // Potenciometro
+
+Dht11 sensor(PTD4); // Sensor DHT11 (libreria)
+
+DigitalOut ledrojo(LED_RED);    // Led rojo de la placa MBED
+
+DigitalOut ledverde(LED_GREEN); // Led verde de la placa MBED
+
+
+// Variables globales
+
+int auxiliar_rpm;   // Variable que almacena las revoluciones por segundo
+int rpm;    // Variable que guarda los rpm para medirlos periodicamente
+
+int var_pulsacion = 25;     // Variable para contar los 2.5mseg de la funcion pulsacion_TSI()
+int teclado = NADA;         // Variable que contiene el valor analogico del TSI en todo momento
+int ingreso = NADA;         // Variable que contiene si se presionó el TSI, que se lee y luego se borra
+
+int estado_maq_cooler = RESET;  // Estado de la maquina de estados que maneja el cooler
+int estado_maq_tsi = NADA;  // Estado de la maquina de estados que maneja el TSI
+
+int auxiliar_temperatura;   // Variable que contiene el ultimo valor de temperatura que se midio
+float auxiliar_velocidad;   // Variable que contiene el numero float (de 0 a 1) para ingresar en el PWM del cooler
+
+
+// Tickers
+
+Ticker lectura; // Ticker lectura del TSI
+Ticker pulsacion;   // Ticker para usar la funcion pulsacion_TSI()
+Ticker segundo; // Ticker para contar los RPM a partir de las revoluciones por segundo
+Ticker pwm_cooler;  // Ticker para escribir en la salida PWM cada cierto tiempo
+Ticker medir;   // Ticker para medir la temperatura
+
+int main(void)
+{
+    medir_temperatura();    // Mido la temperatura así tengo un valor inicial
+
+    // Junto los ticker con la funcion que deseo usar con él
+    lectura.attach(&LEER_TSI,0.1);
+    pulsacion.attach(&pulsacion_TSI,0.001);
+    segundo.attach(&rpm_segundos,1);
+    pwm_cooler.attach(&set_motor,0.3);
+    medir.attach(&medir_temperatura,2);
+
+    // Digo que funcion se realiza cuando el pininterrupt se activa
+    velocidad.rise(&interrupcion);
+
+    while (true) {
+
+        // LLamo constantemente a las funciones de las maquinas de estados
+        MAQ_lecturaTSI();
+        MAQ_cooler();
+
+
+    }
+}
+
+void medir_temperatura()
+{
+    sensor.read();  // Actualizo el valor de temperatura del sensor
+    auxiliar_temperatura = sensor.getCelsius(); // Guardo el valor de temperatura en la variable correspondiente
+}
+
+void MAQ_cooler()
+{
+    int revoluciones;   // Variable que usaré para calcular los RPM a partir del valor del PWM
+
+
+    switch(estado_maq_cooler) {
+
+        case RESET: // No empiezo en ningun modo asi no se consume corriente recien prendo el micro
+            if(ingreso == PULSADO) {    // Si se tocó el pulsador:
+                ingreso=NADA;   // Limpio la variable
+                estado_maq_cooler = LAZO_ABIERTO;   // Cambio de estado
+            }
+            break;
+        case LAZO_ABIERTO:
+
+            auxiliar_velocidad = pote + 0.065;  // El valor del PWM será el valor del pote, sumado al valor minimo para que prenda
+            //                                      el cooler. No uso 200 RPM porque el ventilador no enciende de esa forma.
+
+            // Corrigo el valor que hay en la salida si se detecta que bajaron los RPM
+            if(rpm < (auxiliar_velocidad * 8000)) {
+                auxiliar_velocidad=auxiliar_velocidad+0.1;
+            } else {
+                auxiliar_velocidad=auxiliar_velocidad-0.005;
+            }
+
+            if(auxiliar_velocidad>(float)1) {
+                auxiliar_velocidad=(float)1;
+            }
+
+            // Transicion de la maquina de estados
+            if(ingreso == PULSADO) {
+                ingreso=NADA;
+                estado_maq_cooler = LAZO_CERRADO;
+            }
+
+            break;
+
+        case LAZO_CERRADO:
+
+            revoluciones = (auxiliar_temperatura * 8000) / 45;  // Regla de 3 para calcular las revoluciones por minuto
+            //                                                      que corresponden para la temperatura medida
+
+
+            if(auxiliar_temperatura<20) {  // Cuando la temperatura es mas baja que 20, seteo en el valor minimo del ventilador
+                auxiliar_velocidad = 0.065;
+
+                // Corrigo el valor que hay en la salida si se detecta que bajaron los RPM
+                if(rpm < (auxiliar_velocidad * 8000)) {
+                    auxiliar_velocidad=auxiliar_velocidad+0.05;
+                } else {
+                    auxiliar_velocidad=auxiliar_velocidad-0.005;
+                }
+            }
+
+
+            if((auxiliar_temperatura>=20)&&(auxiliar_temperatura<45)) { // Dentro de este rango de temperatura, las RPM estan dadas
+                //                                                              por una regla de 3 simple
+                auxiliar_velocidad = (revoluciones * 1) / (float)8000;
+
+                // Corrigo el valor que hay en la salida si se detecta que bajaron los RPM
+                if(rpm < (auxiliar_velocidad * 8000)) {
+                    auxiliar_velocidad=auxiliar_velocidad+0.075;
+                } else {
+                    auxiliar_velocidad=auxiliar_velocidad-0.0005;
+                }
+
+                if(auxiliar_velocidad>(float)1) {
+                    auxiliar_velocidad=(float)1;
+                }
+
+            }
+
+            if(auxiliar_temperatura >= 45) { // Si la temperatura es mas alta que la maxima, el cooler se encuentra al maximo de potencia
+                auxiliar_velocidad = 1;
+            }
+
+            // Transicion de la maquina de estados
+            if(ingreso == PULSADO) {
+                ingreso=NADA;
+                estado_maq_cooler = LAZO_ABIERTO;
+            }
+            break;
+    }
+}
+
+void interrupcion()
+{
+    auxiliar_rpm++; // Valor para calcular los RPM, contiene las revoluciones por segundo que luego se multiplicarán por 60
+}
+
+void rpm_segundos()
+{
+
+    rpm = auxiliar_rpm * 60;    // Las RPM son igual a las revoluciones por segundo * 60 segundos
+
+    auxiliar_rpm = 0;   // Reseteo la variable para una nueva medicion
+
+// Imprimo en pantalla el valor actual de RPM, la temperatura actual y el modo en el que se está trabajando. Este mismo
+// depende del estado de la maquina de estados, asi que aplico ese metodo para imprimir en pantalla. Tambien, prendo un
+// led distinto para cada modo de trabajo.
+
+    printf("RPM: %i , ",rpm);
+    printf("T: %i\n",auxiliar_temperatura);
+
+    switch(estado_maq_cooler) {
+        case LAZO_ABIERTO:
+            printf("Lazo abierto\n");
+            ledverde = 0;
+            ledrojo = 1;
+            break;
+        case LAZO_CERRADO:
+            printf("Lazo cerrado\n");
+            ledverde = 1;
+            ledrojo = 0;
+            break;
+    }
+
+}
+
+void set_motor()
+{
+    // Seteo en la salida PWM el valor que corresponde, que ya se guardó en la maquina de estados
+    cooler.period(0.5f);
+    cooler.write(auxiliar_velocidad);
+    
+}
+
+void LEER_TSI()
+{
+    float auxiliar = 0;
+    auxiliar = tsi.readPercentage();    //Guardo de manera auxiliar el valor entre 0 y 1 del TSI
+
+// Asocio el valor del tsi numerico con un color, dividiendo en 4 valores posibles (0, <0.33, <0.66, <1)
+    if(auxiliar >= 0) {
+        teclado = NADA;
+    }
+    if((auxiliar > 0.05)&&(auxiliar <= 1)) {
+        teclado = PULSADO;
+    }
+}
+
+void pulsacion_TSI()
+{
+    if(var_pulsacion > 0) {
+        var_pulsacion--;
+    }
+}
+
+void MAQ_lecturaTSI()
+{
+    if(var_pulsacion < 1) { // Si se llegaron a los 2.5ms:
+
+        var_pulsacion = 25; // Vuelvo a establecer 2.5ms para el proximo ciclo
+
+        switch(estado_maq_tsi) {
+            case NADA:
+                ingreso = NADA; // La variable ingreso, salvo en el caso especifico, siempre se encontrará en NADA
+
+                if(teclado==PULSADO) {
+                    estado_maq_tsi = PULSADO;
+                    ingreso = PULSADO;  // El valor del TSI lo cambio en la transicion entre estados para asegurarme que solo se pueda leer 1 vez
+                }
+                break;
+
+            case PULSADO:
+                if(teclado == NADA) {
+                    estado_maq_tsi = NADA;
+                }
+                break;
+        }
+    }
+}
\ No newline at end of file