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
browseloop.c
browseloop.h
session.h
session.c
telemetry.h
telemetry.c
)

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

@ -16,7 +16,8 @@
#include <byteswap.h>
#include "session.h"
#include "hoeldb.h"
#include "telemetry.h"
#include "gameloop.h"
#include "../helper/parameters.h"
#include "../helper/confighelper.h"
@ -41,7 +42,7 @@ WINDOW* bwin4;
int bwinx, bwiny;
char blanks[100];
char blanks[1000];
void add_line()
{
@ -73,17 +74,6 @@ void b_handle_winch(int sig)
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()
{
@ -93,6 +83,7 @@ int b_curses_init()
init_pair(1,COLOR_GREEN,0);
init_pair(2,COLOR_YELLOW,0);
init_pair(5,COLOR_BLACK,COLOR_YELLOW);
init_pair(3,COLOR_MAGENTA,0);
init_pair(4,COLOR_WHITE,0);
@ -111,220 +102,18 @@ int b_curses_init()
wbkgd(bwin4,COLOR_PAIR(1));
signal(SIGWINCH, b_handle_winch);
curs_set(0);
cbreak();
noecho();
box(bwin1, 0, 0);
box(bwin2, 0, 0);
box(bwin3, 0, 0);
box(bwin4, 0, 0);
//box(bwin2, 0, 0);
//box(bwin3, 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)
{
@ -353,17 +142,17 @@ int getlaps(struct _h_connection* conn, const char* sessionname, LapDbo* laps, i
{
struct _h_result result;
struct _h_data * data;
char* query = malloc(150 * sizeof(char));
char* query = malloc(250 * sizeof(char));
slogt("Performing query laps");
sprintf(query, "select * FROM %s WHERE %s=%i", "Laps", "stint_id", use_id);
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);
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));
//print_result(result);
//get_stint_result(result, stint);
h_clean_result(&result);
slogt("lap query returned OK");
} else {
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;
}
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;
eventtype.type = HOEL_COL_TYPE_INT;
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;
sess.fields[0] = sessid;
sess.fields[1] = eventid;
sess.fields[2] = eventtype;
sess.fields[3] = laps;
sess.fields[4] = track;
//sf.session_id = sessid;
//sf.laps = laps;
@ -640,34 +306,34 @@ void* browseloop(Parameters* p, char* datadir)
DBField avgspeed;
avgspeed.type = HOEL_COL_TYPE_INT;
avgspeed.offset = offsetof(LapRowData, avg_speed);
DBField f_tyre_temp;
f_tyre_temp.type = HOEL_COL_TYPE_DOUBLE;
f_tyre_temp.offset = offsetof(LapRowData, f_tyre_temp);
DBField r_tyre_temp;
r_tyre_temp.type = HOEL_COL_TYPE_DOUBLE;
r_tyre_temp.offset = offsetof(LapRowData, r_tyre_temp);
DBField f_tyre_wear;
f_tyre_wear.type = HOEL_COL_TYPE_DOUBLE;
f_tyre_wear.offset = offsetof(LapRowData, f_tyre_wear);
DBField r_tyre_wear;
r_tyre_wear.type = HOEL_COL_TYPE_DOUBLE;
r_tyre_wear.offset = offsetof(LapRowData, r_tyre_wear);
DBField f_tyre_press;
f_tyre_press.type = HOEL_COL_TYPE_DOUBLE;
f_tyre_press.offset = offsetof(LapRowData, f_tyre_press);
DBField r_tyre_press;
r_tyre_press.type = HOEL_COL_TYPE_DOUBLE;
r_tyre_press.offset = offsetof(LapRowData, r_tyre_press);
DBField f_brake_temp;
f_brake_temp.type = HOEL_COL_TYPE_DOUBLE;
f_brake_temp.offset = offsetof(LapRowData, f_brake_temp);
DBField r_brake_temp;
r_brake_temp.type = HOEL_COL_TYPE_DOUBLE;
r_brake_temp.offset = offsetof(LapRowData, r_brake_temp);
DBField lapsdbfinishedat;
lapsdbfinishedat.type = HOEL_COL_TYPE_DATE;
lapsdbfinishedat.offset = offsetof(LapRowData, finished_at);
lapsdbfinishedat.size = sizeof(PDBTimeStamp);
//DBField f_tyre_temp;
//f_tyre_temp.type = HOEL_COL_TYPE_DOUBLE;
//f_tyre_temp.offset = offsetof(LapRowData, f_tyre_temp);
//DBField r_tyre_temp;
//r_tyre_temp.type = HOEL_COL_TYPE_DOUBLE;
//r_tyre_temp.offset = offsetof(LapRowData, r_tyre_temp);
//DBField f_tyre_wear;
//f_tyre_wear.type = HOEL_COL_TYPE_DOUBLE;
//f_tyre_wear.offset = offsetof(LapRowData, f_tyre_wear);
//DBField r_tyre_wear;
//r_tyre_wear.type = HOEL_COL_TYPE_DOUBLE;
//r_tyre_wear.offset = offsetof(LapRowData, r_tyre_wear);
//DBField f_tyre_press;
//f_tyre_press.type = HOEL_COL_TYPE_DOUBLE;
//f_tyre_press.offset = offsetof(LapRowData, f_tyre_press);
//DBField r_tyre_press;
//r_tyre_press.type = HOEL_COL_TYPE_DOUBLE;
//r_tyre_press.offset = offsetof(LapRowData, r_tyre_press);
//DBField f_brake_temp;
//f_brake_temp.type = HOEL_COL_TYPE_DOUBLE;
//f_brake_temp.offset = offsetof(LapRowData, f_brake_temp);
//DBField r_brake_temp;
//r_brake_temp.type = HOEL_COL_TYPE_DOUBLE;
//r_brake_temp.offset = offsetof(LapRowData, r_brake_temp);
//DBField lapsdbfinishedat;
//lapsdbfinishedat.type = HOEL_COL_TYPE_DATE;
//lapsdbfinishedat.offset = offsetof(LapRowData, finished_at);
//lapsdbfinishedat.size = sizeof(PDBTimeStamp);
lapsdb.fields[0] = lapsdbid;
lapsdb.fields[1] = lapsdbstintid;
@ -681,15 +347,15 @@ void* browseloop(Parameters* p, char* datadir)
lapsdb.fields[9] = carcrashes;
lapsdb.fields[10] = maxspeed;
lapsdb.fields[11] = avgspeed;
lapsdb.fields[12] = lapsdbfinishedat;
lapsdb.fields[13] = f_tyre_temp;
lapsdb.fields[14] = r_tyre_temp;
lapsdb.fields[15] = f_tyre_wear;
lapsdb.fields[16] = r_tyre_wear;
lapsdb.fields[17] = f_tyre_press;
lapsdb.fields[18] = r_tyre_press;
lapsdb.fields[19] = f_brake_temp;
lapsdb.fields[20] = r_brake_temp;
//lapsdb.fields[12] = lapsdbfinishedat;
//lapsdb.fields[13] = f_tyre_temp;
//lapsdb.fields[14] = r_tyre_temp;
//lapsdb.fields[15] = f_tyre_wear;
//lapsdb.fields[16] = r_tyre_wear;
//lapsdb.fields[17] = f_tyre_press;
//lapsdb.fields[18] = r_tyre_press;
//lapsdb.fields[19] = f_brake_temp;
//lapsdb.fields[20] = r_brake_temp;
//slogt("sessions has %i rows", sess.numrows);
@ -741,6 +407,7 @@ void* browseloop(Parameters* p, char* datadir)
slogt("going to perform an action");
lapsresults = getlaps(conn, "laps", &lapsdb, lap_useid);
slogt("laps query executed");
curresults = lapsresults;
}
@ -748,100 +415,54 @@ void* browseloop(Parameters* p, char* datadir)
{
wclear(bwin1);
wprintw(bwin1, "\n");
switch(screen) {
case SESSIONS_SCREEN:
for(int i=0; i<sessions+1; i++)
{
int displaycolumns = 4;
int width1 = displaycolumns + 1;
int width2 = displaycolumns * 2;
if (i == 0)
{
wattrset(bwin1, COLOR_PAIR(2));
wattron(bwin1, A_BOLD);
set_spaces(bwiny/2);
waddstr(bwin1, blanks);
char sessions_title[9];
sprintf(sessions_title, "Sessions");
waddstr(bwin1, sessions_title);
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");
mvwaddnstr(bwin1, 2, bwiny/2, "Sessions", -1);
mvwaddnstr(bwin1, 3, bwiny/width2, "idx", 3);
mvwaddnstr(bwin1, 3, bwiny/width1+bwiny/width2, "name", 4);
mvwaddnstr(bwin1, 3, ((bwiny/width1)*2)+bwiny/width2, "track", 5);
mvwaddnstr(bwin1, 3, ((bwiny/width1)*3)+bwiny/width2, "laps", 4);
mvwhline(bwin1, 4, 0, 0, bwiny);
wattroff(bwin1, A_BOLD);
wattrset(bwin1, COLOR_PAIR(1));
}
else
{
char spacer[4];
sprintf(spacer, "\n");
waddstr(bwin1, spacer);
char selectind[6];
if ( i == selection )
{
stint_useid = sess.rows[i-1].session_id;
sprintf(selectind, "_*_");
waddstr(bwin1, selectind);
wattrset(bwin1, COLOR_PAIR(5));
stint_useid = sess.rows[i-1].session_id;
mvwaddnstr(bwin1, 4+i, bwiny/width2, " * ", 3);
}
else
{
sprintf(selectind, "___");
waddstr(bwin1, selectind);
mvwaddnstr(bwin1, 4+i, bwiny/6, " ", 3);
}
int maxstrlen = 20;
wprintw(bwin1, " %i ", sess.rows[i-1].session_id);
char idchar[4];
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];
sprintf(clastlap, "session name");
waddstr(bwin1, clastlap);
wprintw(bwin1, " ");
char cbestlap[14];
sprintf(cbestlap, "laps %i", sess.rows[i-1].laps);
waddstr(bwin1, cbestlap);
wprintw(bwin1, "\n");
}
//box(win1, 0, 0);
//wrefresh(win1);
mvwaddnstr(bwin1, 4+i, bwiny/width2+2, idchar, 4);
mvwaddnstr(bwin1, 4+i, bwiny/width2+bwiny/width1, "my session name", 15);
mvwaddnstr(bwin1, 4+i, bwiny/width2+((bwiny/width1)*2), trackchar, 20);
mvwaddnstr(bwin1, 4+i, bwiny/width2+((bwiny/width1)*3), lapschar, 4);
}
wattrset(bwin1, COLOR_PAIR(1));
}
break;
case STINTS_SCREEN:
@ -853,64 +474,41 @@ void* browseloop(Parameters* p, char* datadir)
{
if (i == 0)
{
char spacer[4];
sprintf(spacer, "\n");
waddstr(bwin1, spacer);
char selectind[4];
char clastlap[26];
sprintf(clastlap, " stint name ");
waddstr(bwin1, clastlap);
wprintw(bwin1, " ");
char cbestlap[14];
sprintf(cbestlap, " laps ");
waddstr(bwin1, cbestlap);
wprintw(bwin1, "\n");
wattrset(bwin1, COLOR_PAIR(2));
wattron(bwin1, A_BOLD);
mvwaddnstr(bwin1, 2, bwiny/2, "Stints", -1);
mvwaddnstr(bwin1, 3, bwiny/6, "idx", 3);
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);
wattroff(bwin1, A_BOLD);
wattrset(bwin1, COLOR_PAIR(1));
}
else
{
char spacer[4];
sprintf(spacer, "\n");
waddstr(bwin1, spacer);
char selectind[4];
if ( i == selection )
{
sprintf(selectind, "_*_");
waddstr(bwin1, selectind);
lap_useid = stints.rows[i-i].stint_id;
wattrset(bwin1, COLOR_PAIR(5));
lap_useid = stints.rows[i-1].stint_id;
mvwaddnstr(bwin1, 4+i, bwiny/6, " * ", 3);
}
else
{
sprintf(selectind, "___");
waddstr(bwin1, selectind);
mvwaddnstr(bwin1, 4+i, bwiny/6, " ", 3);
}
int maxstrlen = 20;
wprintw(bwin1, " %i ", stints.rows[i-1].stint_id);
char idchar[4];
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];
sprintf(clastlap, "stint name");
waddstr(bwin1, clastlap);
wprintw(bwin1, " ");
char cbestlap[14];
sprintf(cbestlap, "laps %i", stints.rows[i-1].laps);
waddstr(bwin1, cbestlap);
wprintw(bwin1, "\n");
}
mvwaddnstr(bwin1, 4+i, bwiny/6+2, idchar, 4);
mvwaddnstr(bwin1, 4+i, bwiny/6+bwiny/4, "my session name", 15);
mvwaddnstr(bwin1, 4+i, bwiny/6+((bwiny/4)*2), lapschar, 4);
}
wattrset(bwin1, COLOR_PAIR(1));
}
break;
//wattrset(win4, COLOR_PAIR(1));
case LAPS_SCREEN:
if (lapsresults == 0)
{
@ -920,92 +518,55 @@ void* browseloop(Parameters* p, char* datadir)
{
if (i == 0)
{
char spacer[4];
sprintf(spacer, "\n");
waddstr(bwin1, spacer);
char selectind[4];
char clastlap[16];
sprintf(clastlap, " lap name ");
waddstr(bwin1, clastlap);
wprintw(bwin1, " ");
char cbestlap[14];
sprintf(cbestlap, " tyre ");
waddstr(bwin1, cbestlap);
wprintw(bwin1, "\n");
wattrset(bwin1, COLOR_PAIR(2));
wattron(bwin1, A_BOLD);
mvwaddnstr(bwin1, 2, bwiny/2, "Laps", -1);
mvwaddnstr(bwin1, 3, bwiny/7, "idx", 3);
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);
mvwhline(bwin1, 4, 0, 0, bwiny);
wattroff(bwin1, A_BOLD);
wattrset(bwin1, COLOR_PAIR(1));
}
else
{
wattrset(bwin1, COLOR_PAIR(5));
//stint_useid = lapsdb.rows[i-1].rows;
if ( lapsdb.rows[i-1].lap_id == selection1 ) {
mvwaddnstr(bwin1, 4+i, bwiny/7 - 4, " 1 ", 3);
}
else if ( lapsdb.rows[i-1].lap_id == selection2 )
{
char spacer[4];
sprintf(spacer, "\n");
waddstr(bwin1, spacer);
mvwaddnstr(bwin1, 4+i, bwiny/7 - 4, " 2 ", 3);
}
if ( i == selection )
{
mvwaddnstr(bwin1, 4+i, bwiny/7, " * ", 3);
}
else
{
mvwaddnstr(bwin1, 4+i, bwiny/7, " ", 3);
char selectind[4];
}
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);
if ( i == selection )
{
sprintf(selectind, "_*_");
waddstr(bwin1, selectind);
}
else
{
sprintf(selectind, "___");
waddstr(bwin1, selectind);
mvwaddnstr(bwin1, 4+i, bwiny/7+2, idchar, 4);
mvwaddnstr(bwin1, 4+i, bwiny/7+bwiny/5, "my lap name", 13);
mvwaddnstr(bwin1, 4+i, bwiny/7+((bwiny/5)*2), tyrechar, 10);
mvwaddnstr(bwin1, 4+i, bwiny/7+((bwiny/5)*3), maxspeedchar, 4);
}
wattrset(bwin1, COLOR_PAIR(1));
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 )
{
sprintf(selectind1, "_2_");
waddstr(bwin1, selectind1);
}
else
{
sprintf(selectind1, "___");
waddstr(bwin1, selectind1);
}
int maxstrlen = 20;
wprintw(bwin1, " %i ", lapsdb.rows[i-1].lap_id);
char clastlap[14];
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");
}
}
break;
//wattrset(win4, COLOR_PAIR(1));
}
action = 0;
}
@ -1063,28 +624,34 @@ void* browseloop(Parameters* p, char* datadir)
}
if (ch == 'g')
{
selection1 = 363;
selection2 = 362;
if (selection1 > 0 && selection2 > 0)
//selection1 = 363;
//selection2 = 362;
if (p->gnuplotfound == 1)
{
dumptelemetrytofile(conn, datadir, selection1, selection2);
if (selection1 > 0 && selection2 > 0)
{
dumptelemetrytofile(conn, datadir, selection1, selection2);
slogt("finished dumping data");
size_t strsize = strlen(datadir) + strlen(p->gnuplot_file) + 1;
char* plotfile = malloc(strsize);
snprintf(plotfile, strsize, "%s%s", datadir, p->gnuplot_file);
static char* argv1[]={"gnuplot", "-p", "plotfile.gp", NULL};
argv1[2] = plotfile;
slogi("Using gnu plot file %s", plotfile);
if(!fork())
{
execv("/usr/bin/gnuplot", argv1);
}
//wait(NULL);
slogt("finished dumping data");
size_t strsize = strlen(datadir) + strlen(p->gnuplot_file) + 1;
char* plotfile = malloc(strsize);
snprintf(plotfile, strsize, "%s%s", datadir, p->gnuplot_file);
static char* argv1[]={"gnuplot", "-p", "plotfile.gp", NULL};
argv1[2] = plotfile;
slogi("Using gnu plot file %s", plotfile);
if(!fork())
{
execv(p->gnuplot_bin, argv1);
}
}
}
else
{
sloge("No gnuplot binary found or specified");
}
action = 4;
}
if (ch == 'B')
if (ch == 'B' || ch == 'l')
{
selection++;
if (selection > curresults)
@ -1092,7 +659,7 @@ void* browseloop(Parameters* p, char* datadir)
selection = curresults;
}
}
if (ch == 'A')
if (ch == 'A' || ch == 'k')
{
selection--;
if (selection <= 1)
@ -1115,17 +682,17 @@ void* browseloop(Parameters* p, char* datadir)
}
wrefresh(bwin4);
delwin(bwin4);
endwin();
//wrefresh(bwin4);
//delwin(bwin4);
//endwin();
wrefresh(bwin3);
delwin(bwin3);
endwin();
//wrefresh(bwin3);
//delwin(bwin3);
//endwin();
wrefresh(bwin2);
delwin(bwin2);
endwin();
//wrefresh(bwin2);
//delwin(bwin2);
//endwin();
wrefresh(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);
}
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
@ -822,6 +822,7 @@ int addsession(struct _h_connection* conn, int eventid, int eventtype, int airte
json_t* values = json_object();
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, "duration_min", json_integer(60));
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);
}
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;
}
int closelapquery(struct _h_connection* conn, int lapid, int sector1, int sector2, int sector3, int cuts, int crashes, int maxspeed, int avgspeed,
double fbraketemp, double rbraketemp, double ftyrewear, double rtyrewear, double ftyretemp, double rtyretemp, double ftyrepress, double rtyrepress)
int closelapquery(struct _h_connection* conn, int lapid, int sector1, int sector2, int sector3, int cuts, int crashes, int maxspeed, int avgspeed, Simdata* simdata))
{
// stint laps
@ -921,10 +921,25 @@ int closelapquery(struct _h_connection* conn, int lapid, int sector1, int sector
slogt("closing previous lap ", lapid);
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;",
"laps", "sector_1", sector1, "sector_2", sector2, "sector_3", sector3, "front_tyre_temp", ftyretemp, "rear_tyre_temp", rtyretemp,
"front_tyre_wear", ftyrewear, "rear_tyre_wear", rtyrewear, "front_tyre_press", ftyrepress, "rear_tyre_press", rtyrepress,
"front_brake_temp", fbraketemp, "rear_brake_temp", rbraketemp, lapid);
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,
"right_front_tyre_temp", simdata->tyretemp[1],
"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);
@ -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)
{
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
@ -1236,9 +1243,9 @@ void* simviewmysql(void* thargs)
int stintid = 0;
int stintlapid = 0;
int sessionid = 0;
sessionid = addsession(conn, eventid, simdata->session, simdata->airtemp, simdata->tracktemp);
stintid = addstint(conn, sessionid, driverid, carid);
stintlapid = addstintlap(conn, stintid);
sessionid = addsession(conn, eventid, carid, simdata->session, simdata->airtemp, simdata->tracktemp, simdata);
stintid = addstint(conn, sessionid, driverid, carid, simdata);
stintlapid = addstintlap(conn, stintid, simdata);
sessionstatus = simdata->session;
lastsessionstatus = sessionstatus;
lap = simdata->lap;
@ -1302,7 +1309,7 @@ void* simviewmysql(void* thargs)
closesession(conn, sessionid);
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;
@ -1319,7 +1326,7 @@ void* simviewmysql(void* thargs)
// close last stint
closestint(conn, stintid, stintlaps, validstintlaps);
stintid = addstint(conn, sessionid, driverid, carid);
stintid = addstint(conn, sessionid, driverid, carid, simdata);
stintlaps = 1;
validstintlaps = 0;
}
@ -1334,7 +1341,7 @@ void* simviewmysql(void* thargs)
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 b = updatetelemetrydata(conn, track_samples, telemid, stintlapid, speeddata, geardata, rpmdata, steerdata, acceldata, brakedata);
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
#define _SESSION_H
#ifndef _HOELDB_H
#define _HOELDB_H
#include <stddef.h>
#include <stdbool.h>
@ -38,6 +38,7 @@ typedef struct SessionRowData
//int duration_min;
//int elapsed_ms;
int laps;
unsigned char track[20];
//char weather[100];
//double air_temp;
//double road_temp;
@ -68,6 +69,7 @@ typedef struct StintRowData
int laps;
int valid_laps;
int best_lap_id;
unsigned char tyre[10];
}
StintRowData;
@ -85,15 +87,15 @@ typedef struct LapRowData
int crashes;
int max_speed;
int avg_speed;
PDBTimeStamp finished_at;
double f_tyre_temp;
double r_tyre_temp;
double f_tyre_wear;
double r_tyre_wear;
double f_tyre_press;
double r_tyre_press;
double f_brake_temp;
double r_brake_temp;
//PDBTimeStamp finished_at;
//double f_tyre_temp;
//double r_tyre_temp;
//double f_tyre_wear;
//double r_tyre_wear;
//double f_tyre_press;
//double r_tyre_press;
//double f_brake_temp;
//double r_brake_temp;
}
LapRowData;
@ -102,7 +104,7 @@ typedef struct SessionDbo
int numrows;
bool hasdata;
DBField fields[4];
DBField fields[5];
SessionRowData* rows;
}
SessionDbo;
@ -122,9 +124,13 @@ typedef struct LapDbo
int numrows;
bool hasdata;
DBField fields[21];
DBField fields[12];
LapRowData* rows;
}
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

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* datadir = create_user_dir(home_dir_str, ".local/share", PROGRAM_NAME);
xdgHandle xdg;
if(!xdgInitHandle(&xdg))
{

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

@ -3,6 +3,7 @@
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include "confighelper.h"
@ -73,8 +74,10 @@ int loadconfig(const char* config_file_str, Parameters* p)
{
slogi("Parsing config file");
if (p->program_action == A_BROWSE)
{
char* gnuplotbin = "/usr/bin/gnuplot";
config_setting_t* config_graph_array = NULL;
config_graph_array = config_lookup(&cfg, "graph");
@ -88,7 +91,22 @@ int loadconfig(const char* config_file_str, Parameters* p)
const char* temp;
config_setting_lookup_string(config_graph, "gnuplotfile", &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)

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

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

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

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