Guillermo Stedile
/
SNOCC_V2
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Dependencies: NAVDATA RA8875 SDFileSystem VCODATA mbed
Diff: main.cpp
- Revision:
- 1:30b1ca228fc7
- Parent:
- 0:e40cf759ba9a
- Child:
- 2:968b38c3ef49
--- a/main.cpp Mon May 15 22:52:48 2017 +0000
+++ b/main.cpp Fri Jun 23 03:59:11 2017 +0000
@@ -7,51 +7,42 @@
#include "BPG_Arial20x20.h"
#include "BPG_Arial31x32.h"
#include "BPG_Arial63x63.h"
-
-// Agrego includes para uso en la comunicacion con el gps.
-#include "GPS.h"
-// Agrego includes para la clase NAVDATA que maneja los datos de navegación del último período.
-#include "NAVDATA.h"
-// Agrego includes para la clase VCODATA que maneja los datos de navegación más recientes parametrizados por velocidad de cada período.
-#include "VCODATA.h"
-// Agrego include para SD Card
-#include "SDFileSystem.h"
-
-
-#include <sstream> //include this to use string streams
+#include "GPS.h" // Comunicacion con el gps.
+#include "NAVDATA.h" // Para la clase NAVDATA que maneja los datos de navegación del último período.
+#include "VCODATA.h" // Para la clase VCODATA que maneja los datos de navegación más recientes parametrizados por velocidad de cada período.
+#include "SDFileSystem.h" // SD Card
+#include <sstream> // Para uso de streams
#include <string>
+int err_Store=0;
+int TESTING=0; // -->1:Habilita test de funcionamiento del almacenamiento de datos.
+int DEBUG1=1; // -->1:Habilita informacion para debug.
+int DEBUG2=1; // -->1:Habilita informacion para debug2.
+int DEBUG_GPS=0; // -->1:Habilita datos para debug de comunicacion con gps.
+enum sentido{DWN=0,UP,NO};
+enum figura{ZONA=0,SIN_DT,CIRC,FLECHA,ElIP};
const char *sd_dir="/sd/snocc"; // Directorio de almacenamiento de datos.
const char *sd_file="/sd/snocc/sdsnocc.csv"; // Archivo csv de almacenamiento de datos.
-int poll_init=0; // Testigo de inicio de recoleccion de datos.
+const int V_M=54; //Velocidad Maxima
float Counter=0; //Contador de pulsos del sensor de flujo.
float LCounter=0; //Consumo en litros
-const int V_M=100; //Velocidad Maxima
-NAVDATA NAVIGATION_TABLE; //Objeto que maneja los datos de navegación del último período. $
-VCODATA NAVIGATION_VMATRIX(NAVIGATION_TABLE, V_M); // Objeto que maneja la matriz de datos de navegación $
-//VCODATA NAVIGATION_V_INTRP_MTRX(NAVIGATION_TABLE, V_M); // Objeto que maneja la matriz de datos de navegación interpolados $
-VCODATA NAVIGATION_V_SMOOTH_MTRX(NAVIGATION_TABLE, V_M); // Objeto que maneja la matriz de datos de navegación promediados $
-
-
-LocalFileSystem local("local"); // Because I want <PrintScreen>
-Serial pc(USBTX, USBRX); // And a little feedback
+NAVDATA NAVIGATION_OBJECT; //Objeto que maneja los datos de navegación del último período. (ANTERIORMENTE LLAMADO NAVIGATION_TABLE, nombre que generaba confusion)
+VCODATA NAVIGATION_VMATRIX(NAVIGATION_OBJECT, V_M); // Objeto que maneja la matriz de datos de navegación $
+VCODATA NAVIGATION_V_SMOOTH_MTRX(NAVIGATION_OBJECT, V_M); // Objeto que maneja la matriz de datos de navegación promediados $
+NAVDATA TestNAV; // Objeto para crear matriz default; /// DEBUG?
-RA8875 lcd(p5, p6, p7, p8, NC, "tft"); // MOSI, MISO, SCK, /ChipSelect, /reset, name
-
-SDFileSystem sd(p11, p12, p13, p14, "sd"); // SD CARD: mosi, miso, sclk, cs
-
+LocalFileSystem local("local"); // Para <PrintScreen>
+Serial pc(USBTX, USBRX);
+RA8875 lcd(p5, p6, p7, p8, NC, "tft"); // MOSI, MISO, SCK, /ChipSelect, /reset, name // Comunicacion con Display
+SDFileSystem sd(p11, p12, p13, p14, "sd"); // SD CARD: mosi, miso, sclk, cs // Comunicacion con SD card
-//>>>>>>>>>>>>>>>>>> SECCION AGREGADA PROVISORIAMENTE PARA EL TOUCH PANEL <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-
+//>>>>>>>>>>>>>>>>>> SECCION TOUCH PANEL <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
extern "C" void mbed_reset();
-
-
#define min(a,b) ((a<b)?a:b)
#define max(a,b) ((a>b)?a:b)
-
bool Intersect(rect_t rect, point_t p)
{
if (p.x >= min(rect.p1.x, rect.p2.x) && p.x <= max(rect.p1.x, rect.p2.x)
@@ -60,12 +51,10 @@
else
return false;
}
-
int GetScreenCapture(void)
{
char fqfn[50];
int i = 0;
-
pc.printf("Screen Capture... ");
for (i=1; i< 100; i++) {
snprintf(fqfn, sizeof(fqfn), "/local/Screen%02d.bmp", i);
@@ -75,12 +64,12 @@
pc.printf(" as /local/Screen%02d.bmp\r\n", i);
return i;
} else {
- fclose(fh); // close this and try the next
+ fclose(fh);
}
}
return 0;
}
-//>>>>>>>>>>>>>>>>>> FIN SECCION AGREGADA PROVISORIAMENTE PARA EL TOUCH PANEL <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+//>>>>>>>>>>>>>>>>>> FIN SECCION TOUCH PANEL <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
//Función para la interrupción
@@ -95,15 +84,16 @@
void print_VCO_curve(VCODATA &Matrix_VCO, int interpolated){
//lcd.puts("ENTRANDO a print_VCO_curve\r\n"); // DEBUG
+ int vcc[2];
float s; // Consumo
int y,x;
- int VCO= Matrix_VCO.get_VCO();
+ int VCO= Matrix_VCO.get_VCO(vcc);
int y_offset=250; //Para que imprima de abajo hacia arriba.
int y_text_offset=15; //Para cooregir diferencia de impresion entre caracter y linea.
int x_offset=30; //Posicionamiento en x
int y_i=y_offset; //Punto origen y
int x_i=x_offset; //Punto origen x
- int x_scale=4; // Escala para graficar eje x.
+ int x_scale=8; // Escala para graficar eje x.
int y_scale=90; // Escala para graficar eje y.
lcd.background(RGB(255,255,255));
lcd.foreground(Blue);
@@ -155,7 +145,7 @@
lcd.SetTextCursor(420,235);
lcd.puts("Vel.(kn)\r\n");
lcd.line(x_i,y_i,Matrix_VCO.vel_max*x_scale+x_offset,y_i); // Imprimo eje x.
- for(int j=10;j<=100;j+=10){
+ for(int j=10;j<=Matrix_VCO.vel_max;j+=10){
int x=j*x_scale+x_offset;
lcd.line(x,y_i,x,y_i-5);
lcd.SetTextCursor(x,y_i+5);
@@ -180,7 +170,7 @@
lcd.printf("*");
}
lcd.SetTextCursor(VCO*x_scale+x_offset+10,y_offset-s*y_scale+20);
- lcd.printf("%f l/m",s);
+ lcd.printf("%lf l/m",s);
lcd.SetTextCursor(VCO*x_scale+x_offset+10,y_offset-s*y_scale+40);
lcd.printf("VCO: %d kn",VCO);
@@ -196,7 +186,7 @@
}
- /* Funcion print_VCO_data : Imprime una tabla con los datos de consumo/milla en funcion de la velocidad a partir del vector de objetos NAV_DATA de la clase VCODATA, con lineas (printline=1) o puntos (=0)
+ /* Funcion print_VCO_data : Imprime una tabla con los datos de consumo/milla en funcion de la velocidad a partir del vector de objetos NAV_DATA de la clase VCODATA.
Parametros: Objeto VCODATA; */
void print_VCO_data(VCODATA &Matrix_VCO){
@@ -210,14 +200,14 @@
for (int n=0;n<83;n++){ // Recorre x de 0 a 83. (Maxima cantidad que entra en una pantalla)
cons = Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[cons_mile_p]; // Consumo por milla del período
vel= Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[speed_p]; // Velocidad del período.
- lcd.printf("| %d - %f | %f |",n,vel,cons);
+ lcd.printf("| %d - %lf | %lf |",n,vel,cons);
}
wait(3);
lcd.cls();
for (int n=83;n<Matrix_VCO.vel_max;n++){ // Recorre x de 0 a vel_max.
cons = Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[cons_mile_p]; // Consumo por milla del período
vel= Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[speed_p]; // Velocidad del período.
- lcd.printf("| %d - %f | %f |",n,vel,cons);
+ lcd.printf("| %d - %lf | %lf |",n,vel,cons);
}
//lcd.SelectUserFont(BPG_Arial20x20); // Seleccion de tipo y tamaño de letras
@@ -227,17 +217,14 @@
/* Funcion mtrx2sd: Guarda los datos de la matriz en un archivo de texto existente*/
int mtrx2sd(VCODATA &Matrix_VCO, const char *filename){
- float lngtd_f,lngtd_i,lttd_f,lttd_i,tm_f,tm_i,dstnc_p,spd_p,cnsmptn_i,cnsmptn_f,cnsmptn_p,cns_ml_p,cns_hr_p,cns_ntrpltd; // Variables de navegacion;
+ double lngtd_f,lngtd_i,lttd_f,lttd_i,tm_f,tm_i,dstnc_p,spd_p,cnsmptn_i,cnsmptn_f,cnsmptn_p,cns_ml_p,cns_hr_p,cns_ntrpltd; // Variables de navegacion;
FILE *fp1;
fp1 = fopen(filename, "w"); //Apertura para escritura
if(fp1 == NULL) {
//error("Could not open file for write\n");
return -1;
}
- for (int n=0;n<Matrix_VCO.vel_max;n++){
- //cons = Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[cons_mile_p]; // Consumo por milla del período
- //vel= Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[speed_p]; // Velocidad del período.
-
+ for (int n=0;n<=Matrix_VCO.vel_max;n++){
lngtd_f= Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[longitude_f]; // Longitud y Latitud iniciales y finales.
lngtd_i= Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[longitude_i];
lttd_f= Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[latitude_f];
@@ -252,8 +239,7 @@
cns_ml_p= Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[cons_mile_p]; // Consumo en litros por milla nautica.
cns_hr_p= Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[cons_hour_p]; // Consumo en litros por hora.
cns_ntrpltd= Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[cons_interpolated]; // Consumo interpolado?: -1-> initial padding
-
-
+
fprintf(fp1,"%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f\r\n",lngtd_f,lngtd_i,lttd_f,lttd_i,tm_f,tm_i,dstnc_p,spd_p,cnsmptn_i,cnsmptn_f,cnsmptn_p,cns_ml_p,cns_hr_p,cns_ntrpltd);
}
return fclose(fp1);
@@ -262,7 +248,7 @@
/* Funcion sd2mtrx: Guarda los datos de un archivo de texto existente en la matriz*/
int sd2mtrx(VCODATA &Matrix_VCO, const char *filename){
- float lngtd_f,lngtd_i,lttd_f,lttd_i,tm_f,tm_i,dstnc_p,spd_p,cnsmptn_i,cnsmptn_f,cnsmptn_p,cns_ml_p,cns_hr_p,cns_ntrpltd; // Variables de navegacion;
+ double lngtd_f,lngtd_i,lttd_f,lttd_i,tm_f,tm_i,dstnc_p,spd_p,cnsmptn_i,cnsmptn_f,cnsmptn_p,cns_ml_p,cns_hr_p,cns_ntrpltd; // Variables de navegacion;
FILE *fp1;
fp1 = fopen(filename, "r"); //Apertura para escritura
if(fp1 == NULL) {
@@ -270,7 +256,7 @@
return -1;
}
for (int n=0;n<Matrix_VCO.vel_max;n++){
- fscanf(fp1,"%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f",&lngtd_f,&lngtd_i,<td_f,<td_i,&tm_f,&tm_i,&dstnc_p,&spd_p,&cnsmptn_i,&cnsmptn_f,&cnsmptn_p,&cns_ml_p,&cns_hr_p,&cns_ntrpltd); // Leemos un float y lo guardamos
+ fscanf(fp1,"%lf;%lf;%lf;%lf;%lf;%lf;%lf;%lf;%lf;%lf;%lf;%lf;%lf;%lf",&lngtd_f,&lngtd_i,<td_f,<td_i,&tm_f,&tm_i,&dstnc_p,&spd_p,&cnsmptn_i,&cnsmptn_f,&cnsmptn_p,&cns_ml_p,&cns_hr_p,&cns_ntrpltd); // Leemos un double y lo guardamos
Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[longitude_f]=lngtd_f;
Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[longitude_i]=lngtd_i;
Matrix_VCO.NAV_DATA[n].LAST_NAV_DATA[latitude_f]=lttd_f;
@@ -291,70 +277,205 @@
}
/* Funcion build_default_Mtrx: Carga los datos (consumo/milla) del vector LAST_NAV_DATA de los objetos NAVDATA de VCODATA para testing.*/
+/* Si el parámetro virtual_speed es cero, se completa la matríz con valores default. Sino, se carga
+ solamente un vector NAVDATA con valores default consistentes con los parámetros y se almacena en la matríz cuando la cantidad
+ de períodos a vel constante es alcanzada. Este caso es utilizado para testing.*/
-void build_default_Mtrx(VCODATA &Test_Matrix_VCO){
-
- NAVDATA TestNDO;
+int build_default_Mtrx(VCODATA &Test_Matrix_VCO,NAVDATA &TestNDO, double virtual_speed, double virtual_timestamp){
+ double virtual_time=0;
+ double virtual_longitude=-58.5797; // Mantiene cte la Longitud.
+ double virtual_latitude=-34.4251;
+ double virtual_counter=0;
+ if (virtual_speed==0){
+ //virtual_timestamp=0.00000001; // en segundos
+ for (int i=1; i< Test_Matrix_VCO.vel_max; i++){
+ virtual_speed= i*1.0;
+
+ if (i<12) virtual_time=5.0*i; // Formato NMEA: hhmmss,ss
+ else {
+ int mnts=int(5*i/60);
+ virtual_time = ((mnts*100) +((5*i)- (mnts*60))); // Formato NMEA: (hh)mmss,ss
+ }
+ TestNDO.LAST_NAV_DATA[cons_interpolated]=-1; // --> -1:Datos iniciales.
+ TestNDO.np_concat=0; // Cantidad de periodos concatenados:-->0: Solo valores de inicio.
+ virtual_latitude+=(virtual_speed*5/3600)/(59.99999981628485);// Tomo delta_t virtual de (virtual_speed*Delta t) y // calculo latitud recorrida en virtual_timestamp @virtual_speed y longitud cte.
+ if (i<10) virtual_counter+=0.6*i*i; // Simulacion de consumo; modificar y probar
+ else if (i<20) virtual_counter+=55;
+ else if(i<30) virtual_counter+=900/i;
+ else virtual_counter+=0.06*i*i;
+ int err_Rot=TestNDO.rotate_data(virtual_longitude, virtual_latitude, virtual_time, virtual_counter, NAVIGATION_VMATRIX.vel_max);
+ virtual_timestamp+=5; // en segundos, 5 segundos de período
+ if(err_Rot==0){ // Si la rotacion fue 100% exitosa
+ if(Test_Matrix_VCO.store_data(TestNDO,1)!=0) return -1; //Notar que no requiere validar velocidad constante para almacenar; almacena todos los periodos bien rotados.
+ }
+ else {
+
+ if(err_Rot==1) return 1; // Tiempo entre muestras demasiado grande. Períódo no válido.
+ else return 2; // Timestamp no válido.
+ }
+ }
+ }
+ else{ // Rota valores para la velocidad indicada, seteando valores crecientes de consumo para testing
+
- TestNDO.LAST_NAV_DATA[cons_interpolated]=-1;
-
- TestNDO.LAST_NAV_DATA[cons_mile_p]=0.3; // 15-->0.3 ; 16-->0.2; 17-->0.35; 30-->0.1; 32-->0.15; 34-->0.12; 99-->0.25
- TestNDO.LAST_NAV_DATA[speed_p]=15;
- Test_Matrix_VCO.store_data(TestNDO);
- Test_Matrix_VCO.store_data(TestNDO);
- TestNDO.LAST_NAV_DATA[cons_mile_p]=0.2;
- TestNDO.LAST_NAV_DATA[speed_p]=16;
- Test_Matrix_VCO.store_data(TestNDO);
- Test_Matrix_VCO.store_data(TestNDO);
- TestNDO.LAST_NAV_DATA[cons_mile_p]=0.35;
- TestNDO.LAST_NAV_DATA[speed_p]=17;
- Test_Matrix_VCO.store_data(TestNDO);
- Test_Matrix_VCO.store_data(TestNDO);
- TestNDO.LAST_NAV_DATA[cons_mile_p]=0.1;
- TestNDO.LAST_NAV_DATA[speed_p]=30;
- Test_Matrix_VCO.store_data(TestNDO);
- Test_Matrix_VCO.store_data(TestNDO);
- TestNDO.LAST_NAV_DATA[cons_mile_p]=0.15;
- TestNDO.LAST_NAV_DATA[speed_p]=32;
- Test_Matrix_VCO.store_data(TestNDO);
- Test_Matrix_VCO.store_data(TestNDO);
- TestNDO.LAST_NAV_DATA[cons_mile_p]=0.12;
- TestNDO.LAST_NAV_DATA[speed_p]=34;
- Test_Matrix_VCO.store_data(TestNDO);
- Test_Matrix_VCO.store_data(TestNDO);
- TestNDO.LAST_NAV_DATA[cons_mile_p]=0.25;
- TestNDO.LAST_NAV_DATA[speed_p]=(Test_Matrix_VCO.vel_max)-1;
- Test_Matrix_VCO.store_data(TestNDO);
- Test_Matrix_VCO.store_data(TestNDO);
- Test_Matrix_VCO.interpolate();
-
- /*for (int i=0;i<30;i++){
- TestNDO.LAST_NAV_DATA[cons_mile_p]=i+1;
- TestNDO.LAST_NAV_DATA[speed_p]=i;
- Test_Matrix_VCO.store_data(TestNDO);
+ TestNDO.np_concat=0; // Cantidad de periodos concatenados:-->0: Solo valores de inicio.
+ float virtual_longitude=-58.5797; // Mantiene cte la Longitud.
+ float virtual_latitude=-34.4251+((virtual_speed*virtual_timestamp)/(59.99999981628485*3600));// Tomo delta_t virtual de (virtual_speed*virtual_timestamp) y calculo
+ // latitud navegada en virtual_timestamp @virtual_speed y longitud cte.
+ virtual_time=virtual_timestamp; //en formato NMEA hhmmss,ss
+ float virtual_counter=0.01*virtual_timestamp*virtual_timestamp; // Simulacion de consumo creciente; modificar y probar
+ int err_Rot=TestNDO.rotate_data(virtual_longitude, virtual_latitude, virtual_time, virtual_counter, NAVIGATION_VMATRIX.vel_max);
+ if(err_Rot==0){ // Si la rotacion fue 100% exitosa
+ if(Test_Matrix_VCO.store_data(TestNDO,2)==-1) return -1; // Notar que requiere 2 períodos a igual velocidad para que se almacene definitivamente.
+ }
+ else {
+ if(err_Rot==1) return 1; // Tiempo entre muestras demasiado grande. Períódo no válido.
+ else return 2; // Timestamp no válido.
+ }
+ }
+ return 0;
+}
+
+
+/* Function print_signal: imprime un simbolo a partir de las coordenadas de un rectangulo: signal=0-> ZONA VCO,1:Sin datos; 2:Circulo; 3:flecha; 4: elipse */
+
+
+void print_signal(int x1, int y1, int x2, int y2, int R, int G, int B, figura FIG, sentido S){
+ int tx1,tx2,tx3,rx1,rx2,ty1,ty2,ty3,ry1,ry2, delta_ty1,delta_ty2,delta_ty3;
+ int cex,cey,cer1,cer2;
+ cex=(x1+x2)/2;
+ cey=(y1+y2)/2;
+ cer2= (y2-y1)/2;
+ cer1= (x2-x1)/2;
+
+ switch (S){
+ case 1: { // UP
+ tx1=(x2+x1)/2;
+ ty1=y1;
+ tx2=x2;
+ ty2=(y2+y1)/2;
+ tx3=x1;
+ ty3=(y2+y1)/2;
+ delta_ty1=8;
+ delta_ty2=-5;
+ delta_ty3=-5;
+ rx1=(x2+3*x1)/4;
+ ry1=(y2+y1)/2;
+ rx2=(3*x2+x1)/4;
+ ry2=y2;
+ }
+ break;
+ case 0: { // DWN
+ tx1=(x2+x1)/2;
+ ty1=y2;
+ tx2=x2;
+ ty2=(y2+y1)/2;
+ tx3=x1;
+ ty3=(y2+y1)/2;
+ delta_ty1=-8;
+ delta_ty2=5;
+ delta_ty3=5;
+ rx1=(x2+3*x1)/4;
+ ry1=y1;
+ rx2=(3*x2+x1)/4;
+ ry2=(y2+y1)/2;
}
- for (int i=30,x=30;i>1;i--,x++){
- TestNDO.LAST_NAV_DATA[cons_mile_p]=i;
- TestNDO.LAST_NAV_DATA[speed_p]=x;
- Test_Matrix_VCO.store_data(TestNDO);
- }
- TestNDO.LAST_NAV_DATA[cons_mile_p]=1;
- TestNDO.LAST_NAV_DATA[speed_p]=55;
- Test_Matrix_VCO.store_data(TestNDO);
- for (int i=1,x=59;i<40;i++,x++){
- TestNDO.LAST_NAV_DATA[cons_mile_p]=i+1;
- TestNDO.LAST_NAV_DATA[speed_p]=x;
- Test_Matrix_VCO.store_data(TestNDO);
- }*/
- }
+ break;
+ default:
+ break;
+ }
+ switch (FIG){
+ case 0:
+ lcd.roundrect( x1-8,y1-8,x2+8,y2+8, 10,8, BrightBlue);
+ lcd.roundrect( x1-4,y1-4, x2+4,y2+4, 10,8, RGB(153,0,153));
+ lcd.foreground(BrightBlue);
+ lcd.fillroundrect( x1+2,y1+2, x2-2,y2-2, 5,4, RGB(R,G,B));
+ lcd.SetTextCursor(x1+10,y1+(y2-y1)/5);
+ lcd.background(BrightGreen);
+ lcd.foreground(White);
+ lcd.printf ("NAVEGANDO");
+ lcd.SetTextCursor(x1+55,y1+(y2-y1)/2-10);
+ //lcd.SetTextCursor(132,140);
+ lcd.printf ("EN");
+ lcd.SetTextCursor(x1+15,y1+(y2-y1)*2/3);
+ //lcd.SetTextCursor(135,170);
+ lcd.printf ("ZONA VCO");
+ break;
+ case 1:
+ lcd.roundrect( x1-8,y1-8,x2+8,y2+8, 10,8, BrightBlue);
+ lcd.roundrect( x1-4,y1-4, x2+4,y2+4, 10,8, RGB(153,0,153));
+ lcd.foreground(BrightBlue);
+ lcd.SetTextCursor(x1+10,y1+28);
+ lcd.printf ("SIN DATOS");
+ lcd.SetTextCursor(x1+1,y1+48);
+ lcd.printf ("SUFICIENTES\r\n");
+ break;
+ case 2:
+ lcd.circle( cex,cey, cer2+10, BrightBlue);
+ lcd.fillcircle( cex,cey,cer2+5,RGB(R,G,B));
+
+ break;
+ case 3:
+ lcd.roundrect( x1-8,y1-8,x2+8,y2+8, 10,8, BrightBlue);
+ lcd.roundrect( x1-4,y1-4, x2+4,y2+4, 10,8, RGB(153,0,153));
+ lcd.fillroundrect(rx1,ry1, rx2,ry2, 5,3, RGB(R,G,B) );
+ lcd.filltriangle( tx1,ty1, tx2,ty2, tx3,ty3, RGB(R,G,B));
+ lcd.SetTextCursor(x1+(x2-x1)/2-9,y1+(y2-y1)/5);
+ lcd.background(BrightGreen);
+ lcd.foreground(Black);
+ lcd.printf ("A");
+ lcd.SetTextCursor(x1+(x2-x1)/3-6,y1+(y2-y1)/2-10);
+ //lcd.SetTextCursor(132,140);
+ lcd.printf ("ZONA");
+ lcd.SetTextCursor(x1+(x2-x1)/3-3,y1+(y2-y1)*2/3);
+ //lcd.SetTextCursor(135,170);
+ lcd.printf ("VCO");
+ break;
+ case 4:
+ lcd.ellipse( cex,cey, cer1,cer2, BrightBlue);
+ lcd.fillellipse( cex,cey, cer1-5,cer2-5, RGB(R,G,B));
+ default:
+ lcd.circle( cex,cey, cer2+10, Blue);
+ lcd.fillcircle( cex,cey,cer2+5,RGB(R,G,B));
+ break;
+
+ }
+
+
+// lcd.printf("printing 3 x 2 = %d", 3*2);
+// lcd.circle( cex,cey, cer2+10, Blue);
+// lcd.fillcircle( cex,cey,cer2+5, Cyan);
+/// lcd.ellipse( 440,75, 35,20, BrightBlue);
+/// lcd.fillellipse( 440,75, 25,10, Blue);
+// lcd.triangle( tx1,ty1,tx2,ty2,tx3,ty3, Blue);
+// lcd.filltriangle( tx1,ty1+delta_ty1, tx2-5,ty2+delta_ty2, tx3+5,ty3+delta_ty3, RGB(R,G,B));
+/// lcd.rect( 400,130, 475,155, Brown);
+/// lcd.fillrect( 405,135, 470,150, Pink);
+
+// lcd.fillroundrect(x1-4,y1-4, x2+4,y2+4, 5,3,Blue);
+// lcd.roundrect( rx1,ry1,rx2,ry2, 10,8, Blue);
+// lcd.fillroundrect(rx1+5,ry1+5, rx2-5,ry2-5, 5,3, RGB(R,G,B) );
+
+}
+
+
+//###################----------- MAIN ------------#########################
int main()
-{
- pc.baud(460800); // I like a snappy terminal, so crank it up!
+{ int VCC[2]; // Array de valores crucero críticos. VCC[0]=VCO; VCC[1]=VMC (Velocidad de Máximo Consumo)
+ VCC[0]=-1;
+ VCC[1]=-1;
+ int R,G,B=0;
+ int R1,G1,B1=0;
+ int err_Mtrx=0;
+ float PRFM=-1; // Performance
+ sentido SENTIDO; // Sentido de la flecha
+ figura FIG; //
+ pc.baud(460800);
pc.printf("\r\nRA8875 Soft Fonts - Build " __DATE__ " " __TIME__ "\r\n");
lcd.init();
- lcd.TouchPanelCalibrate("Calibrate the touch panel"); // 4 touch
+ lcd.TouchPanelCalibrate(); // Funcion modificada para fijar calibracion.
lcd.cls();
rect_t PrintScreenRect = { 425-65, 20, 425+65, 60}; // Rectangulo para encuadrar boton.
lcd.foreground(RGB(255,255,0)); // Seteo del color de las letras.
@@ -363,113 +484,357 @@
//-------------------------------------------------------------------------------------------------------------
-// Sensor de flujo:
-
+// Sensor de flujo:
InterruptIn pulse_sensor(p15); // Defino pulse_sensor como una entrada de interrupción en p15 .
pulse_sensor.mode(PullUp); // PullUp para esa entrada.
- //DigitalOut led(LED1);
//pulse_sensor.rise(&trigger); // Dispara interrupción con flanco ascendente. (Podría tambien ser desecendente--> fall)
pulse_sensor.fall(&trigger);
+//--------------------------------------------------------------------------------------------------------------
- //--------------------------------------------------------------------------------------------------------------
lcd.SetTextCursor(0,0); // Posicionamiento de cursor.
- lcd.puts(">>>>>>>>>>>>>< Proyecto SNOCC ><<<<<<<<<<<<<<\r\n");
-
- if (!sd2mtrx(NAVIGATION_VMATRIX, sd_file)) lcd.puts("Datos leidos de SD card\r\n"); // Cargo matriz desde SD.
+ lcd.puts(">>>>>>>>>>>>>< Proyecto SNOCC ><<<<<<<<<<<<<<\r\n");
+ if (!sd2mtrx(NAVIGATION_VMATRIX, sd_file)) lcd.puts("Datos leidos de SD card\r\n"); // Cargando matriz desde SD.
else{
lcd.puts("Error al leer los datos.\r\n Inicio sin datos historicos.\r\n");
- lcd.printf("Creando directorio en SD card...\r\n");
- if(!mkdir(sd_dir, 0777)){ // Creo directorio si no existe.
- lcd.printf("Creado: %s\r\n", sd_dir);
- lcd.printf("Cargando datos de inicio default en SD card...\r\n");
- build_default_Mtrx(NAVIGATION_VMATRIX); // Creando matriz de inicio default.
+ if (TESTING){
+ err_Mtrx=build_default_Mtrx(NAVIGATION_VMATRIX,TestNAV,0,0);
+ if(err_Mtrx!=0) lcd.printf("Error al crear la Matriz default.%d\r\n",err_Mtrx); // Creando matriz de inicio default.
+ else lcd.printf("Matriz default creada con exito.\r\n");
+ }
if (!mtrx2sd(NAVIGATION_VMATRIX, sd_file)) lcd.printf("Datos default guardados en SD card\r\n");
- else lcd.puts("Error al guardar los datos default.\r\nNo se podran almacenar los datos.\r\n");
+ else {
+ lcd.puts("Error al guardar los datos default.\r\nCreando directorio en SD card...\r\n");
+ if(!mkdir(sd_dir, 0777)){ // Creando directorio si no existe.
+ lcd.printf("Creado: %s\r\n", sd_dir);
+ lcd.printf("Cargando datos de inicio default en SD card...\r\n");
+ if (!mtrx2sd(NAVIGATION_VMATRIX, sd_file)) lcd.printf("Datos default guardados en SD card\r\n");
+ else lcd.puts("Error al guardar los datos default.\r\nNo se podran almacenar los datos.\r\n");
+ }
+ else lcd.puts("Error al guardar los datos default.\r\nNo se podran almacenar los datos.\r\n");
}
- else lcd.puts("Error al crear directorio en SD card. No se podran almacenar los datos.\r\n");
- }
+ }
wait(3);
+
+ float delta=5.0;//DEBUG
+ float virtual_tmstmp=0.0;//DEBUG
-
+ int prueba=0; // BORRAR ESTO. ES SOLO PARA PROBAR <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+// -------------------------------- LOOP INFINITO ------------------------------------
while(1) {
lcd.SetTextCursor(0,0); // Pongo cursor en posicion
lcd.puts(">>>>>>>>>>>>>< Proyecto SNOCC ><<<<<<<<<<<<<<\r\n");
- //lcd.printf("M0: %s \r\n\r\n", gps.msg); //Imprimo el mensaje crudo proveniente de la uart
+ if (DEBUG_GPS) lcd.printf("M0: %s \r\n\r\n", gps.msg); //Imprimo el mensaje crudo proveniente de la uart
- if(gps.sample()) { // Si es exitosa la obtencion de datos del gps.
- poll_init=1;
+ if(gps.sample()) { // Si es exitosa la obtencion de datos del gps.
lcd.cls();
- lcd.foreground(RGB(255,255,0)); // Seteo del color de las letras.
- lcd.SelectUserFont(BPG_Arial20x20); // Seleccion de tipo y tamaño de letras
- lcd.SetTextCursor(0,0); // Pongo cursor en posicion
+ lcd.foreground(RGB(255,255,0)); // Seteo del color de las letras.
+ lcd.SelectUserFont(BPG_Arial20x20); // Seleccion de tipo y tamaño de letras
+ lcd.SetTextCursor(0,0); // Cursor en posicion
lcd.puts(">>>>>>>>>>>>>< Proyecto SNOCC ><<<<<<<<<<<<<<\r\n");
- if (NAVIGATION_TABLE.rotate_data(gps.longitude, gps.latitude, gps.time, Counter)){
- NAVIGATION_VMATRIX.store_data(NAVIGATION_TABLE);// Luego de rotar los datos en la tabla de navegacion, la guarda en la matriz segun criterios de la clase VCODATA
- lcd.puts("Rotacion exitosa!-->");
- int i=int(NAVIGATION_TABLE.LAST_NAV_DATA[speed_p]);
- int VCO=NAVIGATION_VMATRIX.get_VCO();
- float timetick_f_Last = NAVIGATION_TABLE.LAST_NAV_DATA[speed_p]; // DEBUG
- float timetick_f_Mtrx = NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[time_f]; // DEBUG
- float distance_p_Mtrx = NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[distance_p]; // DEBUG
- float speed_p_Mtrx = NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[speed_p]; // DEBUG
- float speed_p_Last = NAVIGATION_TABLE.LAST_NAV_DATA[speed_p]; // DEBUG
- float longitude_f_Mtrx = NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[longitude_f]; // DEBUG
- float latitude_f_Mtrx = NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[latitude_f]; // DEBUG
- float cons_hour_p_Mtrx = NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[cons_hour_p];
- float cons_mile_p_Mtrx = NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[cons_mile_p];
- lcd.printf("INDICE_Mtrx: %d\r\n",i); // DEBUG
- lcd.printf("Speed_f_Mtrx(%d): %f kn.\r\n",i, speed_p_Mtrx); // DEBUG
- lcd.printf("Speed_f_Last(%d): %f km/h.\r\n",i, speed_p_Last*1.852); // DEBUG
- lcd.printf("Time_f_Mtrx(%d): %f Hours.\r\n",i, timetick_f_Mtrx); // DEBUG
- lcd.printf("Time_f_Last(%d): %f Hours.\r\n",i, timetick_f_Last); // DEBUG
- lcd.printf("Dist_p_Mtrx(%d): %f miles.\r\n",i,distance_p_Mtrx); // DEBUG
- lcd.printf("Posicion: Long(%d): %f ; Lat: %f\r\n",i,longitude_f_Mtrx,latitude_f_Mtrx); // DEBUG
- lcd.printf("FlujoVCOmtrx(%d): %f Litros/Hora\r\n",i, cons_hour_p_Mtrx); // DEBUG
- lcd.printf("FlujoVCOmtrx(%d): %f Litros/Milla\r\n",i, cons_mile_p_Mtrx); // DEBUG
- lcd.printf("Cons. Acumulado: %f l\r\n", LCounter);
- lcd.printf("VCO: %d km/h\r\n", VCO);
-
+ if (!NAVIGATION_OBJECT.rotate_data(gps.longitude, gps.latitude, gps.time, Counter,NAVIGATION_VMATRIX.vel_max )){
+ NAVIGATION_OBJECT.LAST_NAV_DATA[cons_interpolated]=0; // Dato tipo recolectado
+ err_Store=NAVIGATION_VMATRIX.store_data(NAVIGATION_OBJECT,2); // Luego de rotar los datos en la tabla de navegacion,
+ // la guarda en la matriz segun criterios de la clase VCODATA
+
+ int i=int(NAVIGATION_OBJECT.LAST_NAV_DATA[speed_p]);
+ //int VCO=NAVIGATION_VMATRIX.get_VCO(&VCC[0]);
+ NAVIGATION_V_SMOOTH_MTRX.smooth(4, NAVIGATION_VMATRIX); // Genera matriz de datos filtrados con pasabajos
+ int VCO=NAVIGATION_V_SMOOTH_MTRX.get_VCO(&VCC[0]); // VCO OBTENIDA DE MATRIZ FILTRADA.
+
+
+ if (DEBUG1) {
+ lcd.puts("Rotacion exitosa!-->");
+ lcd.printf("Error de rotacion:\t %d\r\n",err_Store); // DEBUG
+ lcd.printf("Speed_f_Mtrx(%d):\t %lf kn.\r\n",i, NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[speed_p]); // DEBUG
+ lcd.printf("Speed_f_Last(%d):\t\t %lf km/h.\r\n",i, NAVIGATION_OBJECT.LAST_NAV_DATA[speed_p]*1.852); // DEBUG
+ lcd.printf("Time_f_Mtrx(%d):\t %lf Hours.\r\n",i, NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[time_f]); // DEBUG
+ lcd.printf("Time_f_Last(%d):\t %lf Hours.\r\n",i, NAVIGATION_OBJECT.LAST_NAV_DATA[time_f]); // DEBUG
+ lcd.printf("Dist_p_Mtrx(%d):\t %lf miles.\r\n",i,NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[distance_p]); // DEBUG
+ }
+ lcd.printf("Posicion: Long(%d):\t %lf ; Lat: %lf\r\n",i,NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[longitude_f],NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[latitude_f]); // DEBUG
+ lcd.printf("FlujoVCOmtrx(%d):\t %lf Litros/Hora\r\n",i, NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[cons_hour_p]); // DEBUG
+ lcd.printf("FlujoVCOmtrx(%d):\t %lf Litros/Milla\r\n",i, NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[cons_mile_p]); // DEBUG
+ lcd.printf("Cons. Acumulado:\t %lf l\r\n", LCounter);
+ lcd.printf("VCO:\t %d knots\r\n", VCO);
+
+ NAVIGATION_VMATRIX.interpolate(); // Interpolacion.
+ if (!mtrx2sd(NAVIGATION_VMATRIX, sd_file)) lcd.printf("Datos guardados en SD card\r\n"); // Almacenamiento de datos en SD.
+ else lcd.printf("Error al guardar los datos.\r\n");
+
+//_____________________________________________________________________________________________________________________
+ int signal_x=80; // REGION DE SEÑALIZACION
+ int signal_y=60;
+ int signal_x_sz=120;
+ int signal_y_sz=150;
+
+ //PRFM=NAVIGATION_VMATRIX.performance(i);
+ PRFM=NAVIGATION_V_SMOOTH_MTRX.performance(i); // PERFORMANCE OBTENIDA DE MATRIZ FILTRADA.
+
+ R1=0; // COLOR DEFAULT PARA CIRCULO DE REFERENCIA DE PERFORMANCE (VERDE)
+ G1=255;
+ B1=0;
+ lcd.foreground(RGB(R1,G1,B1));
+ lcd.SetTextCursor(200,245);
+ lcd.printf("VCO: %d \t\t",VCC[0]);
+ lcd.printf("VMC: %d \r\n",VCC[1]);
+ if (PRFM!=-1 && VCC[0]!=-1){
+ if (PRFM>0.98) {
+ R=0;
+ G=255;
+ B=0;
+ }
+ else {
+ if (PRFM<0.75){
+ R=255;
+ G=255*4*PRFM/3;
+ B=0;
+ }
+ else {
+ R=255*4*(1-PRFM);
+ G=255;
+ B=0;
+ }
+ }
+ float delta_vel= NAVIGATION_VMATRIX.NAV_DATA[i].LAST_NAV_DATA[speed_p]-VCC[0]; // ES IGUAL QUE EN MTRX FILTRADA
+ if (fabs(delta_vel)<2){
+ FIG=ZONA;
+ signal_x=60; // REGION DE SEÑALIZACION
+ signal_y=80;
+ signal_x_sz=150;
+ signal_y_sz=120;
+ }
+ else FIG=FLECHA;
+ if (delta_vel<0) SENTIDO=UP;
+ else SENTIDO=DWN;
+
+
+ print_signal(signal_x, signal_y, signal_x + signal_x_sz,signal_y + signal_y_sz, 0, 255, 0,FIG,SENTIDO); // SI ESTA EN ENTORNO DE VCO--> IMPRIMIR "ZONA VCO".
+
+ }
+ else {
+ int signal_x=80; //CAMBIO ZONA DE SEÑALIZACION (PARA TEXTO "SIN DATOS..")
+ int signal_y=85;
+ signal_y_sz=100;
+ signal_x_sz=130;
+ R1=190;
+ G1=190;
+ B1=190;
+ print_signal(signal_x, signal_y, signal_x + signal_x_sz,signal_y + signal_y_sz,R,G,B,SIN_DT,NO); // SIN DATOS: SOLO RECUADRO PARA TEXTO
+
+ }
+ signal_x=265; // ZONA PERFORMANCE
+ signal_y=85;
+ signal_x_sz=90;
+ signal_y_sz=90;
+ print_signal(signal_x, signal_y, signal_x + signal_x_sz,signal_y + signal_y_sz, R1, G1, B1,CIRC,NO); // CIRCULO VERDE
+
+ if (PRFM >= 0){
+ if (SENTIDO==DWN) {
+ print_signal(signal_x+5, (signal_y+5)-(signal_y_sz*(1-PRFM)), signal_x+signal_x_sz-5, (signal_y+signal_y_sz-5)-(signal_y_sz*(1-PRFM)), R, G, B,CIRC,NO);
+ lcd.SetTextCursor(signal_x+20,(signal_y+5)-(signal_y_sz*(1-PRFM))+ 25);
+ lcd.foreground(RGB(0,0,0));
+ lcd.background(RGB(R,G,B));
+ lcd.SelectUserFont(BPG_Arial31x32);
+ lcd.printf ("%.2f\r\n",PRFM);
+ }
+ else {
+ print_signal(signal_x+5, (signal_y+5)+(signal_y_sz*(1-PRFM)), signal_x+signal_x_sz-5, (signal_y+signal_y_sz-5)+(signal_y_sz*(1-PRFM)), R, G, B,CIRC,NO);
+ lcd.SetTextCursor(signal_x+20,(signal_y+5)+(signal_y_sz*(1-PRFM))+ 25);
+ lcd.foreground(RGB(0,0,0));
+ lcd.background(RGB(R,G,B));
+ lcd.SelectUserFont(BPG_Arial31x32);
+ lcd.printf ("%.2f\r\n",PRFM);
+ }
+ }
+ lcd.background(Black);
+ lcd.foreground(RGB(0,255,0));
+ lcd.SetTextCursor(20,245);
+ lcd.SelectUserFont(BPG_Arial20x20);
+ lcd.printf("VEL: %.1f \r\n",NAVIGATION_OBJECT.LAST_NAV_DATA[speed_p]); // VELOCIDAD ACTUAL.
- NAVIGATION_VMATRIX.interpolate(); // Interpolacion.
- if (!mtrx2sd(NAVIGATION_VMATRIX, sd_file)) lcd.printf("Datos guardados en SD card\r\n"); // Almacenamiento de datos en SD.
- else lcd.printf("Error al guardar los datos.\r\n");
-
- //build_default_Mtrx(NAVIGATION_VMATRIX); // DEBUG Curve
- //print_VCO_curve(NAVIGATION_VMATRIX,1);
+//____________________________________________________________________________________________________________________________________________________________
}
else lcd.puts("Periodo no valido!\r\n");
- }
- else {
+ }
+ else { // No hay datos gps
lcd.background(Black);
lcd.cls();
- lcd.foreground(RGB(255,255,0)); // Seteo del color de las letras.
+ lcd.foreground(RGB(0,255,0)); // Seteo del color de las letras.
lcd.SelectUserFont(BPG_Arial20x20); // Seleccion de tipo y tamaño de letras
lcd.SetTextCursor(0,0); // Posicionamiento de cursor.
lcd.puts(">>>>>>>>>>>>>< Proyecto SNOCC ><<<<<<<<<<<<<<\r\n");
- lcd.SetTextCursor(0,100);
+ lcd.SetTextCursor(0,20);
+ if (!mtrx2sd(NAVIGATION_VMATRIX, sd_file)) lcd.printf("Datos default guardados en SD card\r\n"); //DEBUG
+ else lcd.printf("Error al guardar los datos default.\r\n"); //DEBUG
+
+ lcd.printf("Aun no hay datos gps disponibles. Usando historicos.\r\n");
- if (!mtrx2sd(NAVIGATION_VMATRIX, sd_file)) lcd.printf("Datos guardados en SD card\r\n");
- else lcd.printf("Error al guardar los datos.\r\n");
+ //lcd.printf("Timetick %lf h\r\n", NAVIGATION_OBJECT.LAST_NAV_DATA[time_f]);
+
+ //_____________________________________________________________________________________________________________________
+ int signal_x=80; // REGION DE SEÑALIZACION
+ int signal_y=60;
+ int signal_x_sz=120;
+ int signal_y_sz=150;
+
+ if (prueba >= NAVIGATION_VMATRIX.vel_max) prueba=prueba-NAVIGATION_VMATRIX.vel_max;
+ PRFM=NAVIGATION_VMATRIX.performance(prueba);
+ R1=0; // COLOR DEFAULT PARA CIRCULO DE REFERENCIA DE PERFORMANCE (VERDE)
+ G1=255;
+ B1=0;
+ lcd.foreground(RGB(R1,G1,B1));
+ //lcd.printf("Indice: %d \r\n",prueba);
+ //lcd.printf("Perf.: %f \r\n",PRFM);
+ lcd.SetTextCursor(200,245);
+ lcd.printf("VCO: %d \t\t",NAVIGATION_VMATRIX.get_VCO(&VCC[0]));
+ lcd.printf("VMC: %d \r\n",VCC[1]);
+ if (PRFM!=-1 && VCC[0]!=-1){
+ if (PRFM>0.98) {
+ R=0;
+ G=255;
+ B=0;
+ }
+ else {
+ if (PRFM<0.75){
+ R=255;
+ G=255*4*PRFM/3;
+ B=0;
+ }
+ else {
+ R=255*4*(1-PRFM);
+ G=255;
+ B=0;
+ }
+ }
+ float delta_vel= NAVIGATION_VMATRIX.NAV_DATA[prueba].LAST_NAV_DATA[speed_p]-VCC[0];
+
+ //float delta_vel=int(NAVIGATION_OBJECT.LAST_NAV_DATA[speed_p])-VCC[0];
+
+ if (fabs(delta_vel)<2){
+ FIG=ZONA;
+ signal_x=60; // REGION DE SEÑALIZACION
+ signal_y=80;
+ signal_x_sz=150;
+ signal_y_sz=120;
+ }
+ else FIG=FLECHA;
+ if (delta_vel<0) SENTIDO=UP;
+ else SENTIDO=DWN;
+
+
+ print_signal(signal_x, signal_y, signal_x + signal_x_sz,signal_y + signal_y_sz, 0, 255, 0,FIG,SENTIDO); // SI ESTA EN ENTORNO DE VCO--> IMPRIMIR "ZONA VCO".
+
+ /*
+ lcd.SetTextCursor(signal_x+signal_x_sz/2-6,signal_y+signal_y_sz/4);
+ lcd.background(RGB(0,255,0));
+ lcd.foreground(RGB(0,0,255));
+ lcd.printf ("A");
+ lcd.SetTextCursor(signal_x+signal_x_sz/3-3,signal_y+signal_y_sz/2-10);
+ //lcd.SetTextCursor(132,140);
+ lcd.printf ("ZONA");
+ lcd.SetTextCursor(signal_x+signal_x_sz/3,signal_y+2*signal_y_sz/3);
+ //lcd.SetTextCursor(135,170);
+ lcd.printf ("VCO");
+ */
+
- lcd.printf("Aun no hay datos disponibles :(\r\n");
- lcd.SetTextCursor(0,180);
- lcd.printf("Timetick %f h\r\n", NAVIGATION_TABLE.LAST_NAV_DATA[time_f]);
- lcd.printf("Flujo Mtrx: %f Litros/Hora\r\n", NAVIGATION_TABLE.LAST_NAV_DATA[cons_hour_p]);
- lcd.printf("Flujo Counter: %f Litros\r\n", LCounter);
-
- //if (poll_init==0) build_default_Mtrx(NAVIGATION_VMATRIX); //DEBUG
-
- }
+ //lcd.printf("Delta_v: %.0f \r\n",delta_vel);
+ }
+ else {
+ int signal_x=80; //CAMBIO ZONA DE SEÑALIZACION (PARA TEXTO "SIN DATOS..")
+ int signal_y=85;
+ signal_y_sz=100;
+ signal_x_sz=130;
+ R1=190;
+ G1=190;
+ B1=190;
+ print_signal(signal_x, signal_y, signal_x + signal_x_sz,signal_y + signal_y_sz,R,G,B,SIN_DT,NO); // SIN DATOS: SOLO RECUADRO PARA TEXTO
+
+ }
+ signal_x=265; // ZONA PERFORMANCE
+ signal_y=85;
+ signal_x_sz=90;
+ signal_y_sz=90;
+ print_signal(signal_x, signal_y, signal_x + signal_x_sz,signal_y + signal_y_sz, R1, G1, B1,CIRC,NO); // CIRCULO VERDE
+
+ if (SENTIDO==DWN){
+ print_signal(signal_x+5, (signal_y+5)-(signal_y_sz*(1-PRFM)), signal_x+signal_x_sz-5, (signal_y+signal_y_sz-5)-(signal_y_sz*(1-PRFM)), R, G, B,CIRC,NO);
+ lcd.SetTextCursor(signal_x+20,(signal_y+5)-(signal_y_sz*(1-PRFM))+ 25);
+ lcd.foreground(RGB(0,0,0));
+ lcd.background(RGB(R,G,B));
+ lcd.SelectUserFont(BPG_Arial31x32);
+ if (PRFM >= 0) lcd.printf ("%.2f\r\n",PRFM);
+ }
+ else {
+ print_signal(signal_x+5, (signal_y+5)+(signal_y_sz*(1-PRFM)), signal_x+signal_x_sz-5, (signal_y+signal_y_sz-5)+(signal_y_sz*(1-PRFM)), R, G, B,CIRC,NO);
+ lcd.SetTextCursor(signal_x+20,(signal_y+5)+(signal_y_sz*(1-PRFM))+ 25);
+ lcd.foreground(RGB(0,0,0));
+ lcd.background(RGB(R,G,B));
+ lcd.SelectUserFont(BPG_Arial31x32);
+ lcd.printf ("%.2f\r\n",PRFM);
+ }
+ lcd.background(Black);
+ lcd.foreground(RGB(0,255,0));
+ lcd.SetTextCursor(20,235);
+ lcd.printf("Flujo Acum: %.1f \r\n",LCounter);
+ lcd.SetTextCursor(20,245);
+ lcd.SelectUserFont(BPG_Arial20x20);
+ lcd.printf("Speed_p: %.1f \r\n",NAVIGATION_VMATRIX.NAV_DATA[prueba].LAST_NAV_DATA[speed_p]);
+ prueba++;
+ //______________________________________________________________________________________________________________________
+
+ if (TESTING){ //DEBUG
+
+ // ESTA PARTE ES PARA PROBAR EL FUNCIONAMIENTO DE LA ROTACION Y ALMACENAMIENTO DE DATOS......DEBUG.
+ //lcd.SelectUserFont(BPG_Arial10x10); // Seleccion de tipo y tamaño de letras
+
+ float vrtl_speed=12; // pruebo cargar datos para velocidad 12.
+ TestNAV.LAST_NAV_DATA[cons_interpolated]=0; // --> -1:Datos iniciales. 0--> recolectado (setear para testing)
+ err_Mtrx=build_default_Mtrx(NAVIGATION_VMATRIX, TestNAV, vrtl_speed, virtual_tmstmp);
+ if(err_Mtrx!=0){
+ lcd.printf("Error al cargar datos en la Matriz default.%d..\r\n", err_Mtrx); // DEBUG; ya se crea la matriz en el arranque, si no hay archivo.
+ }
+ else lcd.printf("Datos para virtual_speed= %.1f cargado con exito.\r\n",vrtl_speed);
+ lcd.printf("Virtual_Timestamp=%.2f.\t",virtual_tmstmp);//DEBUG
+ virtual_tmstmp+=delta; // DEBUG Esta en formato NMEA(hhmmss.ss): no son validos los valores de segundos mayores a 59, por lo tanto
+ // cuando se ingrese 100,00 despues de 95,00 se espera que el sistema no valide la ronda pues en ese
+ // formato 100,00 < 95,00 (1m < 95s); seria un valor entrante menor que el anterior.
+
+ lcd.printf("V_time(h):%lf\r\n",TestNAV.time_NMEA2hours(virtual_tmstmp));
+
+ // FIN DE LA PARTE PARA PROBAR EL FUNCIONAMIENTO DE LA ROTACION Y ALMACENAMIENTO DE DATOS......DEBUG.
+
+ }
+ if (DEBUG2){
+ int buff_indx=int(NAVIGATION_VMATRIX.NAV_DATA[NAVIGATION_VMATRIX.vel_max].LAST_NAV_DATA[speed_p]+0.5); // DEBUG
+ lcd.printf("Cons_m_p[%d]= %.3f l/ml\t",buff_indx, NAVIGATION_VMATRIX.NAV_DATA[buff_indx].LAST_NAV_DATA[cons_mile_p]);
+ lcd.printf("Dist_p[%d]= %lf ml\r\n",buff_indx, NAVIGATION_VMATRIX.NAV_DATA[buff_indx].LAST_NAV_DATA[distance_p]);
+ lcd.printf("Tiempo_f[%d]= %lf h\t",buff_indx, NAVIGATION_VMATRIX.NAV_DATA[buff_indx].LAST_NAV_DATA[time_f]);
+ lcd.printf("Tiempo_i[%d]= %lf h\r\n",buff_indx, NAVIGATION_VMATRIX.NAV_DATA[buff_indx].LAST_NAV_DATA[time_i]);
+ lcd.printf("Buff_INDX = %d \t", buff_indx);
+ lcd.printf("Speed_p[%d]= %.2f knots\r\n",buff_indx, NAVIGATION_VMATRIX.NAV_DATA[buff_indx].LAST_NAV_DATA[speed_p]);
+ lcd.printf("Per_con[vel_max]= %d \t", NAVIGATION_VMATRIX.NAV_DATA[NAVIGATION_VMATRIX.vel_max].np_concat);
+ lcd.printf("V_buff[%d]= %.2f\t", NAVIGATION_VMATRIX.vel_max,NAVIGATION_VMATRIX.NAV_DATA[NAVIGATION_VMATRIX.vel_max].LAST_NAV_DATA[speed_p]);
+ lcd.printf("TestNAV-time_f = %lf \t", TestNAV.LAST_NAV_DATA[time_f]);
+ lcd.printf("TestNAV-time_i = %lf \r\n", TestNAV.LAST_NAV_DATA[time_i]);
+ lcd.printf("TestNAV-max_per_t = %lf \t", TestNAV.max_period_time);
+ lcd.printf("TestNAV-time_p = %lf \r\n", TestNAV.LAST_NAV_DATA[time_f]-TestNAV.LAST_NAV_DATA[time_i]);
+ lcd.printf("TestNAV-cons_m_p = %lf \t", TestNAV.LAST_NAV_DATA[cons_mile_p]);
+ lcd.printf("TestNAV-cons_h_p = %lf \r\n", TestNAV.LAST_NAV_DATA[cons_hour_p]);
+ //lcd.SelectUserFont(BPG_Arial20x20); // Seleccion de tipo y tamaño de letras
+ }// FIN DEBUG
+ }
- for (int i=0;i<200;i++) { // Barrido para el touch
+ for (int i=0;i<200;i++) { // Barrido para el touch
point_t p;
- lcd.fillrect(PrintScreenRect, Green);
- lcd.foreground(Blue);
+ lcd.fillroundrect(PrintScreenRect,5,2, Green);
+ lcd.roundrect(PrintScreenRect, 5,2, BrightBlue);
+ lcd.foreground(BrightBlue);
lcd.background(Green);
lcd.puts(425-60, 22, "GET CURVE");
lcd.background(Black);
@@ -483,7 +848,7 @@
if (Intersect(PrintScreenRect, p)) {
lcd.foreground(Red);
lcd.puts(400-38, 20, "GET CURVE");
- //build_default_Mtrx(NAVIGATION_VMATRIX); // DEBUG Curve
+ //if(build_default_Mtrx(NAVIGATION_VMATRIX)==-1) lcd.printf("Error al crear la Matriz default...\r\n"); // DEBUG Curve
NAVIGATION_V_SMOOTH_MTRX.smooth(4, NAVIGATION_VMATRIX); // Genera matriz de datos filtrados con pasabajos
//lcd.puts(425-120, 22, "ANTES de PRINT"); //DEBUG
print_VCO_curve(NAVIGATION_VMATRIX,0); // Valores recolectados
@@ -497,10 +862,13 @@
wait(3);
print_VCO_curve(NAVIGATION_V_SMOOTH_MTRX,2); // Suavizados (lineas)
wait(3);
- print_VCO_data(NAVIGATION_VMATRIX); // Volcado de datos
- wait(4);
+ if (DEBUG2){
+ print_VCO_data(NAVIGATION_VMATRIX); // Volcado de datos
+ wait(4);
+ }
+ //GetScreenCapture();
break;
- //GetScreenCapture();
+
}
}