main.cpp

00001 /*
00002  * - Proyecto:      Apagado Temporizado MEGAPACA
00003  * - Lenguaje:      ANSI C/C++ (mbed)
00004  * - Tarjeta:       NUCLEO F303K8
00005  * - Referencias:
00006  * - Fecha:         2017/Septiembre
00007  * - Autor(es):     Felícito Manzano /
00008                     Mario Vargas
00009  * - Compañia:      V.S.R. de Centroamérica
00010  * - País:          SV / CR
00011  */
00012 
00013 #include "mbed.h"
00014 #include "BufferedSerial.h"
00015 #include "constantes.hpp"
00016 #include "funciones_basicas.h"
00017 #include "PinDetect.h"
00018 
00019 /*  CONFIGURACIÓN DE HARDWARE
00020 ************************************** */
00021 BufferedSerial  gv300(USBTX, USBRX);
00022 PinDetect       input(PA_10); //PC_13
00023 DigitalOut      myled(LED1); 
00024 
00025 // DECLARACIÓN DE VARIABLES
00026 //**************************************
00027 float           tiempo_actual           = 0.0;      // Para almacenar el valor del temporizador
00028 int             contador_tramas         = 2;        // Para contar las tramas enviadas a SKT300
00029 int             factor                  = 1;        // Para multiplicar
00030 int             i                       = 0;        // Uso genérico
00031 int             contador_pulsos         = 0;
00032 bool            apagar                  = false;
00033 char            skytrack_frame[128];                // Salida de datos para SKT300
00034 char            buffered_frame[128];                      // Salida temporal de datos
00035 
00036 
00037 // DECLARACIÓN DE TEMPORIZADORES
00038 //**************************************
00039 Timer           funcionando;        // Temporizador para generar el motivo por tiempo de lectura de la tarjeta NUCLEO
00040 Timer           apagando_cp;        // Temporizador para consultar el estatus de la puerta.
00041 
00042 // Funciones de Interrupción
00043 void flanco_negativo_SKT300N() {
00044     contador_pulsos++;
00045 }
00046 
00047 int main() {
00048     // CONFIGURAR INTERFACES
00049     //***********************************
00050     gv300.baud(115200);
00051     input.mode(PullUp);
00052     input.attach_asserted(&flanco_negativo_SKT300N);
00053     input.setSampleFrequency(50000);
00054     wait(0.4);
00055     iniciando(&gv300);
00056     
00057     // Inicio de temporizadores y RTC
00058     funcionando.start();
00059         
00060     while(1) {
00061         
00062         // Validar puslsos.
00063         if (contador_pulsos >= 1) {
00064             myled = 1;
00065             wait(7.0);
00066             if (contador_pulsos == PULSOS_APAGAR) {
00067                 apagar = true;
00068             } else {
00069                 apagar = false;
00070             }
00071             contador_pulsos = 0;
00072             myled = 0;
00073         }
00074         
00075         
00076         // CONSULTAR SI SE HA PRESIONADO EL BOTÓN 
00077         if ((apagar) && (apagando_cp.read() < 0.5)) {
00078             //pcusb.printf("\r\nBoton de panico presionado.\r\n");
00079             //pcusb.printf("Apagando en T-15\r\n");
00080             apagar = false;
00081             apagando_cp.start();
00082             sprintf(skytrack_frame,"%s%s%s%s%04X%s", 
00083                     CABECERA_TX, CODIGO_INT, INIT_SHUTDOWN, 
00084                     FIN_CABECERA_TX, contador_tramas, ULTIMO_CARACTER);
00085             gv300.printf("%s\r\n", skytrack_frame);
00086             memset(skytrack_frame, '\0', sizeof(skytrack_frame));               // Vaciar el buffer de Skytrack Frame
00087             incrementar_trama(&contador_tramas);
00088         }
00089 
00090         // VALIDAR SI SE DEBE ABORTAR
00091         // Leer puerto Serial
00092         if (leer_uart(&gv300, buffered_frame)) {
00093             //pcusb.printf("Trama recibida...\r\n");
00094             i = procesar_trama(buffered_frame);
00095             if(i == 1) { // 1 = ABORTAR
00096                 apagar = 0;
00097                 factor = 1;
00098                 apagando_cp.stop();
00099                 apagando_cp.reset();
00100                 sprintf(skytrack_frame,"%s%s%s%s%04X%s", 
00101                     CABECERA_TX, CODIGO_INT, CANC_SHUTDOWN, 
00102                     FIN_CABECERA_TX, contador_tramas, ULTIMO_CARACTER);
00103                 gv300.printf("%s\r\n", skytrack_frame);
00104                 //pcusb.printf("Apagado por panico ABORTADO.\r\n");
00105             } else if (i == 3){
00106                 // Nada por hacer por el OK
00107             } else {
00108                 // pcusb.printf("Trama DESCONOCIDA.\r\n");
00109             }
00110         }
00111 
00112         // CONSULTAR SI SE DEBE APAGAR
00113         tiempo_actual = apagando_cp.read();                              // Leer el temporizador de Heartbeat
00114         if (tiempo_actual >= (MINUTO * factor)) {
00115             //pcusb.printf("Apagando en T-%d\r\n", (T_15 - factor));
00116             factor++;
00117         }
00118 
00119         if (tiempo_actual >= TIME_SHUTDOWN) {
00120             //pcusb.printf("Apangado en progreso...\r\n");
00121             apagando_cp.stop();
00122             apagando_cp.reset();
00123             apagar = 0;
00124             factor = 1;
00125             gv300.printf("%s\r\n", SHUTDOWN_TXT);
00126             wait_ms(T_TX);
00127             // Leer puerto Serial
00128             i = leer_uart(&gv300, buffered_frame);
00129             if (i) {
00130                 // Confirmar resultado de Apagado
00131                 i = procesar_trama(buffered_frame);
00132                 if (i == 2) { // +ACK
00133                     sprintf(skytrack_frame,"%s%s%s%s%04X%s", 
00134                         CABECERA_TX, CODIGO_INT, SHUTDOWN_DONE, 
00135                         FIN_CABECERA_TX, contador_tramas, ULTIMO_CARACTER);
00136                     gv300.printf("%s\r\n", skytrack_frame);
00137                     //pcusb.printf("Apagado remoto +EXITOSO!\r\n");
00138                 } else {
00139                     sprintf(skytrack_frame,"%s%s%s%s%04X%s", 
00140                         CABECERA_TX, CODIGO_INT, SHUTDOWN_ERRO, 
00141                         FIN_CABECERA_TX, contador_tramas, ULTIMO_CARACTER);
00142                     gv300.printf("%s\r\n", skytrack_frame);
00143                     //pcusb.printf("Apagado remoto -FALLIDO!\r\n");    
00144                 }
00145             }  else { 
00146                 sprintf(skytrack_frame,"%s%s%s%s%04X%s", 
00147                         CABECERA_TX, CODIGO_INT, SHUTDOWN_ERRO, 
00148                         FIN_CABECERA_TX, contador_tramas, ULTIMO_CARACTER);
00149                 gv300.printf("%s\r\n", skytrack_frame);
00150                 //pcusb.printf("Apagado remoto -FALLIDO!\r\n");
00151             }
00152         }
00153 
00154         // ENVIAR HEARTBEAT A SKYTRACK
00155         tiempo_actual = funcionando.read();                              // Leer el temporizador de Heartbeat
00156         if (tiempo_actual >= TIME_HEARTBEAT) {
00157             //pcusb.printf("\r\nMultipuertos estable.\r\n");
00158             funcionando.reset();
00159             sprintf(skytrack_frame, "%s%s%04X%s\r\n",
00160                     ALIVE, FIN_CABECERA_TX, contador_tramas, ULTIMO_CARACTER);
00161             gv300.printf("%s\r\n", skytrack_frame);
00162             memset(skytrack_frame, '\0', sizeof(skytrack_frame));               // Vaciar el buffer de Skytrack Frame
00163             incrementar_trama(&contador_tramas);
00164         }
00165     }
00166 }