f_basicas.cpp

00001 /**
00002  * @file f_basicas.cpp
00003  * @author Felícito Manzano (felicito.manzano@detektor.com.sv)
00004  * @brief 
00005  * @version 0.1
00006  * @date 2021-05-23
00007  * 
00008  * @copyright Copyright (c) 2021
00009  * 
00010  */
00011 
00012 #include "mbed.h"
00013 #include "BufferedSerial.h"
00014 #include "constantes.hpp "
00015 #include "tagid.hpp "
00016 #include "f_basicas.hpp "
00017 
00018 
00019 
00020 /**
00021  * @brief 
00022  *  Esta función recibe un entero que es el contador de tramas
00023     realiza el incremento en uno y verifica si el valor es mayor
00024     o igual que 65535 que es equivalente a 0xFFFF. Si se cumple
00025     la condución se regresa el valor a 1.
00026     Esta función siempre retorna 0.
00027  * 
00028  * @param tramas 
00029  * @return true 
00030  * @return false 
00031  */
00032 bool incrementar_trama(int *tramas)
00033 {
00034 
00035     int actual = *tramas;
00036     int limite = 65535;
00037     actual++;
00038 
00039     if (actual > limite) {
00040         *tramas = 1;
00041     } else {
00042         *tramas = actual;
00043     }
00044     return(false);
00045 }
00046 
00047 
00048 
00049 /**
00050  * @brief 
00051  * 
00052  * @param puerto_usb 
00053  * @param puerto_cp 
00054  * @return true 
00055  * @return false 
00056  */
00057 bool booting_gtdat (Serial *puerto_usb, Serial *puerto_cp) {
00058     wait_us(1000000);
00059     puerto_usb -> printf("\r\n*** DETEKTOR LATAM ***\r\n");
00060     puerto_usb -> printf("INICIANDO NUCLEO STM32\r\n");
00061     puerto_usb -> printf("CCN TIEMPO EN PLANTA\r\n");
00062     puerto_usb -> printf("R.0A.1 - 2021-05-24\r\n\r\n");
00063     puerto_usb -> printf("BAHIA-%d\r\n", BAY_ADDRESS);
00064     puerto_cp  -> printf("%s*INICIA BAHIA-%d*%s0001%s\r\n", 
00065                     CABECERA_TX, BAY_ADDRESS, FIN_CABECERA_TX, ULTIMO_CARACTER);
00066     wait_us(T_TX);
00067     return(false);
00068 }
00069 
00070 
00071 
00072 /**
00073  * @brief 
00074  * 
00075  *  Esta función recibe los digitos correspondientes a las horas, decenas y
00076     minutos que representan la hora y que deben presentarse en los tres
00077     display de siete segmentos. La función siempre retorna 0.
00078  * @param horas 
00079  * @param decenas 
00080  * @param minutos 
00081  * @param d7_h 
00082  * @param d7_d 
00083  * @param d7_m 
00084  * @return int 
00085  */
00086 int presentar_tiempo(int *horas, int *decenas, int *minutos,
00087                      BusOut *d7_h, BusOut *d7_d, BusOut *d7_m)
00088 {
00089     // Digito más significativo (HORAS)
00090     switch (*horas) {
00091         case 0 :
00092             d7_h -> write(DIGITOS[CERO_7S]);
00093             break;
00094         case 1 :
00095             d7_h -> write(DIGITOS[UNO_7S]);
00096             break;
00097         case 2 :
00098             d7_h -> write(DIGITOS[DOS_7S]);
00099             break;
00100         case 3 :
00101             d7_h -> write(DIGITOS[TRES_7S]);
00102             break;
00103         case 4 :
00104             d7_h -> write(DIGITOS[CUATRO_7S]);
00105             break;
00106         case 5 :
00107             d7_h -> write(DIGITOS[CINCO_7S]);
00108             break;
00109         case 6 :
00110             d7_h -> write(DIGITOS[SEIS_7S]);
00111             break;
00112         case 7 :
00113             d7_h -> write(DIGITOS[SIETE_7S]);
00114             break;
00115         case 8 :
00116             d7_h -> write(DIGITOS[OCHO_7S]);
00117             break;
00118         case 9 :
00119             d7_h -> write(DIGITOS[NUEVE_7S]);
00120             break;
00121         case 10:
00122             d7_h -> write(DIGITOS[APAGADO_7S]);
00123             break;
00124     }
00125 
00126     // DECENAS DE MINUTOS
00127     switch (*decenas) {
00128         case 0 :
00129             d7_d -> write(DIGITOS[CERO_7S]);
00130             break;
00131         case 1 :
00132             d7_d -> write(DIGITOS[UNO_7S]);
00133             break;
00134         case 2 :
00135             d7_d -> write(DIGITOS[DOS_7S]);
00136             break;
00137         case 3 :
00138             d7_d -> write(DIGITOS[TRES_7S]);
00139             break;
00140         case 4 :
00141             d7_d -> write(DIGITOS[CUATRO_7S]);
00142             break;
00143         case 5 :
00144             d7_d -> write(DIGITOS[CINCO_7S]);
00145             break;
00146         case 6 :
00147             d7_d -> write(DIGITOS[SEIS_7S]);
00148             break;
00149         case 7 :
00150             d7_d -> write(DIGITOS[SIETE_7S]);
00151             break;
00152         case 8 :
00153             d7_d -> write(DIGITOS[OCHO_7S]);
00154             break;
00155         case 9 :
00156             d7_d -> write(DIGITOS[NUEVE_7S]);
00157             break;
00158         case 10:
00159             d7_d -> write(DIGITOS[APAGADO_7S]);
00160             break;
00161     }
00162 
00163     // Digito menos significativo (MINUTOS  )
00164     switch (*minutos) {
00165         case 0 :
00166             d7_m -> write(DIGITOS[CERO_7S]);
00167             break;
00168         case 1 :
00169             d7_m -> write(DIGITOS[UNO_7S]);
00170             break;
00171         case 2 :
00172             d7_m -> write(DIGITOS[DOS_7S]);
00173             break;
00174         case 3 :
00175             d7_m -> write(DIGITOS[TRES_7S]);
00176             break;
00177         case 4 :
00178             d7_m -> write(DIGITOS[CUATRO_7S]);
00179             break;
00180         case 5 :
00181             d7_m -> write(DIGITOS[CINCO_7S]);
00182             break;
00183         case 6 :
00184             d7_m -> write(DIGITOS[SEIS_7S]);
00185             break;
00186         case 7 :
00187             d7_m -> write(DIGITOS[SIETE_7S]);
00188             break;
00189         case 8 :
00190             d7_m -> write(DIGITOS[OCHO_7S]);
00191             break;
00192         case 9 :
00193             d7_m -> write(DIGITOS[NUEVE_7S]);
00194             break;
00195         case 10:
00196             d7_m -> write(DIGITOS[APAGADO_7S]);
00197             break;
00198     }
00199 
00200     return(0);
00201 }
00202 
00203 int presentar_torre(const int *color, BusOut *torre_luz)
00204 {
00205     /*
00206     Esta función recibe el código de color correspondiente a la torre de luz
00207     estilo semaforo para activar el LED correspondiente.
00208     La función siempre retorna 0
00209     */
00210 
00211     switch (*color) {
00212         case 0 :
00213             torre_luz -> write(COLOR_TORRE_LUZ[APAGADO_TL]);
00214             break;
00215         case 1 :
00216             torre_luz -> write(COLOR_TORRE_LUZ[VERDE]);
00217             break;
00218         case 2 :
00219             torre_luz -> write(COLOR_TORRE_LUZ[AMARILLO]);
00220             break;
00221         case 3 :
00222             torre_luz -> write(COLOR_TORRE_LUZ[ROJO]);
00223             break;
00224     }
00225 
00226     return(0);
00227 }
00228 
00229 
00230 
00231 /**
00232  * @brief 
00233  *  Esta función se encarga de buscar el grupo al que está asignado el TAGRFiD
00234        que ha sido leido por el lector. Se ha predefinido 3 arreglos con los TAG
00235        validos. En función del arreglo en que se genere la coincidencia se retorna
00236        el tiempo para cambiar.
00237        La función retorna 1 cuando encuentra coincidencia. 0 cuando no encuentra coincidencia y
00238        se define el tiempo de la torre de luz amarillo y rojo en 50 minutos y 1 hora.
00239  * 
00240  * @param id 
00241  * @param amarillo 
00242  * @param rojo 
00243  * @return int 
00244  */
00245 int tiempo_asignado(char id[9], int *amarillo, int *rojo)
00246 {
00247     int i = 0;
00248     int v = 0;
00249     int busca_id = 0;
00250 
00251     for (i=0; i<TOTAL_PLACAS_A; i++) {
00252         busca_id = strncmp(PLACAS_A[i], id, 10);
00253         if (busca_id == 0) {
00254             *amarillo = GRUPO_A_AMARILLO;
00255             *rojo = GRUPO_A_ROJO;
00256             v = 1; return(1);
00257         }
00258     }
00259 
00260     for (i=0; i<TOTAL_PLACAS_B; i++) {
00261         busca_id = strncmp(PLACAS_B[i], id, 10);
00262         if (busca_id == 0) {
00263             *amarillo = GRUPO_B_AMARILLO;
00264             *rojo = GRUPO_B_ROJO;
00265             v = 1; return(1);
00266         }
00267     }
00268 
00269     for (i=0; i<TOTAL_PLACAS_C; i++) {
00270         busca_id = strncmp(PLACAS_C[i], id, 10);
00271         if (busca_id == 0) {
00272             *amarillo = GRUPO_C_AMARILLO;
00273             *rojo = GRUPO_C_ROJO; 
00274             v = 1; return(1);
00275         }
00276     }
00277 
00278     if (v) {
00279         return(1);
00280     } else {
00281         *amarillo = GRUPO_DEFAULT_AMARILLO;
00282         *rojo = GRUPO_DEFAULT_ROJO;
00283         return(0);
00284     }
00285 }
00286 
00287 
00288 
00289 /**
00290  * @brief 
00291  * 
00292  *  Esta función se encarga de analisar el payload de una
00293     huella que es enviada dentro de una cadena (char array)
00294     expresada de manera hexadecimal. en su equivalente de código
00295     ASCII que es guardado en otra cadena.
00296 
00297  * @param id_original 
00298  * @param id_hex 
00299  * @param tamano_id 
00300  * @return int 
00301  */
00302 int convertir_id(char id_original[256], char id_hex[15], int *tamano_id)
00303 {
00304     int i = 0;
00305     int j = 0;
00306     int limite = *tamano_id;
00307     int k = 0;
00308     char tmp_buffer_ascii[77];
00309 
00310     memset(tmp_buffer_ascii, '\0', sizeof tmp_buffer_ascii);
00311     memset(id_hex, '\0', sizeof id_hex);
00312 
00313     for (i=0; i<limite; i++) {
00314         snprintf(&tmp_buffer_ascii[j*2], 3,"%02X", id_original[i]);
00315         j++;
00316     }
00317 
00318     limite = strlen(tmp_buffer_ascii);
00319     k = limite - 14;
00320 
00321     strncpy(id_hex, &tmp_buffer_ascii[k], 14);
00322     id_hex[15] = '\0';
00323 
00324     return(1);
00325 }
00326 
00327 
00328 
00329 /**
00330  * @brief 
00331  *  Esta funsión se utiliza para limpiar el buffer de recepción del puerto seleccionado.
00332     No se guarda ninguna información. Siempre devuelve true
00333  * 
00334  * @param uart 
00335  * @return true 
00336  * @return false 
00337  */
00338 bool flush_uart_rx(BufferedSerial *uart)
00339 {
00340     while (uart -> readable()) {
00341         uart -> getc();
00342     }    
00343     return(true);
00344 }
00345 
00346 
00347 
00348 
00349 
00350 
00351 /**
00352  * @brief 
00353  * 
00354  */
00355 extern Serial  pcusb;
00356 extern BusOut  torreLuz;
00357 extern BusOut  display_H;
00358 extern BusOut  display_dM;
00359 extern BusOut  display_uM;
00360 extern Ticker  ticker_minuto; 
00361 extern Timer   t_ocupado;
00362 extern Timer   t_apagado;
00363 extern float   tiempo_actual;
00364 extern bool    mostrar_tiempo;
00365 extern char    actual_trailerID_HEX[];
00366 extern char    antena_trailerID_HEX[];
00367 extern int     rtc_delta;
00368 extern int     uminutos;
00369 extern int     dminutos;
00370 extern int     horas;
00371 extern int     tiempo_luz_amarilla;
00372 extern int     tiempo_luz_roja;
00373 
00374 void actualizar_minuto() {
00375     // ACTUALIZACIÓN DE PANTALLA DE CRONOMETRO
00376     uminutos++; // Acumular un minuto
00377     if (uminutos >= 10) { // Si es 10 cambiar 0
00378         uminutos = 0;
00379         dminutos++; // Acumularse las decenas de minutos
00380     }
00381     if (dminutos >= 6) { // Si es 6 cambiar 0
00382         dminutos = 0; // Acumular una hora
00383         horas++;
00384     }
00385 
00386     if (mostrar_tiempo) {
00387         rtc_delta = (int)t_ocupado.read();
00388         pcusb.printf("\r\nTiempo total en Bahia: %d segundos", rtc_delta);
00389 
00390         if ((rtc_delta >= tiempo_luz_amarilla) && (rtc_delta < tiempo_luz_roja)) { // Si estamos en el rango de 50 - 59 minutos
00391             pcusb.printf("\r\nSemaforo AMARILLO...");
00392             presentar_torre(&AMARILLO, &torreLuz); // Activar luz ambar
00393         } else if (rtc_delta >= tiempo_luz_roja) {
00394             pcusb.printf("\r\nSemaforo ROJO...");
00395             presentar_torre(&ROJO, &torreLuz); // Activar luz roja
00396         } else {
00397             presentar_torre(&VERDE, &torreLuz); // Activar luz ambar
00398         }
00399         presentar_tiempo(&horas, &dminutos, &uminutos, &display_H, &display_dM, &display_uM);// Actualizar la vista del cronometro
00400         pcusb.printf("\r\nTiempo actual [H:MM] = %d:%d%d\r\n\r\n", horas, dminutos, uminutos);
00401     } else {
00402         tiempo_actual =  t_apagado.read();
00403         if (tiempo_actual >= (TIEMPO_RECARGA)) {
00404             pcusb.printf("\r\nSobrepasa limite de %d segundos con pantallas apagadas", TIEMPO_RECARGA);
00405             pcusb.printf("\r\nSe descarta TAG actual y reinicia contadores.\r\n");
00406             ticker_minuto.detach();
00407             t_apagado.stop();
00408         }
00409     }
00410 
00411 
00412 }
00413 
00414 
00415 /**
00416  * @brief 
00417  * 
00418  */
00419 extern Serial   gv300;
00420 extern char     skytrack_frame[];
00421 extern int      contador_tramas;
00422 void tx_skytrack()
00423 {
00424     sprintf(skytrack_frame, "%s%s%s%s%04X%s",
00425             CABECERA_TX,CODIGO_INT,ALIVE, FIN_CABECERA_TX, contador_tramas, ULTIMO_CARACTER);
00426     gv300.printf("%s\r\n", skytrack_frame);
00427     
00428     incrementar_trama(&contador_tramas);
00429     pcusb.printf("\r\n%s", ALIVE);
00430 }