paul
/
gilles
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

basic code organization changes mostly

This commit is contained in:
Paul Dino Jones 2024-01-19 19:49:11 +00:00
parent 109d7b1fed
commit 32accbfb77
11 changed files with 576 additions and 646 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/gilles/gameloop/CMakeLists.txt
View File

@ -3,6 +3,10 @@ set(gameloop_source_files
gameloop.h gameloop.h
browseloop.c browseloop.c
browseloop.h browseloop.h
session.h
session.c
telemetry.h
telemetry.c
) )

741
src/gilles/gameloop/browseloop.c
View File

@ -16,7 +16,8 @@
#include <byteswap.h> #include <byteswap.h>
#include "session.h" #include "hoeldb.h"
#include "telemetry.h"
#include "gameloop.h" #include "gameloop.h"
#include "../helper/parameters.h" #include "../helper/parameters.h"
#include "../helper/confighelper.h" #include "../helper/confighelper.h"
@ -41,7 +42,7 @@ WINDOW* bwin4;
int bwinx, bwiny; int bwinx, bwiny;
char blanks[100]; char blanks[1000];
void add_line() void add_line()
{ {
@ -73,17 +74,6 @@ void b_handle_winch(int sig)
refresh(); refresh();
} }
//void rectangle(int y1, int x1, int y2, int x2)
//{
// mvhline(y1, x1, 0, x2-x1);
// mvhline(y2, x1, 0, x2-x1);
// mvvline(y1, x1, 0, y2-y1);
// mvvline(y1, x2, 0, y2-y1);
// mvaddch(y1, x1, ACS_ULCORNER);
// mvaddch(y2, x1, ACS_LLCORNER);
// mvaddch(y1, x2, ACS_URCORNER);
// mvaddch(y2, x2, ACS_LRCORNER);
//}
int b_curses_init() int b_curses_init()
{ {
@ -93,6 +83,7 @@ int b_curses_init()
init_pair(1,COLOR_GREEN,0); init_pair(1,COLOR_GREEN,0);
init_pair(2,COLOR_YELLOW,0); init_pair(2,COLOR_YELLOW,0);
init_pair(5,COLOR_BLACK,COLOR_YELLOW);
init_pair(3,COLOR_MAGENTA,0); init_pair(3,COLOR_MAGENTA,0);
init_pair(4,COLOR_WHITE,0); init_pair(4,COLOR_WHITE,0);
@ -111,220 +102,18 @@ int b_curses_init()
wbkgd(bwin4,COLOR_PAIR(1)); wbkgd(bwin4,COLOR_PAIR(1));
signal(SIGWINCH, b_handle_winch); signal(SIGWINCH, b_handle_winch);
curs_set(0);
cbreak(); cbreak();
noecho(); noecho();
box(bwin1, 0, 0); box(bwin1, 0, 0);
box(bwin2, 0, 0); //box(bwin2, 0, 0);
box(bwin3, 0, 0); //box(bwin3, 0, 0);
box(bwin4, 0, 0); //box(bwin4, 0, 0);
} }
int telem_result(struct _h_result result, int doublefields, int intfields, int* intarrays, double* doublearrays) {
int col, row, i;
char buf[64];
slogt("rows: %d, col: %d", result.nb_rows, result.nb_columns);
//int* intarrays;
int points = 0;
//int doublefields = 3;
//int intfields = 3;
//int* intarrays;
//int* doublearrays;
//int* intarrays = malloc((sizeof(int)*1736)*3);
//double* doublearrays = malloc((sizeof(double)*1736)*3);
int intarrayoffset = 0;
int doublearrayoffset = 0;
for (row = 0; row<result.nb_rows; row++) {
for (col=0; col<result.nb_columns; col++) {
switch(result.data[row][col].type) {
case HOEL_COL_TYPE_INT:
int cc = ((struct _h_type_int *)result.data[row][col].t_data)->value;
if (col == 1)
{
points = cc;
}
break;
case HOEL_COL_TYPE_DOUBLE:
//intarrays = malloc((sizeof(int)*1736)*3);
break;
case HOEL_COL_TYPE_TEXT:
slogi("| %s ", ((struct _h_type_text *)result.data[row][col].t_data)->value);
break;
case HOEL_COL_TYPE_BLOB:
int offset2 = 0;
int j = 0;
i = 2;
if (col < 5)
{
while (i<((struct _h_type_blob *)result.data[row][col].t_data)->length)
{
char sss[10];
sss[0] = '0';
sss[1] = 'x';
sss[2] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+2);
sss[3] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+3);
sss[4] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+4);
sss[5] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+5);
sss[6] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+6);
sss[7] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+7);
sss[8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+8);
sss[9] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+9);
long val;
int number = (int)strtol(sss, NULL, 16);
int swapped = __bswap_32(number);
intarrays[j+intarrayoffset] = __bswap_32(number);
offset2 = offset2 + 8;
i+=8;
j++;
}
intarrayoffset += points;
}
else
{
while (i<((struct _h_type_blob *)result.data[row][col].t_data)->length)
{
char sss[18];
sss[0] = '0';
sss[1] = 'x';
sss[2] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+2);
sss[3] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+3);
sss[4] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+4);
sss[5] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+5);
sss[6] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+6);
sss[7] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+7);
sss[8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+8);
sss[9] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+9);
sss[2+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+2+8);
sss[3+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+3+8);
sss[4+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+4+8);
sss[5+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+5+8);
sss[6+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+6+8);
sss[7+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+7+8);
sss[8+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+8+8);
sss[9+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+9+8);
long val;
int64_t number = (int64_t) strtoll(sss, NULL, 16);
int64_t swapped = __bswap_64(number);
double d = *((double*)&swapped);
doublearrays[j+doublearrayoffset] = (double) d;
offset2 = offset2 + 16;
i+=16;
j++;
}
doublearrayoffset += points;
}
//snprintf( "blob value: %.*s", ((struct _h_type_blob *)result.data[row][col].t_data)->length, ((struct _h_type_blob *)result.data[row][col].t_data)->value);
//char* b = malloc(sizeof(int)*1736);
//for (i=0; i<((struct _h_type_blob *)result.data[row][col].t_data)->length; i++) {
// //slogi("%c", *((char*)(((struct _h_type_blob *)result.data[row][col].t_data)->value+i)));
// memcpy(&b[i], ((struct _h_type_blob *)result.data[row][col].t_data)->value+1*sizeof(char), sizeof(char));
//}
// FILE *out = fopen("memory.bin", "wb");
// if(out != NULL)
// {
// size_t to_go = sizeof(int)*1736;
// while(to_go > 0)
// {
// const size_t wrote = fwrite(b, to_go, 1, out);
// if(wrote == 0)
// break;
// to_go -= wrote;
// }
// fclose(out);
// }
break;
case HOEL_COL_TYPE_DATE:
strftime(buf, 64, "%Y-%m-%d %H:%M:%S", &((struct _h_type_datetime *)result.data[row][col].t_data)->value);
printf("| %s ", buf);
case HOEL_COL_TYPE_NULL:
slogi("| [null] ");
break;
}
}
printf("|\n");
}
return points;
}
void get_row_results(struct _h_result result, DBField* fields, void* rows, size_t rowsize) {
int col, row, i;
char buf[64];
//sess->hasdata = true;
//sess->rows = result.nb_rows;
slogi("rows: %d, col: %d", result.nb_rows, result.nb_columns);
char* aaa = (char *) rows;
for (row = 0; row<result.nb_rows; row++) {
char* aa = (char*)aaa + (rowsize * row);
for (col=0; col<result.nb_columns; col++) {
char* a = (char*) aa + fields[col].offset;
switch(result.data[row][col].type) {
case HOEL_COL_TYPE_INT:
int bb = ((struct _h_type_int *)result.data[row][col].t_data)->value;
*(int*) a = bb;
break;
case HOEL_COL_TYPE_DOUBLE:
double cc = ((struct _h_type_double *)result.data[row][col].t_data)->value;
*(double*) a = cc;
break;
case HOEL_COL_TYPE_TEXT:
char* ddd = ((struct _h_type_text *)result.data[row][col].t_data)->value;
memcpy(a, ddd, fields[col].size);
break;
case HOEL_COL_TYPE_BLOB:
for (i=0; i<((struct _h_type_blob *)result.data[row][col].t_data)->length; i++) {
printf("%c", *((char*)(((struct _h_type_blob *)result.data[row][col].t_data)->value+i)));
if (i%80 == 0 && i>0) {
printf("\n");
}
}
break;
case HOEL_COL_TYPE_DATE:
strftime(a, fields[col].size, "%Y-%m-%d %H:%M:%S", &((struct _h_type_datetime *)result.data[row][col].t_data)->value);
//strftime(buf, 64, "%Y-%m-%d %H:%M:%S", &((struct _h_type_datetime *)result.data[row][col].t_data)->value);
printf("| %s ", buf);
case HOEL_COL_TYPE_NULL:
printf("| [null] ");
break;
}
}
printf("|\n");
}
}
int getsessions(struct _h_connection* conn, int* err, const char* sessionname, SessionDbo* sess)
{
struct _h_result result;
struct _h_data * data;
char* query = malloc(99 * sizeof(char));
slogt("Performing query");
//sprintf(query, "select session_id, event_id, event_type, duration_min, elapsed_ms, laps, air_temp, road_temp, start_grip, current_grip, is_finished, http_port from %s", "Sessions");
sprintf(query, "select session_id, event_id, event_type, laps FROM %s ORDER BY session_id DESC LIMIT 25", "Sessions");
if (h_query_select(conn, query, &result) == H_OK) {
sess->rows = malloc(sizeof(SessionRowData) * result.nb_rows);
get_row_results(result, sess->fields, sess->rows, sizeof(SessionRowData));
//get_session_result(result, sess);
h_clean_result(&result);
}
else
{
printf("Error executing query\n");
*err = E_DB_QUERY_FAIL;;
free(query);
return 0;
}
free(query);
return result.nb_rows;
}
int getstints(struct _h_connection* conn, const char* sessionname, StintDbo* stint, int use_id) int getstints(struct _h_connection* conn, const char* sessionname, StintDbo* stint, int use_id)
{ {
@ -353,17 +142,17 @@ int getlaps(struct _h_connection* conn, const char* sessionname, LapDbo* laps, i
{ {
struct _h_result result; struct _h_result result;
struct _h_data * data; struct _h_data * data;
char* query = malloc(150 * sizeof(char)); char* query = malloc(250 * sizeof(char));
slogt("Performing query laps"); slogt("Performing query laps");
sprintf(query, "select lap_id, stint_id, sector_1, sector_2, sector_3, grip, tyre, time, cuts, crashes, max_speed, avg_speed FROM %s WHERE %s=%i", "Laps", "stint_id", use_id);
sprintf(query, "select * FROM %s WHERE %s=%i", "Laps", "stint_id", use_id);
if (h_query_select(conn, query, &result) == H_OK) { if (h_query_select(conn, query, &result) == H_OK) {
laps->rows = malloc(sizeof(LapRowData) * result.nb_rows); laps->rows = malloc(sizeof(LapRowData) * result.nb_rows);
get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData)); get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData));
//print_result(result); //print_result(result);
//get_stint_result(result, stint); //get_stint_result(result, stint);
h_clean_result(&result); h_clean_result(&result);
slogt("lap query returned OK");
} else { } else {
printf("Error executing query\n"); printf("Error executing query\n");
} }
@ -372,134 +161,6 @@ int getlaps(struct _h_connection* conn, const char* sessionname, LapDbo* laps, i
return result.nb_rows; return result.nb_rows;
} }
int dumptelemetrytofile(struct _h_connection* conn, char* datadir, int lap1id, int lap2id)
{
slogt("dumping telemetry to temp file");
int points = 0;
int intfields = 3;
int doublefields = 3;
struct _h_result result;
struct _h_data *data;
char* query = malloc(150 * sizeof(char));
sprintf(query, "SELECT lap_id, points FROM %s WHERE %s=%i", "telemetry", "lap_id", lap1id);
if (h_query_select(conn, query, &result) == H_OK) {
//laps->rows = malloc(sizeof(LapRowData) * result.nb_rows);
//get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData));
points = telem_result(result, 3, 3, NULL, NULL);
//get_stint_result(result, stint);
h_clean_result(&result);
} else {
printf("Error executing query\n");
}
free(query);
int* intarrays1 = malloc((sizeof(int))*points*intfields);
double* doublearrays1 = malloc((sizeof(double))*points*doublefields);
int* intarrays2 = malloc((sizeof(int))*points*intfields);
double* doublearrays2 = malloc((sizeof(double))*points*doublefields);
struct _h_result result1;
struct _h_data * data1;
char* query1 = malloc(150 * sizeof(char));
sprintf(query1, "SELECT lap_id, points, speed, gear, rpms, brake, accel, steer FROM %s WHERE %s=%i", "telemetry", "lap_id", lap1id);
if (h_query_select(conn, query1, &result1) == H_OK) {
//laps->rows = malloc(sizeof(LapRowData) * result.nb_rows);
//get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData));
points = telem_result(result1, intfields, doublefields, intarrays1, doublearrays1);
//get_stint_result(result, stint);
h_clean_result(&result1);
} else {
printf("Error executing query\n");
}
free(query1);
struct _h_result result2;
struct _h_data * data2;
char* query2 = malloc(150 * sizeof(char));
sprintf(query2, "SELECT lap_id, points, speed, gear, rpms, brake, accel, steer FROM %s WHERE %s=%i", "telemetry", "lap_id", lap2id);
if (h_query_select(conn, query2, &result2) == H_OK) {
//laps->rows = malloc(sizeof(LapRowData) * result.nb_rows);
//get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData));
points = telem_result(result2, intfields, doublefields, intarrays2, doublearrays2);
//get_stint_result(result, stint);
h_clean_result(&result2);
} else {
printf("Error executing query\n");
}
free(query2);
char* filename1= "data.out";
size_t strsize = strlen(datadir) + strlen(filename1) + 1;
char* datafile = malloc(strsize);
snprintf(datafile, strsize, "%s%s", datadir, filename1);
slogt("dumping %i points to file %s", points, datafile);
FILE *out = fopen(datafile, "w");
fprintf(out, "%s %s %s %s %s %s %s %s %s %s %s %s %s\n", "point", "speed1", "gear1", "rpms1", "brake1", "accel1", "steer1", "speed2", "gear2", "rpms2", "brake2", "accel2", "steer2" );
for (int i=0; i<points; i++)
{
fprintf(out, "%i %i %i %i %f %f %f", i+1, intarrays1[i], intarrays1[i+points], intarrays1[i+(points*2)], doublearrays1[i], doublearrays1[i+points], doublearrays1[i+(points*2)]);
fprintf(out, "%i %i %i %i %f %f %f\n", i+1, intarrays2[i], intarrays2[i+points], intarrays2[i+(points*2)], doublearrays2[i], doublearrays2[i+points], doublearrays2[i+(points*2)]);
}
fclose(out);
free(intarrays1);
free(intarrays2);
free(doublearrays1);
free(doublearrays2);
return 1;
}
//int getsessions(struct _h_connection* conn, const char* carname)
//{
// json_t *j_result;
// char* where_clause = h_build_where_clause(conn, "car_name=%s", carname);
// json_t* j_query = json_pack("{sss[s]s{s{ssss}}}","table", "sessions", "columns", "session_id", "session_name", "laps",
// "where", " ", "operator", "raw",
// "value", where_clause);
//
// slogi("Looking for car named %s", carname);
// //char* qq;
// int res = h_select(conn, j_query, &j_result, NULL);
// //slogi("here your query: %s", qq);
// // Deallocate j_query since it won't be needed anymore
// json_decref(j_query);
// h_free(where_clause);
// int session_id = -1;
// int sessions = 0;
// // Test query execution result
// if (res == H_OK) {
// // Print result
// char* dump = json_dumps(j_result, JSON_INDENT(2));
// slogi("json select result is\n%s", dump);
// int index1 = json_array_size(j_result);
// sessions = index1;
// if (index1 == 0)
// {
// slogw("no car by this name");
// }
// else {
// for (int k = 0; k < index1; k++)
// {
// json_t* jj = json_array_get(j_result, k);
// session_id = json_integer_value(json_object_get(jj, "session_id"));
// int laps = json_integer_value(json_object_get(jj, "laps"));
// slogt("found session %i with %i laps", session_id, laps);
// }
// }
// // Deallocate data result
// json_decref(j_result);
// free(dump);
// } else {
// sloge("Error executing select query: %d", res);
// }
// return sessions;
//}
@ -540,12 +201,17 @@ void* browseloop(Parameters* p, char* datadir)
DBField eventtype; DBField eventtype;
eventtype.type = HOEL_COL_TYPE_INT; eventtype.type = HOEL_COL_TYPE_INT;
eventtype.offset = offsetof(SessionRowData, event_type); eventtype.offset = offsetof(SessionRowData, event_type);
DBField track;
track.type = HOEL_COL_TYPE_TEXT;
track.offset = offsetof(SessionRowData, track);
track.size = sizeof(unsigned char)*20;
//SessionFields sf; //SessionFields sf;
sess.fields[0] = sessid; sess.fields[0] = sessid;
sess.fields[1] = eventid; sess.fields[1] = eventid;
sess.fields[2] = eventtype; sess.fields[2] = eventtype;
sess.fields[3] = laps; sess.fields[3] = laps;
sess.fields[4] = track;
//sf.session_id = sessid; //sf.session_id = sessid;
//sf.laps = laps; //sf.laps = laps;
@ -640,34 +306,34 @@ void* browseloop(Parameters* p, char* datadir)
DBField avgspeed; DBField avgspeed;
avgspeed.type = HOEL_COL_TYPE_INT; avgspeed.type = HOEL_COL_TYPE_INT;
avgspeed.offset = offsetof(LapRowData, avg_speed); avgspeed.offset = offsetof(LapRowData, avg_speed);
DBField f_tyre_temp; //DBField f_tyre_temp;
f_tyre_temp.type = HOEL_COL_TYPE_DOUBLE; //f_tyre_temp.type = HOEL_COL_TYPE_DOUBLE;
f_tyre_temp.offset = offsetof(LapRowData, f_tyre_temp); //f_tyre_temp.offset = offsetof(LapRowData, f_tyre_temp);
DBField r_tyre_temp; //DBField r_tyre_temp;
r_tyre_temp.type = HOEL_COL_TYPE_DOUBLE; //r_tyre_temp.type = HOEL_COL_TYPE_DOUBLE;
r_tyre_temp.offset = offsetof(LapRowData, r_tyre_temp); //r_tyre_temp.offset = offsetof(LapRowData, r_tyre_temp);
DBField f_tyre_wear; //DBField f_tyre_wear;
f_tyre_wear.type = HOEL_COL_TYPE_DOUBLE; //f_tyre_wear.type = HOEL_COL_TYPE_DOUBLE;
f_tyre_wear.offset = offsetof(LapRowData, f_tyre_wear); //f_tyre_wear.offset = offsetof(LapRowData, f_tyre_wear);
DBField r_tyre_wear; //DBField r_tyre_wear;
r_tyre_wear.type = HOEL_COL_TYPE_DOUBLE; //r_tyre_wear.type = HOEL_COL_TYPE_DOUBLE;
r_tyre_wear.offset = offsetof(LapRowData, r_tyre_wear); //r_tyre_wear.offset = offsetof(LapRowData, r_tyre_wear);
DBField f_tyre_press; //DBField f_tyre_press;
f_tyre_press.type = HOEL_COL_TYPE_DOUBLE; //f_tyre_press.type = HOEL_COL_TYPE_DOUBLE;
f_tyre_press.offset = offsetof(LapRowData, f_tyre_press); //f_tyre_press.offset = offsetof(LapRowData, f_tyre_press);
DBField r_tyre_press; //DBField r_tyre_press;
r_tyre_press.type = HOEL_COL_TYPE_DOUBLE; //r_tyre_press.type = HOEL_COL_TYPE_DOUBLE;
r_tyre_press.offset = offsetof(LapRowData, r_tyre_press); //r_tyre_press.offset = offsetof(LapRowData, r_tyre_press);
DBField f_brake_temp; //DBField f_brake_temp;
f_brake_temp.type = HOEL_COL_TYPE_DOUBLE; //f_brake_temp.type = HOEL_COL_TYPE_DOUBLE;
f_brake_temp.offset = offsetof(LapRowData, f_brake_temp); //f_brake_temp.offset = offsetof(LapRowData, f_brake_temp);
DBField r_brake_temp; //DBField r_brake_temp;
r_brake_temp.type = HOEL_COL_TYPE_DOUBLE; //r_brake_temp.type = HOEL_COL_TYPE_DOUBLE;
r_brake_temp.offset = offsetof(LapRowData, r_brake_temp); //r_brake_temp.offset = offsetof(LapRowData, r_brake_temp);
DBField lapsdbfinishedat; //DBField lapsdbfinishedat;
lapsdbfinishedat.type = HOEL_COL_TYPE_DATE; //lapsdbfinishedat.type = HOEL_COL_TYPE_DATE;
lapsdbfinishedat.offset = offsetof(LapRowData, finished_at); //lapsdbfinishedat.offset = offsetof(LapRowData, finished_at);
lapsdbfinishedat.size = sizeof(PDBTimeStamp); //lapsdbfinishedat.size = sizeof(PDBTimeStamp);
lapsdb.fields[0] = lapsdbid; lapsdb.fields[0] = lapsdbid;
lapsdb.fields[1] = lapsdbstintid; lapsdb.fields[1] = lapsdbstintid;
@ -681,15 +347,15 @@ void* browseloop(Parameters* p, char* datadir)
lapsdb.fields[9] = carcrashes; lapsdb.fields[9] = carcrashes;
lapsdb.fields[10] = maxspeed; lapsdb.fields[10] = maxspeed;
lapsdb.fields[11] = avgspeed; lapsdb.fields[11] = avgspeed;
lapsdb.fields[12] = lapsdbfinishedat; //lapsdb.fields[12] = lapsdbfinishedat;
lapsdb.fields[13] = f_tyre_temp; //lapsdb.fields[13] = f_tyre_temp;
lapsdb.fields[14] = r_tyre_temp; //lapsdb.fields[14] = r_tyre_temp;
lapsdb.fields[15] = f_tyre_wear; //lapsdb.fields[15] = f_tyre_wear;
lapsdb.fields[16] = r_tyre_wear; //lapsdb.fields[16] = r_tyre_wear;
lapsdb.fields[17] = f_tyre_press; //lapsdb.fields[17] = f_tyre_press;
lapsdb.fields[18] = r_tyre_press; //lapsdb.fields[18] = r_tyre_press;
lapsdb.fields[19] = f_brake_temp; //lapsdb.fields[19] = f_brake_temp;
lapsdb.fields[20] = r_brake_temp; //lapsdb.fields[20] = r_brake_temp;
//slogt("sessions has %i rows", sess.numrows); //slogt("sessions has %i rows", sess.numrows);
@ -741,6 +407,7 @@ void* browseloop(Parameters* p, char* datadir)
slogt("going to perform an action"); slogt("going to perform an action");
lapsresults = getlaps(conn, "laps", &lapsdb, lap_useid); lapsresults = getlaps(conn, "laps", &lapsdb, lap_useid);
slogt("laps query executed");
curresults = lapsresults; curresults = lapsresults;
} }
@ -748,100 +415,54 @@ void* browseloop(Parameters* p, char* datadir)
{ {
wclear(bwin1); wclear(bwin1);
wprintw(bwin1, "\n");
switch(screen) { switch(screen) {
case SESSIONS_SCREEN: case SESSIONS_SCREEN:
for(int i=0; i<sessions+1; i++) for(int i=0; i<sessions+1; i++)
{ {
int displaycolumns = 4;
int width1 = displaycolumns + 1;
int width2 = displaycolumns * 2;
if (i == 0) if (i == 0)
{ {
wattrset(bwin1, COLOR_PAIR(2)); wattrset(bwin1, COLOR_PAIR(2));
wattron(bwin1, A_BOLD); wattron(bwin1, A_BOLD);
set_spaces(bwiny/2); mvwaddnstr(bwin1, 2, bwiny/2, "Sessions", -1);
waddstr(bwin1, blanks); mvwaddnstr(bwin1, 3, bwiny/width2, "idx", 3);
mvwaddnstr(bwin1, 3, bwiny/width1+bwiny/width2, "name", 4);
char sessions_title[9]; mvwaddnstr(bwin1, 3, ((bwiny/width1)*2)+bwiny/width2, "track", 5);
sprintf(sessions_title, "Sessions"); mvwaddnstr(bwin1, 3, ((bwiny/width1)*3)+bwiny/width2, "laps", 4);
waddstr(bwin1, sessions_title); mvwhline(bwin1, 4, 0, 0, bwiny);
wprintw(bwin1, "\n");
wprintw(bwin1, "\n");
char selectind[4];
set_spaces(bwiny/4);
waddstr(bwin1, blanks);
char idx[6];
sprintf(idx, " idx ");
waddstr(bwin1, idx);
set_spaces(bwiny/6);
waddstr(bwin1, blanks);
char clastlap[26];
sprintf(clastlap, " session name ");
waddstr(bwin1, clastlap);
set_spaces(bwiny/6);
waddstr(bwin1, blanks);
char cbestlap[14];
sprintf(cbestlap, " laps ");
waddstr(bwin1, cbestlap);
add_line();
//mvhline(5, 5, 0, bwiny-1);
//mvwhline(bwin1, 20, 20, ACS_HLINE, bwiny+1);
//whline(bwin1, ACS_HLINE, 100);
wprintw(bwin1, "\n");
wattroff(bwin1, A_BOLD); wattroff(bwin1, A_BOLD);
wattrset(bwin1, COLOR_PAIR(1)); wattrset(bwin1, COLOR_PAIR(1));
} }
else else
{ {
char spacer[4];
sprintf(spacer, "\n");
waddstr(bwin1, spacer);
char selectind[6];
if ( i == selection ) if ( i == selection )
{ {
wattrset(bwin1, COLOR_PAIR(5));
stint_useid = sess.rows[i-1].session_id; stint_useid = sess.rows[i-1].session_id;
sprintf(selectind, "_*_"); mvwaddnstr(bwin1, 4+i, bwiny/width2, " * ", 3);
waddstr(bwin1, selectind);
} }
else else
{ {
sprintf(selectind, "___"); mvwaddnstr(bwin1, 4+i, bwiny/6, " ", 3);
waddstr(bwin1, selectind);
} }
int maxstrlen = 20; char idchar[4];
wprintw(bwin1, " %i ", sess.rows[i-1].session_id); snprintf(idchar, 4, "%i", sess.rows[i-1].session_id);
char lapschar[4];
snprintf(lapschar, 4, "%i", sess.rows[i-1].laps);
char trackchar[4];
snprintf(trackchar, 20, "%s", sess.rows[i-1].track);
char clastlap[14]; mvwaddnstr(bwin1, 4+i, bwiny/width2+2, idchar, 4);
sprintf(clastlap, "session name"); mvwaddnstr(bwin1, 4+i, bwiny/width2+bwiny/width1, "my session name", 15);
waddstr(bwin1, clastlap); mvwaddnstr(bwin1, 4+i, bwiny/width2+((bwiny/width1)*2), trackchar, 20);
mvwaddnstr(bwin1, 4+i, bwiny/width2+((bwiny/width1)*3), lapschar, 4);
wprintw(bwin1, " ");
char cbestlap[14];
sprintf(cbestlap, "laps %i", sess.rows[i-1].laps);
waddstr(bwin1, cbestlap);
wprintw(bwin1, "\n");
} }
//box(win1, 0, 0); wattrset(bwin1, COLOR_PAIR(1));
//wrefresh(win1);
} }
break; break;
case STINTS_SCREEN: case STINTS_SCREEN:
@ -853,64 +474,41 @@ void* browseloop(Parameters* p, char* datadir)
{ {
if (i == 0) if (i == 0)
{ {
char spacer[4]; wattrset(bwin1, COLOR_PAIR(2));
sprintf(spacer, "\n"); wattron(bwin1, A_BOLD);
waddstr(bwin1, spacer); mvwaddnstr(bwin1, 2, bwiny/2, "Stints", -1);
mvwaddnstr(bwin1, 3, bwiny/6, "idx", 3);
char selectind[4]; mvwaddnstr(bwin1, 3, bwiny/4+bwiny/6, "name", 4);
mvwaddnstr(bwin1, 3, ((bwiny/4)*2)+bwiny/6, "laps", 4);
mvwhline(bwin1, 4, 0, 0, bwiny);
char clastlap[26]; wattroff(bwin1, A_BOLD);
sprintf(clastlap, " stint name "); wattrset(bwin1, COLOR_PAIR(1));
waddstr(bwin1, clastlap);
wprintw(bwin1, " ");
char cbestlap[14];
sprintf(cbestlap, " laps ");
waddstr(bwin1, cbestlap);
wprintw(bwin1, "\n");
} }
else else
{ {
char spacer[4];
sprintf(spacer, "\n");
waddstr(bwin1, spacer);
char selectind[4];
if ( i == selection ) if ( i == selection )
{ {
sprintf(selectind, "_*_"); wattrset(bwin1, COLOR_PAIR(5));
waddstr(bwin1, selectind); lap_useid = stints.rows[i-1].stint_id;
lap_useid = stints.rows[i-i].stint_id; mvwaddnstr(bwin1, 4+i, bwiny/6, " * ", 3);
} }
else else
{ {
sprintf(selectind, "___"); mvwaddnstr(bwin1, 4+i, bwiny/6, " ", 3);
waddstr(bwin1, selectind);
} }
int maxstrlen = 20; char idchar[4];
wprintw(bwin1, " %i ", stints.rows[i-1].stint_id); snprintf(idchar, 4, "%i", stints.rows[i-1].stint_id);
char lapschar[4];
snprintf(lapschar, 4, "%i", stints.rows[i-1].laps);
char clastlap[14]; mvwaddnstr(bwin1, 4+i, bwiny/6+2, idchar, 4);
sprintf(clastlap, "stint name"); mvwaddnstr(bwin1, 4+i, bwiny/6+bwiny/4, "my session name", 15);
waddstr(bwin1, clastlap); mvwaddnstr(bwin1, 4+i, bwiny/6+((bwiny/4)*2), lapschar, 4);
wprintw(bwin1, " ");
char cbestlap[14];
sprintf(cbestlap, "laps %i", stints.rows[i-1].laps);
waddstr(bwin1, cbestlap);
wprintw(bwin1, "\n");
} }
wattrset(bwin1, COLOR_PAIR(1));
} }
break; break;
//wattrset(win4, COLOR_PAIR(1));
case LAPS_SCREEN: case LAPS_SCREEN:
if (lapsresults == 0) if (lapsresults == 0)
{ {
@ -920,92 +518,55 @@ void* browseloop(Parameters* p, char* datadir)
{ {
if (i == 0) if (i == 0)
{ {
char spacer[4]; wattrset(bwin1, COLOR_PAIR(2));
sprintf(spacer, "\n"); wattron(bwin1, A_BOLD);
waddstr(bwin1, spacer); mvwaddnstr(bwin1, 2, bwiny/2, "Laps", -1);
mvwaddnstr(bwin1, 3, bwiny/7, "idx", 3);
char selectind[4]; mvwaddnstr(bwin1, 3, bwiny/5+bwiny/7, "name", 4);
mvwaddnstr(bwin1, 3, ((bwiny/5)*2)+bwiny/7, "tyre", 4);
mvwaddnstr(bwin1, 3, ((bwiny/5)*3)+bwiny/7, "max speed", 4);
char clastlap[16]; mvwhline(bwin1, 4, 0, 0, bwiny);
sprintf(clastlap, " lap name "); wattroff(bwin1, A_BOLD);
waddstr(bwin1, clastlap); wattrset(bwin1, COLOR_PAIR(1));
wprintw(bwin1, " ");
char cbestlap[14];
sprintf(cbestlap, " tyre ");
waddstr(bwin1, cbestlap);
wprintw(bwin1, "\n");
} }
else else
{ {
wattrset(bwin1, COLOR_PAIR(5));
char spacer[4]; //stint_useid = lapsdb.rows[i-1].rows;
sprintf(spacer, "\n"); if ( lapsdb.rows[i-1].lap_id == selection1 ) {
waddstr(bwin1, spacer); mvwaddnstr(bwin1, 4+i, bwiny/7 - 4, " 1 ", 3);
char selectind[4];
if ( i == selection )
{
sprintf(selectind, "_*_");
waddstr(bwin1, selectind);
}
else
{
sprintf(selectind, "___");
waddstr(bwin1, selectind);
}
char selectind1[4];
if ( lapsdb.rows[i-1].lap_id == selection1 )
{
sprintf(selectind1, "_1_");
waddstr(bwin1, selectind1);
} }
else if ( lapsdb.rows[i-1].lap_id == selection2 ) else if ( lapsdb.rows[i-1].lap_id == selection2 )
{ {
sprintf(selectind1, "_2_");
waddstr(bwin1, selectind1); mvwaddnstr(bwin1, 4+i, bwiny/7 - 4, " 2 ", 3);
}
if ( i == selection )
{
mvwaddnstr(bwin1, 4+i, bwiny/7, " * ", 3);
} }
else else
{ {
sprintf(selectind1, "___"); mvwaddnstr(bwin1, 4+i, bwiny/7, " ", 3);
waddstr(bwin1, selectind1);
} }
char idchar[4];
snprintf(idchar, 4, "%i", lapsdb.rows[i-1].lap_id);
char tyrechar[10];
snprintf(tyrechar, 10, "%s", lapsdb.rows[i-1].tyre);
char maxspeedchar[4];
snprintf(maxspeedchar, 4, "%i", lapsdb.rows[i-1].max_speed);
int maxstrlen = 20; mvwaddnstr(bwin1, 4+i, bwiny/7+2, idchar, 4);
wprintw(bwin1, " %i ", lapsdb.rows[i-1].lap_id); mvwaddnstr(bwin1, 4+i, bwiny/7+bwiny/5, "my lap name", 13);
mvwaddnstr(bwin1, 4+i, bwiny/7+((bwiny/5)*2), tyrechar, 10);
char clastlap[14]; mvwaddnstr(bwin1, 4+i, bwiny/7+((bwiny/5)*3), maxspeedchar, 4);
sprintf(clastlap, "lap name");
waddstr(bwin1, clastlap);
wprintw(bwin1, " ");
char cbestlap[14];
sprintf(cbestlap, "laps %i", lapsdb.rows[i-1].max_speed);
waddstr(bwin1, cbestlap);
wprintw(bwin1, " ");
char gripstr[14];
sprintf(gripstr, "%s", lapsdb.rows[i-1].tyre);
waddstr(bwin1, gripstr);
wprintw(bwin1, " ");
char finstr[29];
sprintf(finstr, " %s ", lapsdb.rows[i-1].finished_at);
waddstr(bwin1, finstr);
wprintw(bwin1, "\n");
} }
wattrset(bwin1, COLOR_PAIR(1));
} }
break; break;
//wattrset(win4, COLOR_PAIR(1));
} }
action = 0; action = 0;
} }
@ -1063,8 +624,10 @@ void* browseloop(Parameters* p, char* datadir)
} }
if (ch == 'g') if (ch == 'g')
{ {
selection1 = 363; //selection1 = 363;
selection2 = 362; //selection2 = 362;
if (p->gnuplotfound == 1)
{
if (selection1 > 0 && selection2 > 0) if (selection1 > 0 && selection2 > 0)
{ {
dumptelemetrytofile(conn, datadir, selection1, selection2); dumptelemetrytofile(conn, datadir, selection1, selection2);
@ -1078,13 +641,17 @@ void* browseloop(Parameters* p, char* datadir)
slogi("Using gnu plot file %s", plotfile); slogi("Using gnu plot file %s", plotfile);
if(!fork()) if(!fork())
{ {
execv("/usr/bin/gnuplot", argv1); execv(p->gnuplot_bin, argv1);
} }
//wait(NULL); }
}
else
{
sloge("No gnuplot binary found or specified");
} }
action = 4; action = 4;
} }
if (ch == 'B') if (ch == 'B' || ch == 'l')
{ {
selection++; selection++;
if (selection > curresults) if (selection > curresults)
@ -1092,7 +659,7 @@ void* browseloop(Parameters* p, char* datadir)
selection = curresults; selection = curresults;
} }
} }
if (ch == 'A') if (ch == 'A' || ch == 'k')
{ {
selection--; selection--;
if (selection <= 1) if (selection <= 1)
@ -1115,17 +682,17 @@ void* browseloop(Parameters* p, char* datadir)
} }
wrefresh(bwin4); //wrefresh(bwin4);
delwin(bwin4); //delwin(bwin4);
endwin(); //endwin();
wrefresh(bwin3); //wrefresh(bwin3);
delwin(bwin3); //delwin(bwin3);
endwin(); //endwin();
wrefresh(bwin2); //wrefresh(bwin2);
delwin(bwin2); //delwin(bwin2);
endwin(); //endwin();
wrefresh(bwin1); wrefresh(bwin1);
delwin(bwin1); delwin(bwin1);

55
src/gilles/gameloop/gameloop.c
View File

@ -808,7 +808,7 @@ int addevent(struct _h_connection* conn, int track_config)
return getLastInsertID(conn); return getLastInsertID(conn);
} }
int addsession(struct _h_connection* conn, int eventid, int eventtype, int airtemp, int tracktemp) int addsession(struct _h_connection* conn, int eventid, int carid, int eventtype, int airtemp, int tracktemp, SimData* simdata)
{ {
// session_id | event_id | event_type | track_time | session_name // session_id | event_id | event_type | track_time | session_name
@ -822,6 +822,7 @@ int addsession(struct _h_connection* conn, int eventid, int eventtype, int airte
json_t* values = json_object(); json_t* values = json_object();
json_object_set_new(values, "event_id", json_integer(eventid)); json_object_set_new(values, "event_id", json_integer(eventid));
json_object_set_new(values, "car_id", json_integer(carid));
json_object_set_new(values, "event_type", json_integer(1)); json_object_set_new(values, "event_type", json_integer(1));
json_object_set_new(values, "duration_min", json_integer(60)); json_object_set_new(values, "duration_min", json_integer(60));
json_object_set_new(values, "start_time", json_string("NOW()")); json_object_set_new(values, "start_time", json_string("NOW()"));
@ -838,7 +839,7 @@ int addsession(struct _h_connection* conn, int eventid, int eventtype, int airte
return getLastInsertID(conn); return getLastInsertID(conn);
} }
int addstint(struct _h_connection* conn, int sessionid, int driverid, int carid) int addstint(struct _h_connection* conn, int sessionid, int driverid, int carid, SimData* simdata)
{ {
@ -910,8 +911,7 @@ int closestint(struct _h_connection* conn, int stintid, int stintlaps, int valid
return res1; return res1;
} }
int closelapquery(struct _h_connection* conn, int lapid, int sector1, int sector2, int sector3, int cuts, int crashes, int maxspeed, int avgspeed, int closelapquery(struct _h_connection* conn, int lapid, int sector1, int sector2, int sector3, int cuts, int crashes, int maxspeed, int avgspeed, Simdata* simdata))
double fbraketemp, double rbraketemp, double ftyrewear, double rtyrewear, double ftyretemp, double rtyretemp, double ftyrepress, double rtyrepress)
{ {
// stint laps // stint laps
@ -921,10 +921,25 @@ int closelapquery(struct _h_connection* conn, int lapid, int sector1, int sector
slogt("closing previous lap ", lapid); slogt("closing previous lap ", lapid);
char* query = malloc((sizeof(char)*360)); char* query = malloc((sizeof(char)*360));
sprintf(query, "UPDATE %s SET %s=%i, %s=%i, %s=%i, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, finished_at=NOW() WHERE lap_id=%i;", sprintf(query, "UPDATE %s SET %s=%i, %s=%i, %s=%i, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, finished_at=NOW() WHERE lap_id=%i;",
"laps", "sector_1", sector1, "sector_2", sector2, "sector_3", sector3, "front_tyre_temp", ftyretemp, "rear_tyre_temp", rtyretemp, "laps", "sector_1", sector1, "sector_2", sector2, "sector_3", sector3,
"front_tyre_wear", ftyrewear, "rear_tyre_wear", rtyrewear, "front_tyre_press", ftyrepress, "rear_tyre_press", rtyrepress, "right_front_tyre_temp", simdata->tyretemp[1],
"front_brake_temp", fbraketemp, "rear_brake_temp", rbraketemp, lapid); "right_rear_tyre_temp", simdata->tyretemp[3],
"right_front_tyre_wear", simdata->tyrewear[1],
"right_rear_tyre_wear", simdata->tyrewear[3],
"right_front_tyre_press",simdata->tyrepressure[1],
"right_rear_tyre_press", simdata->tyrepressure[3],
"right_front_brake_temp",simdata->braketemp[1],
"right_rear_brake_temp", simdata->braketemp[3],
"left_front_tyre_temp", simdata->tyretemp[0],
"left_rear_tyre_temp", simdata->tyretemp[2],
"left_front_tyre_wear", simdata->tyrewear[0],
"left_rear_tyre_wear", simdata->tyrewear[2],
"left_front_tyre_press",simdata->tyrepressure[0],
"left_rear_tyre_press", simdata->tyrepressure[2],
"left_front_brake_temp",simdata->braketemp[0],
"left_rear_brake_temp", simdata->braketemp[2],
lapid);
int res1 = h_query_update(conn, query); int res1 = h_query_update(conn, query);
@ -937,20 +952,12 @@ int closelapquery(struct _h_connection* conn, int lapid, int sector1, int sector
int closelap(struct _h_connection* conn, SimData* simdata, int lapid, int sector1, int sector2, int sector3, int cuts, int crashes, int maxspeed, int avgspeed) int closelap(struct _h_connection* conn, SimData* simdata, int lapid, int sector1, int sector2, int sector3, int cuts, int crashes, int maxspeed, int avgspeed)
{ {
double fbraketemp = (simdata->braketemp[0] + simdata->braketemp[1])/2;
double rbraketemp = (simdata->braketemp[2] + simdata->braketemp[3])/2;
double ftyrewear = (simdata->tyrewear[0] + simdata->tyrewear[1])/2;
double rtyrewear = (simdata->tyrewear[2] + simdata->tyrewear[3])/2;
double ftyretemp = (simdata->tyretemp[0] + simdata->tyretemp[1])/2;
double rtyretemp = (simdata->tyretemp[2] + simdata->tyretemp[3])/2;
double ftyrepress = (simdata->tyrepressure[0] + simdata->tyrepressure[1])/2;
double rtyrepress = (simdata->tyrepressure[2] + simdata->tyrepressure[3])/2;
closelapquery(conn, lapid, sector1, sector2, sector3, 0, 0, 0, 0, fbraketemp, rbraketemp, ftyrewear, rtyrewear, ftyretemp, rtyretemp, ftyrepress, rtyrepress); closelapquery(conn, lapid, sector1, sector2, sector3, 0, 0, 0, 0, simdata);
} }
int addstintlap(struct _h_connection* conn, int stintid) int addstintlap(struct _h_connection* conn, int stintid, SimData* simdata)
{ {
// stint laps // stint laps
@ -1236,9 +1243,9 @@ void* simviewmysql(void* thargs)
int stintid = 0; int stintid = 0;
int stintlapid = 0; int stintlapid = 0;
int sessionid = 0; int sessionid = 0;
sessionid = addsession(conn, eventid, simdata->session, simdata->airtemp, simdata->tracktemp); sessionid = addsession(conn, eventid, carid, simdata->session, simdata->airtemp, simdata->tracktemp, simdata);
stintid = addstint(conn, sessionid, driverid, carid); stintid = addstint(conn, sessionid, driverid, carid, simdata);
stintlapid = addstintlap(conn, stintid); stintlapid = addstintlap(conn, stintid, simdata);
sessionstatus = simdata->session; sessionstatus = simdata->session;
lastsessionstatus = sessionstatus; lastsessionstatus = sessionstatus;
lap = simdata->lap; lap = simdata->lap;
@ -1302,7 +1309,7 @@ void* simviewmysql(void* thargs)
closesession(conn, sessionid); closesession(conn, sessionid);
if (sessionstatus > 1) if (sessionstatus > 1)
{ {
sessionid = addsession(conn, eventid, simdata->session, simdata->airtemp, simdata->tracktemp); sessionid = addsession(conn, eventid, carid, simdata->session, simdata->airtemp, simdata->tracktemp, simdata);
} }
//pitstatus = 1; //pitstatus = 1;
@ -1319,7 +1326,7 @@ void* simviewmysql(void* thargs)
// close last stint // close last stint
closestint(conn, stintid, stintlaps, validstintlaps); closestint(conn, stintid, stintlaps, validstintlaps);
stintid = addstint(conn, sessionid, driverid, carid); stintid = addstint(conn, sessionid, driverid, carid, simdata);
stintlaps = 1; stintlaps = 1;
validstintlaps = 0; validstintlaps = 0;
} }
@ -1334,7 +1341,7 @@ void* simviewmysql(void* thargs)
closelap(conn, simdata, stintlapid, sectortimes[1], sectortimes[2], simdata->lastsectorinms, 0, 0, 0, 0); closelap(conn, simdata, stintlapid, sectortimes[1], sectortimes[2], simdata->lastsectorinms, 0, 0, 0, 0);
stintlapid = addstintlap(conn, stintid); stintlapid = addstintlap(conn, stintid, simdata);
int telemid = addtelemetry(conn, track_samples, stintlapid); int telemid = addtelemetry(conn, track_samples, stintlapid);
int b = updatetelemetrydata(conn, track_samples, telemid, stintlapid, speeddata, geardata, rpmdata, steerdata, acceldata, brakedata); int b = updatetelemetrydata(conn, track_samples, telemid, stintlapid, speeddata, geardata, rpmdata, steerdata, acceldata, brakedata);
tick = 0; tick = 0;

89
src/gilles/gameloop/hoeldb.c Normal file
View File

@ -0,0 +1,89 @@
#include <stdbool.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <hoel.h>
#include <jansson.h>
#include "hoeldb.h"
#include "../helper/confighelper.h"
#include "../slog/slog.h"
void get_row_results(struct _h_result result, DBField* fields, void* rows, size_t rowsize) {
int col, row, i;
char buf[64];
//sess->hasdata = true;
//sess->rows = result.nb_rows;
slogi("rows: %d, col: %d", result.nb_rows, result.nb_columns);
char* aaa = (char *) rows;
for (row = 0; row<result.nb_rows; row++) {
char* aa = (char*)aaa + (rowsize * row);
for (col=0; col<result.nb_columns; col++) {
char* a = (char*) aa + fields[col].offset;
switch(result.data[row][col].type) {
case HOEL_COL_TYPE_INT:
int bb = ((struct _h_type_int *)result.data[row][col].t_data)->value;
*(int*) a = bb;
break;
case HOEL_COL_TYPE_DOUBLE:
double cc = ((struct _h_type_double *)result.data[row][col].t_data)->value;
*(double*) a = cc;
break;
case HOEL_COL_TYPE_TEXT:
char* ddd = ((struct _h_type_text *)result.data[row][col].t_data)->value;
memcpy(a, ddd, fields[col].size);
break;
case HOEL_COL_TYPE_BLOB:
for (i=0; i<((struct _h_type_blob *)result.data[row][col].t_data)->length; i++) {
printf("%c", *((char*)(((struct _h_type_blob *)result.data[row][col].t_data)->value+i)));
if (i%80 == 0 && i>0) {
printf("\n");
}
}
break;
case HOEL_COL_TYPE_DATE:
strftime(a, fields[col].size, "%Y-%m-%d %H:%M:%S", &((struct _h_type_datetime *)result.data[row][col].t_data)->value);
//strftime(buf, 64, "%Y-%m-%d %H:%M:%S", &((struct _h_type_datetime *)result.data[row][col].t_data)->value);
printf("| %s ", buf);
case HOEL_COL_TYPE_NULL:
printf("| [null] ");
break;
}
}
printf("|\n");
}
}
int getsessions(struct _h_connection* conn, int* err, const char* sessionname, SessionDbo* sess)
{
struct _h_result result;
struct _h_data * data;
char* query = malloc(247 * sizeof(char));
slogt("Performing query");
//sprintf(query, "select session_id, event_id, event_type, duration_min, elapsed_ms, laps, air_temp, road_temp, start_grip, current_grip, is_finished, http_port from %s", "Sessions");
sprintf(query, "select session_id, events.event_id, sessions.event_type, laps, display_name FROM %s JOIN events ON sessions.event_id=events.event_id JOIN track_config ON events.track_config_id=track_config.track_config_id ORDER BY session_id DESC LIMIT 25", "Sessions");
int errcode = h_query_select(conn, query, &result);
if (errcode == H_OK)
{
sess->rows = malloc(sizeof(SessionRowData) * result.nb_rows);
get_row_results(result, sess->fields, sess->rows, sizeof(SessionRowData));
//get_session_result(result, sess);
h_clean_result(&result);
}
else
{
sloge("Error executing query %s returned %i", query, errcode);
*err = E_DB_QUERY_FAIL;;
free(query);
return 0;
}
free(query);
return result.nb_rows;
}

32
src/gilles/gameloop/session.h → src/gilles/gameloop/hoeldb.h
View File

@ -1,6 +1,6 @@
#ifndef _SESSION_H #ifndef _HOELDB_H
#define _SESSION_H #define _HOELDB_H
#include <stddef.h> #include <stddef.h>
#include <stdbool.h> #include <stdbool.h>
@ -38,6 +38,7 @@ typedef struct SessionRowData
//int duration_min; //int duration_min;
//int elapsed_ms; //int elapsed_ms;
int laps; int laps;
unsigned char track[20];
//char weather[100]; //char weather[100];
//double air_temp; //double air_temp;
//double road_temp; //double road_temp;
@ -68,6 +69,7 @@ typedef struct StintRowData
int laps; int laps;
int valid_laps; int valid_laps;
int best_lap_id; int best_lap_id;
unsigned char tyre[10];
} }
StintRowData; StintRowData;
@ -85,15 +87,15 @@ typedef struct LapRowData
int crashes; int crashes;
int max_speed; int max_speed;
int avg_speed; int avg_speed;
PDBTimeStamp finished_at; //PDBTimeStamp finished_at;
double f_tyre_temp; //double f_tyre_temp;
double r_tyre_temp; //double r_tyre_temp;
double f_tyre_wear; //double f_tyre_wear;
double r_tyre_wear; //double r_tyre_wear;
double f_tyre_press; //double f_tyre_press;
double r_tyre_press; //double r_tyre_press;
double f_brake_temp; //double f_brake_temp;
double r_brake_temp; //double r_brake_temp;
} }
LapRowData; LapRowData;
@ -102,7 +104,7 @@ typedef struct SessionDbo
int numrows; int numrows;
bool hasdata; bool hasdata;
DBField fields[4]; DBField fields[5];
SessionRowData* rows; SessionRowData* rows;
} }
SessionDbo; SessionDbo;
@ -122,9 +124,13 @@ typedef struct LapDbo
int numrows; int numrows;
bool hasdata; bool hasdata;
DBField fields[21]; DBField fields[12];
LapRowData* rows; LapRowData* rows;
} }
LapDbo; LapDbo;
void get_row_results(struct _h_result result, DBField* fields, void* rows, size_t rowsize);
int getsessions(struct _h_connection* conn, int* err, const char* sessionname, SessionDbo* sess);
#endif #endif

228
src/gilles/gameloop/telemetry.c Normal file
View File

@ -0,0 +1,228 @@
#include <stdbool.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <hoel.h>
#include <jansson.h>
#include "telemetry.h"
#include "../helper/confighelper.h"
#include "../slog/slog.h"
int telem_result(struct _h_result result, int doublefields, int intfields, int* intarrays, double* doublearrays) {
int col, row, i;
char buf[64];
slogt("rows: %d, col: %d", result.nb_rows, result.nb_columns);
//int* intarrays;
int points = 0;
//int doublefields = 3;
//int intfields = 3;
//int* intarrays;
//int* doublearrays;
//int* intarrays = malloc((sizeof(int)*1736)*3);
//double* doublearrays = malloc((sizeof(double)*1736)*3);
int intarrayoffset = 0;
int doublearrayoffset = 0;
for (row = 0; row<result.nb_rows; row++) {
for (col=0; col<result.nb_columns; col++) {
switch(result.data[row][col].type) {
case HOEL_COL_TYPE_INT:
int cc = ((struct _h_type_int *)result.data[row][col].t_data)->value;
if (col == 1)
{
points = cc;
}
break;
case HOEL_COL_TYPE_DOUBLE:
//intarrays = malloc((sizeof(int)*1736)*3);
break;
case HOEL_COL_TYPE_TEXT:
slogi("| %s ", ((struct _h_type_text *)result.data[row][col].t_data)->value);
break;
case HOEL_COL_TYPE_BLOB:
int offset2 = 0;
int j = 0;
i = 2;
if (col < 5)
{
while (i<((struct _h_type_blob *)result.data[row][col].t_data)->length)
{
char sss[10];
sss[0] = '0';
sss[1] = 'x';
sss[2] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+2);
sss[3] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+3);
sss[4] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+4);
sss[5] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+5);
sss[6] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+6);
sss[7] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+7);
sss[8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+8);
sss[9] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+9);
long val;
int number = (int)strtol(sss, NULL, 16);
int swapped = __bswap_32(number);
intarrays[j+intarrayoffset] = __bswap_32(number);
offset2 = offset2 + 8;
i+=8;
j++;
}
intarrayoffset += points;
}
else
{
while (i<((struct _h_type_blob *)result.data[row][col].t_data)->length)
{
char sss[18];
sss[0] = '0';
sss[1] = 'x';
sss[2] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+2);
sss[3] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+3);
sss[4] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+4);
sss[5] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+5);
sss[6] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+6);
sss[7] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+7);
sss[8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+8);
sss[9] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+9);
sss[2+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+2+8);
sss[3+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+3+8);
sss[4+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+4+8);
sss[5+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+5+8);
sss[6+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+6+8);
sss[7+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+7+8);
sss[8+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+8+8);
sss[9+8] = *((char*)((struct _h_type_blob *)result.data[row][col].t_data)->value+offset2+9+8);
long val;
int64_t number = (int64_t) strtoll(sss, NULL, 16);
int64_t swapped = __bswap_64(number);
double d = *((double*)&swapped);
doublearrays[j+doublearrayoffset] = (double) d;
offset2 = offset2 + 16;
i+=16;
j++;
}
doublearrayoffset += points;
}
//snprintf( "blob value: %.*s", ((struct _h_type_blob *)result.data[row][col].t_data)->length, ((struct _h_type_blob *)result.data[row][col].t_data)->value);
//char* b = malloc(sizeof(int)*1736);
//for (i=0; i<((struct _h_type_blob *)result.data[row][col].t_data)->length; i++) {
// //slogi("%c", *((char*)(((struct _h_type_blob *)result.data[row][col].t_data)->value+i)));
// memcpy(&b[i], ((struct _h_type_blob *)result.data[row][col].t_data)->value+1*sizeof(char), sizeof(char));
//}
// FILE *out = fopen("memory.bin", "wb");
// if(out != NULL)
// {
// size_t to_go = sizeof(int)*1736;
// while(to_go > 0)
// {
// const size_t wrote = fwrite(b, to_go, 1, out);
// if(wrote == 0)
// break;
// to_go -= wrote;
// }
// fclose(out);
// }
break;
case HOEL_COL_TYPE_DATE:
strftime(buf, 64, "%Y-%m-%d %H:%M:%S", &((struct _h_type_datetime *)result.data[row][col].t_data)->value);
printf("| %s ", buf);
case HOEL_COL_TYPE_NULL:
slogi("| [null] ");
break;
}
}
printf("|\n");
}
return points;
}
int dumptelemetrytofile(struct _h_connection* conn, char* datadir, int lap1id, int lap2id)
{
slogt("dumping telemetry to temp file: lap1id: %d lap2id: %d", lap1id, lap2id);
int points = 0;
int intfields = 3;
int doublefields = 3;
struct _h_result result;
struct _h_data *data;
char* query = malloc(150 * sizeof(char));
sprintf(query, "SELECT lap_id, points FROM %s WHERE %s=%i", "telemetry", "lap_id", lap1id);
if (h_query_select(conn, query, &result) == H_OK) {
//laps->rows = malloc(sizeof(LapRowData) * result.nb_rows);
//get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData));
points = telem_result(result, 3, 3, NULL, NULL);
//get_stint_result(result, stint);
h_clean_result(&result);
} else {
printf("Error executing query\n");
}
free(query);
int* intarrays1 = malloc((sizeof(int))*points*intfields);
double* doublearrays1 = malloc((sizeof(double))*points*doublefields);
int* intarrays2 = malloc((sizeof(int))*points*intfields);
double* doublearrays2 = malloc((sizeof(double))*points*doublefields);
struct _h_result result1;
struct _h_data * data1;
char* query1 = malloc(150 * sizeof(char));
sprintf(query1, "SELECT lap_id, points, speed, gear, rpms, brake, accel, steer FROM %s WHERE %s=%i", "telemetry", "lap_id", lap1id);
if (h_query_select(conn, query1, &result1) == H_OK) {
//laps->rows = malloc(sizeof(LapRowData) * result.nb_rows);
//get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData));
points = telem_result(result1, intfields, doublefields, intarrays1, doublearrays1);
//get_stint_result(result, stint);
h_clean_result(&result1);
} else {
printf("Error executing query\n");
}
free(query1);
struct _h_result result2;
struct _h_data * data2;
char* query2 = malloc(150 * sizeof(char));
sprintf(query2, "SELECT lap_id, points, speed, gear, rpms, brake, accel, steer FROM %s WHERE %s=%i", "telemetry", "lap_id", lap2id);
if (h_query_select(conn, query2, &result2) == H_OK) {
//laps->rows = malloc(sizeof(LapRowData) * result.nb_rows);
//get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData));
points = telem_result(result2, intfields, doublefields, intarrays2, doublearrays2);
//get_stint_result(result, stint);
h_clean_result(&result2);
} else {
printf("Error executing query\n");
}
free(query2);
char* filename1 = "data.out";
size_t strsize = strlen(datadir) + strlen(filename1) + 1;
char* datafile = malloc(strsize);
snprintf(datafile, strsize, "%s%s", datadir, filename1);
slogt("dumping %i points to file %s", points, datafile);
FILE *out = fopen(datafile, "w");
fprintf(out, "%s %s %s %s %s %s %s %s %s %s %s %s %s\n", "point", "speed1", "gear1", "rpms1", "brake1", "accel1", "steer1", "speed2", "gear2", "rpms2", "brake2", "accel2", "steer2" );
for (int i=0; i<points; i++)
{
fprintf(out, "%i %i %i %i %f %f %f", i+1, intarrays1[i], intarrays1[i+points], intarrays1[i+(points*2)], doublearrays1[i], doublearrays1[i+points], doublearrays1[i+(points*2)]);
fprintf(out, "%i %i %i %i %f %f %f\n", i+1, intarrays2[i], intarrays2[i+points], intarrays2[i+(points*2)], doublearrays2[i], doublearrays2[i+points], doublearrays2[i+(points*2)]);
}
fclose(out);
free(intarrays1);
free(intarrays2);
free(doublearrays1);
free(doublearrays2);
free(datafile);
return 1;
}

6
src/gilles/gameloop/telemetry.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef _TELEMETRY_H
#define _TELEMETRY_H
int dumptelemetrytofile(struct _h_connection* conn, char* datadir, int lap1id, int lap2id);
#endif

1
src/gilles/gilles.c
View File

@ -59,7 +59,6 @@ int main(int argc, char** argv)
char* configdir = create_user_dir(home_dir_str, ".config", PROGRAM_NAME); char* configdir = create_user_dir(home_dir_str, ".config", PROGRAM_NAME);
char* datadir = create_user_dir(home_dir_str, ".local/share", PROGRAM_NAME); char* datadir = create_user_dir(home_dir_str, ".local/share", PROGRAM_NAME);
xdgHandle xdg; xdgHandle xdg;
if(!xdgInitHandle(&xdg)) if(!xdgInitHandle(&xdg))
{ {

20
src/gilles/helper/confighelper.c
View File

@ -3,6 +3,7 @@
#include <string.h> #include <string.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include "confighelper.h" #include "confighelper.h"
@ -73,8 +74,10 @@ int loadconfig(const char* config_file_str, Parameters* p)
{ {
slogi("Parsing config file"); slogi("Parsing config file");
if (p->program_action == A_BROWSE) if (p->program_action == A_BROWSE)
{ {
char* gnuplotbin = "/usr/bin/gnuplot";
config_setting_t* config_graph_array = NULL; config_setting_t* config_graph_array = NULL;
config_graph_array = config_lookup(&cfg, "graph"); config_graph_array = config_lookup(&cfg, "graph");
@ -88,7 +91,22 @@ int loadconfig(const char* config_file_str, Parameters* p)
const char* temp; const char* temp;
config_setting_lookup_string(config_graph, "gnuplotfile", &temp); config_setting_lookup_string(config_graph, "gnuplotfile", &temp);
p->gnuplot_file = strdup(temp); p->gnuplot_file = strdup(temp);
slogi("set gnuplot config file %s", p->gnuplot_file); slogt("set gnuplot config file %s", p->gnuplot_file);
int found = config_setting_lookup_string(config_graph, "gnuplotbin", &temp);
if (found > 0)
{
p->gnuplot_bin = strdup(temp);
}
else
{
p->gnuplot_bin = strdup(gnuplotbin);
}
p->gnuplotfound = 0;
if (access(p->gnuplot_bin, F_OK) == 0)
{
p->gnuplotfound = 1;
}
} }
if (p->mysql == true || p->program_action == A_BROWSE) if (p->mysql == true || p->program_action == A_BROWSE)

4
src/gilles/helper/parameters.c
View File

@ -25,6 +25,10 @@ int freeparams(Parameters* p)
free(p->db_conn); free(p->db_conn);
} }
} }
if (p->program_action == A_BROWSE)
{
free(p->gnuplot_bin);
}
if (p->config_path != NULL) if (p->config_path != NULL)
{ {
free(p->config_path); free(p->config_path);

2
src/gilles/helper/parameters.h
View File

@ -14,6 +14,8 @@ typedef struct
int program_state; int program_state;
char* config_path; char* config_path;
char* gnuplot_file; char* gnuplot_file;
char* gnuplot_bin;
int gnuplotfound;
bool cli; bool cli;
bool mqtt; bool mqtt;