![](/media/cache/img/default_profile.jpg.50x50_q85.jpg)
Version Final
Diff: main.cpp
- Revision:
- 5:f12c0d64518f
- Parent:
- 3:f483abe4bc57
- Child:
- 6:75b0f24dad9b
diff -r 01060b5e01b4 -r f12c0d64518f main.cpp --- a/main.cpp Fri Jan 13 18:30:37 2017 +0000 +++ b/main.cpp Wed Jun 05 01:27:43 2019 +0000 @@ -1,49 +1,645 @@ -#define MULTIPLE_PROBES -#define DATA_PIN A0 +/* +FERNANDEZ-CLERICI +EJER01 - TP01 +PTB0 -- Habilitacion Cooler +PTB1 -- DS18B20 (Data) (4K7 PullUp) +D3 -- Sensor Efecto de Hall --> PullUp 4k7 +PTB3 -- Pulsador --> 0 = Nada || 1 = Pulsado +PTC2 -- Preset +A3 -- Pin Para Probar que el programa no retiene -#ifdef MULTIPLE_PROBES +*/ +/*Librerias*/ #include "mbed.h" #include "DS1820.h" -#define MAX_PROBES 16 - -DS1820* probe[MAX_PROBES]; - -int main() { - // Initialize the probe array to DS1820 objects - int num_devices = 0; - while(DS1820::unassignedProbe(DATA_PIN)) { - probe[num_devices] = new DS1820(DATA_PIN); - num_devices++; - if (num_devices == MAX_PROBES) + +/*Definicion Pines*/ +#define EN_COOLER PTB0 +#define DS18B20_PIN PTB1 +#define VELOCIDAD D3 +#define PULSADOR A5 +#define PRESET PTC2 + +/*Definicion de Elementos*/ +DS1820 probe(DS18B20_PIN); + +DigitalOut Rojo(LED1); +DigitalOut Verde(LED2); +DigitalOut Azul(LED3); + +DigitalOut RET(A3); + +PwmOut Cooler(EN_COOLER); +InterruptIn velocidad(VELOCIDAD); +AnalogIn Preset(PRESET); +DigitalIn P(PULSADOR); + + +/*MAQUINA DE ESTADOS CENTRAL*/ + +#define InicioSistema 0 +#define LazoAbierto 1 +#define LazoCerrado 2 +#define VelocidadMaxima 3 + +/*Variables maquina de estado lazos*/ +int Modo = 0; //Me avisa en que modo estoy : Lazo Abierto , Lazo Cerrado, Inicio Sistema y Velocidad maxima +int ta = 0; //Acumulador de tiempo del Inicio Sistema +void medicion_velocidad(void); +int VMAX = 0; //Velocidad maxima del Cooler + + +/*MAQUINA DE ESTADOS ANTI REBOTE*/ + +#define INICIO_P 0 +#define RISING_P 1 +#define RETENCION_P 2 + +bool antirrebote(bool lectura); +int estado = 0;//Variable que guaarda el estado de la maquina de estados +int tp = 0;//Acumulador de tiempo de la maquina +void CambioDeModo(); //Funcion que me sirve para switchear entre los dos modos + + +/*MAQUINA DE ESTADOS MEDICION VELOCIDAD*/ + +#define INCIO_V 0 +#define RISE_1 1 +#define FALL_1 2 +#define ESPERA_V 3 + +//Interrupciones de deteccion de cambios en pin de medicion de valocidad +void R_ton(); //Funcion relacionada a la interrupcion de deteccion de flancos ascendentes +void F_ton(); //Funcion relacionada a la interrupcion de deteccion de flancos descendentes + +//Flags medicion de ancho de pulso +bool em = 0; //Estoy midiendo +bool tmv = 0; //Termine de medir +int tv = 0; //Acumulacion de tiempo maquina control velocidad +int EMV = 0; //Guardar estado medicion de velocidad +float RPM = 0; //Guardo la velocidad + + + +/*MAQUINA DE ESTADOS CAMBIO DE DUTY (LAZO ABIERTO)*/ + +#define INICIO_CM 0 +#define CAMBIO_MAYOR 1 +#define CAMBIO_MENOR 2 +#define INICIO_CAMBIO_MENOR 5 +#define ESPERA_DECREMENTO 3 +#define ESPERA_FINAL 4 + +int tcd = 0; //Acumulador de tiempo +int ECM = 0; //Guardo el estado de la maquina +float cantv = 0; //Cantidad de veces que debo modificar el duty (funciona como entero) +char jv = 0; //Cantidad de veces que modifique el duty +float D = 1.00f; //Duty Actual +float DAN = 0.5f;//Duty Anterior + +void cambio_duty_pwm(float nuevoDuty); //Funcion que engloa la maquina + + +/*MAQUINA DE ESTADOS LAZO CERRADO (DUTY EN FUNCION DE TEMPERATURA)*/ + +#define INCIO_LAZOCERRADO 0 +#define MEDICION_TEMPERATURA 1 +#define MEDICION_RPM 2 +#define CAMBIO_PWM 3 +#define ESPERA_CAMBIOS_PWM 4 +#define ESPERA_ENTRE_MODIFICACIONES 5 + +void control_PWM_Temp(void); //Funcion que engloba la maquina de estados + +int CPT = 0; //Guardo el estado de la maquina +int IM = 0; //Acumulador de tiempo base +float duty = 0; //Guardo el duty actual + +/*SubMaquina utilizada para modificar el duty*/ +int FTR = 0; //Control de estados de la submaquina +bool tdm = 0; //Flag que me notifica cuando termine de cambiar el duty.. + +float NuevoDuty = 0; //Duty que voy enviando a forma de prueba y error.. + +/*VALORES DE CONFIGURACION LAZO CERRADO*/ +#define DEFINICION_CAMBIO_PWM 0.02f //Resolucion de barrido, valores altos agilizan el cambio pero pueden hacer que nunca se alcance lo pedido.. +#define MinRPM 500.0f //Minima velocidad establecida por el Cooler +#define ToleranciaRPM 100.0f //Tolerancia de calculos en torno a la velocidad (Cuanto me puedo desviar de la regla de tres simple y considerarlo verdadero) + +/*RELACION DE REVOLUCIONES POR MINUTO EN FUNCION DE LA TEMPERATURA*/ +/* + 20ºC ==> 500rpm + x ºC ==> x rpm +*/ + +void cambio_gradual_duty(float obj);//Funcion que engloba la maquina de modificacion del duty , en especial la zona que no puedo enviar directamente.. + +int ty = 0; //Acumulador de tiempo + + +/*ELEMENTOS GENERALES DEL SISTEMA*/ +void leds(int num); +/*Tickers*/ +Ticker TiempoBase; +Ticker TiempoRapido; +void base_de_tiempo(); +void tiempo_rapido(); +/*Timmers*/ +Timer ap; + +int main() +{ + /*Apago Todos los LEDS*/ + leds(0); + printf("TRABAJO PRACTICO 1 : MAQUINAS DE ESTADO\r\n EJERCICIO 1\r\n ALUMNOS: FERNANDEZ SANZ Y CLERICI \r\n INICIANDO.............\r\n"); + /*Attach Timmers*/ + TiempoBase.attach(&base_de_tiempo, 0.5f); + TiempoRapido.attach(&tiempo_rapido, 0.05f); + /*Inicio PWM*/ + Cooler.period(0.01f); //Establezco un periodo de 100mS para el PWM + + while(1) { + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /*Maquina de Estados Central del Sistema*/ + switch(Modo) { + + //La primera vez arranco el motor al maximo y inicializo la medicion de velocidad.. + case InicioSistema: + Cooler.write(1); + //Espero un tiempo para q arranque el motor + if(ta > 5) { + ta = 0; + /*Attach Pin Interrupt del medidor de velocidad*/ + velocidad.rise(&R_ton); + velocidad.fall(&F_ton); + printf("Termine de incializar....\r\n"); + Modo = VelocidadMaxima; + } + + break; + + //Mido la velocidad maxima del Cooler.. Lo setie al meximo en "InicioSistema" + case VelocidadMaxima: + medicion_velocidad(); + break; + + //Mido el Preset y seteo el duty del Cooler en funcion de la lectura + case LazoAbierto: + float lec = Preset; + cambio_duty_pwm(lec); + break; + + //Mido la temperatura y establezco la velocidad del Cooler + case LazoCerrado: + control_PWM_Temp(); + break; + } +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + //Actualizo el pulsador... + CambioDeModo(); + + RET = !RET; //Cambio el estado del pin de verificacion.. + + } +} + +//Funcion utilizada para controlar los Leds On Board +//IN ==> Combinacion Binaria de estados || OUT ==> Actualizacion estado de leds + +void leds(int num) +{ + switch(num) { + case 0: + Rojo = 1; + Verde = 1; + Azul = 1; + break; + case 4: + Rojo = 0; + Verde = 1; + Azul = 1; + break; + case 2: + Rojo = 1; + Verde = 0; + Azul = 1; + break; + case 1: + Rojo = 1; + Verde = 1; + Azul = 0; + break; + case 7: + Rojo = 0; + Verde = 0; + Azul = 0; break; } - - printf("Found %d device(s)\r\n\n", num_devices); - while(1) { - probe[0]->convertTemperature(true, DS1820::all_devices); //Start temperature conversion, wait until ready - for (int i = 0; i<num_devices; i++) - printf("Device %d returns %3.1foC\r\n", i, probe[i]->temperature()); - printf("\r\n"); - wait(1); +} + +//Maquina de estados que elimina el Rebote de los pulsadores +//IN ==> DigitalIn || OUT ==> Detector de flancos ascendentes del pulsador +bool antirrebote(bool lectura) +{ + static bool lecant = 0; + + switch(estado) { + case INICIO_P: + //Si tengo un flanco ascendente + if((lectura == 1) && (lecant == 0)) { + estado = RISING_P; + } + tp = 0; + break; + case RISING_P: + estado = RETENCION_P; + tp = 0; + return 1; + case RETENCION_P: + if((tp >= 2) && (lectura == 0)) { + estado = INICIO_P; + } + break; } - + lecant = lectura; + return 0; +} + +//Funcion relacionada al timmer , es llamada cada 0.5 segundos +void base_de_tiempo() +{ + tp ++; //Acumulador Antirebote + tv ++; //Acumulador Mediciond de velocidad + ta ++; //Acumulador Inicio del sistema.. + IM++; //Acumulador Lazo Cerrado } -#else -#include "mbed.h" -#include "DS1820.h" - -DS1820 probe(DATA_PIN); - -int main() { - while(1) { - probe.convertTemperature(true, DS1820::all_devices); //Start temperature conversion, wait until ready - printf("It is %3.1foC\r\n", probe.temperature()); - wait(1); +//Funcion del timmer dos, es llamada cada 0.05 segundos +void tiempo_rapido() +{ + tcd ++;//Acumulador Cambio de Duty(Lazo Abierto) + ty ++; //Acumulador Cambio de Duty(Lazo Cerrado) +} + +//Funcion dedicada a controlar el pulsador y analizar los cambios de modo.. +void CambioDeModo() +{ + if(antirrebote(P)) { + Modo ++; + if(Modo > 2) { + Modo = 1; + printf("Lazo Abierto!!\r\n"); + } + } +} + +//Inicio la medicion del tiempo de On del pulso +void R_ton() +{ + switch(EMV) { + case INCIO_V: + ap.reset(); + ap.start(); + em = 1; + tmv = 0; + EMV = RISE_1; + break; + + case RISE_1: + printf("ERROR MIDIENDO VELOCIDAD, EMV = %d!!\r\n", EMV); + break; + + case FALL_1: + ap.stop(); + tmv = 1; + em = 0; + tv = 0; + EMV = ESPERA_V; + break; + } } -#endif \ No newline at end of file +void F_ton() +{ + if(em) { + switch(EMV) { + case INCIO_V: + printf("ERROR MIDIENDO VELOCIDAD, EMV = %d!!\r\n", EMV); + break; + case RISE_1: + EMV = FALL_1; + break; + case FALL_1: + printf("ERROR MIDIENDO VELOCIDAD, EMV = %d!!\r\n", EMV); + break; + } + } + +} + +void cambio_duty_pwm(float nuevoDuty) +{ + static float ND = 0; + + switch(ECM) { + case INICIO_CM: + + ND = nuevoDuty; + Azul = 1; //Apago el indicador de LazoCerrado + + //Me fijo si estoy por poner mas o menos el mismo duty para evitar el proceso + if(abs(ND * 100.00f - DAN * 100.00f ) < 2) { + //printf("El duty es el mismo del ciclo previo...\r\n"); + tcd = 0; + ECM = ESPERA_FINAL; + break; + } + + printf("Inicio el cambio de duty....\r\n"); + Rojo = 0; + tcd = 0; + if(ND < 0.07f) { + Cooler.write(0); + duty = 0; + printf("Cooler APAGADO!\r\n"); + tcd = 0; + DAN = 0.5f; + ECM = ESPERA_FINAL; + Rojo = 1; + break; + } + if(ND >= 0.5f) { + ECM = CAMBIO_MAYOR; + } else + ECM = INICIO_CAMBIO_MENOR; + break; + case CAMBIO_MAYOR: + Cooler.write(ND); + printf("\tNuevo Duty = %f%\r\n", ND* 100); + DAN = ND; + tcd = 0; + ECM = ESPERA_FINAL; + break; + case INICIO_CAMBIO_MENOR: + cantv = abs( (int(DAN*100)) - (int(ND*100))); + printf("\tVoy a hacer %.0f pasos intermedios desde %.0f para llegar a %.0f%\r\n", cantv, DAN*100, ND * 100); + ECM = CAMBIO_MENOR; + jv = 0; + D = DAN; + break; + case CAMBIO_MENOR: + if(cantv >= jv) { + Cooler.write(D); + printf("\t\tEtapa intermedia en %.0f%\r\n", D * 100.00f); + /*Si quiero alcanzar un duty inferior*/ + if(ND < DAN) + D -= 0.01f; //Decremeto 1% + /*Si quiero alcanzar un duty superior*/ + if(ND > DAN) + D += 0.01f; //Incremento 1% + tcd = 0; + ECM = ESPERA_DECREMENTO; + jv++; + break; + } else { + tcd = 0; + ECM = ESPERA_FINAL; + printf("\t\tNuevo Duty = %.0f\r\n", floor(ND*100.00f)); + DAN = ND; + } + break; + case ESPERA_DECREMENTO: + if(tcd >= 2) { + ECM = CAMBIO_MENOR; + tcd = 0; + } + break; + case ESPERA_FINAL: + Rojo = 1; + if(tcd >= 100) { + ECM = INICIO_CM; + tcd = 0; + } + break; + } + +} + +//Maquina LazoCerrado +void control_PWM_Temp(void) +{ + static float temperatura = 0; + float val = 0; + switch(CPT) { + case INCIO_LAZOCERRADO: + ECM = 0; //Reincio la maquina de cambio de duty de lazo abierto.. + Rojo = 1;//Apago el Led rojo.. + Azul = 0;//Prendo el Led azuil... + /*Fijo el duty en 50%*/ + Cooler.write(0.5f); + duty = 0.5f; + printf("Lazo Cerrado!!\r\n"); + CPT = MEDICION_TEMPERATURA; + break; + + case MEDICION_TEMPERATURA: + probe.convertTemperature(false, DS1820::all_devices); + temperatura = probe.temperature(); + printf("La temperatura es de %3.1foC\r\n",temperatura ); + /*Reinicio la medicion de RPM*/ + CPT = MEDICION_RPM; + tv = 0; + EMV = INCIO_V; //Pongo en el estado inicial la maquina de medicion de velocidad + IM = 0; //Pongo en cero el acumulador para darle un TimeOut a la medicion de velocidad + break; + + case MEDICION_RPM: + /*Si termine de medir la velocidad...*/ + if(EMV == ESPERA_V) { + if(tv >= 1) { + RPM = 60.00 / (ap.read() * 2); + printf("Velocidad = %f RPM\r\n",RPM); + tv = 0; + EMV = INCIO_V; + + val = floor(temperatura * MinRPM / 20); + printf("Deberia tener %f RPM y tengo %f RPM\r\n", val, RPM); + + /*Aca me fijo si debo modificar el duty*/ + if(abs(RPM - val) > ToleranciaRPM) { + + /*Miro que duty debo enviar...*/ + if(val < RPM) + NuevoDuty = duty - DEFINICION_CAMBIO_PWM; + if(val > RPM) + NuevoDuty = duty + DEFINICION_CAMBIO_PWM; + + IM = 0; + CPT = CAMBIO_PWM; + break; + } else { + printf("EL duty es correcto! Estoy en %0.1f% :D\r\n", floor(duty * 100.0f)); + IM = 0; + CPT = ESPERA_ENTRE_MODIFICACIONES; + break; + + } + + } + } + /*Verifico que no se me apago el motor...*/ + if(IM > 10) { + printf("El cooler estaba apagadoo!!..Reiniciando Lazo cerrado..\r\n"); + EMV = INCIO_LAZOCERRADO; + IM = 0; + } + + break; + + case CAMBIO_PWM: + cambio_gradual_duty(NuevoDuty); + /*Si termine de modificar el duty*/ + if(tdm) { + IM = 0; + CPT = ESPERA_CAMBIOS_PWM; + } + break; + + case ESPERA_CAMBIOS_PWM: + /*Si se cumplio un tiempo prudencial.. El motor se debe adecuar a la nueva velocidad*/ + if(IM >= 2) { + tdm = 0; //Reinicio el flag de cambio de duty + EMV = 0; //Reinico la maquina de medicion de velocidad.. + IM = 0; //Reinicio el acumulador de tiempo + CPT = MEDICION_RPM; //Mido nuevamente la velocidad y me fijo si debo modificar denuevo + break; + } + + break; + + case ESPERA_ENTRE_MODIFICACIONES: + if(IM >= 1) + CPT = MEDICION_TEMPERATURA; + break; + } +} + +//Maquina de cambio de duty gradual.... + +void cambio_gradual_duty(float obj) +{ + static float dtf = 0; //Variable que va a guardar durante todo el proceso el objetivo, es estatico... lo modifico en el estado inicial solamente.. + + switch(FTR) { + case INICIO_CM: + dtf = obj; //Fijo el nuevo objetivo... + tdm = 0; //Aviso que estoy modificando el duty... + printf("Inicio el cambio de duty....\r\n"); + Rojo = 0; + + /*Si estoy por debajo del minimo del Cooler directamente lo apago...*/ + if(dtf < 0.07f) { + /*Apago el PWM*/ + Cooler.write(0); + duty = 0; + printf("Cooler APAGADO!\r\n"); + /*Voy al final de la maquina*/ + ty = 0; //Reinicio el acumulador de tiempo final... + FTR = ESPERA_FINAL; + Rojo = 1; + break; + } + if(dtf >= 0.5f) { + FTR = CAMBIO_MAYOR; + } else + FTR = INICIO_CAMBIO_MENOR; + break; + + case CAMBIO_MAYOR: + Cooler.write(dtf); //Coloco el nuevo valor en el PWM de una.. + //printf("\tNuevo Duty = %f%\r\n", dtf * 100); + duty = dtf; //Actualizo el duty actual.. + ty = 0; //Reinicio el acumulador de tiempo base + FTR = ESPERA_FINAL; + break; + + case INICIO_CAMBIO_MENOR: + cantv = abs( (int(duty*100)) - (int(dtf*100))); //Me fijo cuantos pasos intermedios voy a dar... + //printf("\tVoy a hacer %.0f pasos intermedios desde %.0f para llegar a %.0f%\r\n", cantv, duty*100, dtf * 100); + D = duty; //Parto desde el PWM actual + jv = 0; //Reinico el acumulador de veces + FTR = CAMBIO_MENOR; + break; + + case CAMBIO_MENOR: + /*La cantidad de pasos intermedios calculados en el estado anterior...*/ + if(cantv >= jv) { + Cooler.write(D); //Pongo el duty + //printf("\t\tEtapa intermedia en %.0f%\r\n", D * 100.00f); + /*Si quiero alcanzar un duty inferior*/ + if(dtf < duty) + D -= 0.01f; //Decremeto 1% + /*Si quiero alcanzar un duty superior*/ + if(dtf > duty) + D += 0.01f; //Incremento 1% + + if(D < 0 || D > 1) { //Si estoy en valores no logicos... + //printf("Valores de duty no logicos... ERORR!!!! D:\r\n"); + FTR = INICIO_CM; + break; + } + + jv++; //Acumulo el paso realizo en la variable(Lo cuento).. + ty = 0; //Reinicio el acumulador de tiempo + FTR = ESPERA_DECREMENTO; //Espero un tiempo para que se ajuste la salida.. + break; + } + /*Si termine con las modificaciones de duty..*/ + else { + //printf("\t\tNuevo Duty = %.0f\r\n", (D+0.01f)*100); + duty = dtf; //Guardo el nuevo valor de duty + ty = 0; //Reinicio el acumulador de tiempo base + FTR = ESPERA_FINAL; //Paso a la espera final... + } + break; + + case ESPERA_DECREMENTO: + /*Si se cumplio el tiempo*/ + if(ty >= 1) { + ty = 0; //Reinico el acumulador de tiempo + FTR = CAMBIO_MENOR;//Paso al nuevo paso + } + break; + case ESPERA_FINAL: + /*Termine el proceso de cambio de duty*/ + Rojo = 1; //Apago el led modificador.. + tdm = 1; //Notifico a las otras maquinas de estado que termine de modificar el duty.. + /*Si se cumplio el tiempo*/ + if(ty >= 1) { + ty = 0; //Reinicio el acumulador de tiempo + FTR = INICIO_CM; //Vuelvo al estado inicial del proceso.. + } + break; + } +} + +void medicion_velocidad(void) +{ + if(EMV == ESPERA_V) { + if(tv >= 1) { + RPM = 60.00 / (ap.read() * 2); + printf("Velocidad maxima = %f RPM\r\n",RPM); + VMAX = RPM; + tv = 0; + EMV = INCIO_V; + Modo = LazoAbierto; + printf("Modo Lazo Abierto...!\r\n"); + } + } +} \ No newline at end of file