Compare commits
1 Commits
newfeature
...
master
| Author | SHA1 | Date |
|---|---|---|
Paul Dino Jones
|
1bdb72a0ac |
|
|
@ -1,3 +1,6 @@
|
|||
[submodule "src/gilles/simulatorapi/simapi"]
|
||||
path = src/gilles/simulatorapi/simapi
|
||||
url = https://github.com/Spacefreak18/simapi
|
||||
[submodule "src/gilles/GUIslice"]
|
||||
path = src/gilles/GUIslice
|
||||
url = https://github.com/spacefreak18/GUIslice.git
|
||||
|
|
|
|||
10
.valgrindrc
10
.valgrindrc
|
|
@ -1,10 +0,0 @@
|
|||
{
|
||||
argtable arg_parse
|
||||
Memcheck:Leak
|
||||
...
|
||||
...
|
||||
...
|
||||
fun:arg_parse
|
||||
...
|
||||
...
|
||||
}
|
||||
|
|
@ -24,8 +24,7 @@ add_subdirectory(src/gilles/helper)
|
|||
add_subdirectory(src/gilles/slog)
|
||||
|
||||
add_executable(gilles src/gilles/gilles.c)
|
||||
target_link_libraries(gilles xdg-basedir m ncursesw argtable2 config gameloop helper slog simulatorapi eclipse-paho-mqtt-c::paho-mqtt3c pthread hoel jansson)
|
||||
add_compile_definitions(gilles SIMMAP_ALL)
|
||||
target_link_libraries(gilles m ncursesw argtable2 config gameloop helper slog simulatorapi eclipse-paho-mqtt-c::paho-mqtt3c pthread json-c SDL SDL_ttf SDL_gfx)
|
||||
|
||||
# used for enabling additional compiler options if supported
|
||||
include(CheckCXXCompilerFlag)
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
Subproject commit 8899915eff8f390b62af7f1f9d1b26ca820c06ee
|
||||
|
|
@ -1,15 +1,18 @@
|
|||
set(gameloop_source_files
|
||||
gameloop.c
|
||||
gameloop.h
|
||||
browseloop.c
|
||||
browseloop.h
|
||||
hoeldb.h
|
||||
hoeldb.c
|
||||
telemetry.h
|
||||
telemetry.c
|
||||
wheeldash.c
|
||||
wheeldash.h
|
||||
|
||||
../GUIslice/src/GUIslice.c
|
||||
../GUIslice/src/GUIslice.h
|
||||
../GUIslice/src/GUIslice_config.h
|
||||
../GUIslice/src/GUIslice_drv_sdl.h
|
||||
../GUIslice/src/GUIslice_drv_sdl.c
|
||||
)
|
||||
|
||||
|
||||
|
||||
add_library(gameloop STATIC ${gameloop_source_files})
|
||||
|
||||
target_compile_definitions(gameloop PRIVATE SIMMAP_ALL)
|
||||
|
|
|
|||
|
|
@ -1,666 +0,0 @@
|
|||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <ncurses.h>
|
||||
#include <signal.h>
|
||||
#include <time.h>
|
||||
#include <sys/time.h>
|
||||
#include <MQTTClient.h>
|
||||
#include <poll.h>
|
||||
#include <termios.h>
|
||||
#include <hoel.h>
|
||||
#include <jansson.h>
|
||||
|
||||
#include <byteswap.h>
|
||||
|
||||
#include "hoeldb.h"
|
||||
#include "telemetry.h"
|
||||
#include "gameloop.h"
|
||||
#include "../helper/parameters.h"
|
||||
#include "../helper/confighelper.h"
|
||||
#include "../helper/dirhelper.h"
|
||||
#include "../simulatorapi/simapi/simapi/simdata.h"
|
||||
#include "../simulatorapi/simapi/simapi/simmapper.h"
|
||||
#include "../slog/slog.h"
|
||||
|
||||
#define DEFAULT_UPDATE_RATE 60
|
||||
#define DATA_UPDATE_RATE 4
|
||||
|
||||
|
||||
#define SESSIONS_SCREEN 1
|
||||
#define STINTS_SCREEN 2
|
||||
#define LAPS_SCREEN 3
|
||||
|
||||
|
||||
WINDOW* bwin1;
|
||||
WINDOW* bwin2;
|
||||
WINDOW* bwin3;
|
||||
WINDOW* bwin4;
|
||||
|
||||
int bwinx, bwiny;
|
||||
|
||||
char blanks[1000];
|
||||
|
||||
void add_line()
|
||||
{
|
||||
wprintw(bwin1, "\n");
|
||||
for (int j = 0; j < bwiny-1; ++j)
|
||||
{
|
||||
waddch(bwin1, ACS_HLINE);
|
||||
}
|
||||
}
|
||||
|
||||
void set_spaces(int spaces)
|
||||
{
|
||||
blanks[spaces] = '\0';
|
||||
}
|
||||
|
||||
void b_handle_winch(int sig)
|
||||
{
|
||||
endwin();
|
||||
|
||||
refresh();
|
||||
clear();
|
||||
getmaxyx(stdscr, bwinx, bwiny);
|
||||
refresh();
|
||||
}
|
||||
|
||||
|
||||
int b_curses_init()
|
||||
{
|
||||
memset(blanks,' ',sizeof(blanks));
|
||||
initscr();
|
||||
start_color();
|
||||
|
||||
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);
|
||||
|
||||
getmaxyx(stdscr, bwinx, bwiny);
|
||||
slogt("windowx %i, windowy %i", bwinx, bwiny);
|
||||
bwin1 = newwin(bwinx,bwiny,0,0);
|
||||
|
||||
wbkgd(bwin1,COLOR_PAIR(1));
|
||||
wbkgd(bwin2,COLOR_PAIR(1));
|
||||
wbkgd(bwin3,COLOR_PAIR(1));
|
||||
wbkgd(bwin4,COLOR_PAIR(1));
|
||||
|
||||
signal(SIGWINCH, b_handle_winch);
|
||||
curs_set(0);
|
||||
cbreak();
|
||||
noecho();
|
||||
|
||||
box(bwin1, 0, 0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void* browseloop(Parameters* p, char* datadir)
|
||||
{
|
||||
|
||||
struct _h_result result;
|
||||
struct _h_connection* conn;
|
||||
conn = h_connect_pgsql(p->db_conn);
|
||||
|
||||
if (conn == NULL)
|
||||
{
|
||||
slogf("Unable to connect to configured Gilles database. Are the parameters in the config correct? Is the user allowed to access from this address?");
|
||||
p->err = E_FAILED_DB_CONN;
|
||||
return 0;
|
||||
}
|
||||
|
||||
slogt("Starting analyzer");
|
||||
b_curses_init();
|
||||
|
||||
timeout(DEFAULT_UPDATE_RATE);
|
||||
|
||||
SessionDbo sess;
|
||||
DBField sessid;
|
||||
sessid.type = HOEL_COL_TYPE_INT;
|
||||
sessid.offset = 0;
|
||||
sessid.colnum = 0;
|
||||
DBField laps;
|
||||
laps.type = HOEL_COL_TYPE_INT;
|
||||
laps.offset = sizeof(int);
|
||||
laps.offset = offsetof(SessionRowData, laps);
|
||||
laps.colnum = 1;
|
||||
DBField eventid;
|
||||
eventid.type = HOEL_COL_TYPE_INT;
|
||||
eventid.offset = offsetof(SessionRowData, event_id);
|
||||
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)*150;
|
||||
DBField car;
|
||||
car.type = HOEL_COL_TYPE_TEXT;
|
||||
car.offset = offsetof(SessionRowData, car);
|
||||
car.size = sizeof(unsigned char)*150;
|
||||
DBField starttime;
|
||||
starttime.type = HOEL_COL_TYPE_DATE;
|
||||
starttime.offset = offsetof(SessionRowData, start_time);
|
||||
starttime.size = sizeof(PDBTimeStamp);
|
||||
|
||||
//SessionFields sf;
|
||||
sess.fields[0] = sessid;
|
||||
sess.fields[1] = eventid;
|
||||
sess.fields[2] = eventtype;
|
||||
sess.fields[3] = laps;
|
||||
sess.fields[4] = track;
|
||||
sess.fields[5] = car;
|
||||
sess.fields[6] = starttime;
|
||||
//sf.session_id = sessid;
|
||||
//sf.laps = laps;
|
||||
|
||||
//sess.fields = sf;
|
||||
|
||||
|
||||
|
||||
int action = 0;
|
||||
int selection = 1;
|
||||
int lastselection = 1;
|
||||
int selection1 = 0;
|
||||
int selection2 = 0;
|
||||
int sessions = 0;
|
||||
int lapsresults = 0;
|
||||
int curresults = 0;
|
||||
int stintsid = 0;
|
||||
|
||||
StintDbo stints;
|
||||
DBField stintid;
|
||||
stintid.type = HOEL_COL_TYPE_INT;
|
||||
stintid.offset = 0;
|
||||
DBField driverid;
|
||||
driverid.type = HOEL_COL_TYPE_INT;
|
||||
driverid.offset = offsetof(StintRowData, driver_id);
|
||||
DBField teammemberid;
|
||||
teammemberid.type = HOEL_COL_TYPE_INT;
|
||||
teammemberid.offset = offsetof(StintRowData, team_member_id);
|
||||
DBField sessionidstint;
|
||||
sessionidstint.type = HOEL_COL_TYPE_INT;
|
||||
sessionidstint.offset = offsetof(StintRowData, session_id);
|
||||
DBField carid;
|
||||
carid.type = HOEL_COL_TYPE_INT;
|
||||
carid.offset = offsetof(StintRowData, car_id);
|
||||
DBField gamecarid;
|
||||
gamecarid.type = HOEL_COL_TYPE_INT;
|
||||
gamecarid.offset = offsetof(StintRowData, game_car_id);
|
||||
DBField stintlaps;
|
||||
stintlaps.type = HOEL_COL_TYPE_INT;
|
||||
stintlaps.offset = offsetof(StintRowData, laps);
|
||||
DBField validlaps;
|
||||
validlaps.type = HOEL_COL_TYPE_INT;
|
||||
validlaps.offset = offsetof(StintRowData, valid_laps);
|
||||
DBField bestlapid;
|
||||
bestlapid.type = HOEL_COL_TYPE_INT;
|
||||
bestlapid.offset = offsetof(StintRowData, best_lap_id);
|
||||
|
||||
stints.fields[0] = stintid;
|
||||
stints.fields[1] = driverid;
|
||||
stints.fields[2] = teammemberid;
|
||||
stints.fields[3] = sessionidstint;
|
||||
stints.fields[4] = carid;
|
||||
stints.fields[5] = gamecarid;
|
||||
stints.fields[6] = stintlaps;
|
||||
stints.fields[7] = validlaps;
|
||||
stints.fields[8] = bestlapid;
|
||||
|
||||
LapDbo lapsdb;
|
||||
DBField lapsdbid;
|
||||
lapsdbid.type = HOEL_COL_TYPE_INT;
|
||||
lapsdbid.offset = 0;
|
||||
DBField lapsdbstintid;
|
||||
lapsdbstintid.type = HOEL_COL_TYPE_INT;
|
||||
lapsdbstintid.offset = offsetof(LapRowData, stint_id);
|
||||
DBField sector_1;
|
||||
sector_1.type = HOEL_COL_TYPE_INT;
|
||||
sector_1.offset = offsetof(LapRowData, sector_1);
|
||||
DBField sector_2;
|
||||
sector_2.type = HOEL_COL_TYPE_INT;
|
||||
sector_2.offset = offsetof(LapRowData, sector_2);
|
||||
DBField sector_3;
|
||||
sector_3.type = HOEL_COL_TYPE_INT;
|
||||
sector_3.offset = offsetof(LapRowData, sector_3);
|
||||
DBField grip;
|
||||
grip.type = HOEL_COL_TYPE_DOUBLE;
|
||||
grip.offset = offsetof(LapRowData, grip);
|
||||
DBField tyrec;
|
||||
tyrec.type = HOEL_COL_TYPE_TEXT;
|
||||
tyrec.offset = offsetof(LapRowData, tyre);
|
||||
tyrec.size = sizeof(unsigned char)*10;
|
||||
DBField time;
|
||||
time.type = HOEL_COL_TYPE_INT;
|
||||
time.offset = offsetof(LapRowData, time);
|
||||
DBField cuts;
|
||||
cuts.type = HOEL_COL_TYPE_INT;
|
||||
cuts.offset = offsetof(LapRowData, cuts);
|
||||
DBField carcrashes;
|
||||
carcrashes.type = HOEL_COL_TYPE_INT;
|
||||
carcrashes.offset = offsetof(LapRowData, crashes);
|
||||
DBField maxspeed;
|
||||
maxspeed.type = HOEL_COL_TYPE_INT;
|
||||
maxspeed.offset = offsetof(LapRowData, max_speed);
|
||||
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);
|
||||
|
||||
lapsdb.fields[0] = lapsdbid;
|
||||
lapsdb.fields[1] = lapsdbstintid;
|
||||
lapsdb.fields[2] = sector_1;
|
||||
lapsdb.fields[3] = sector_2;
|
||||
lapsdb.fields[4] = sector_3;
|
||||
lapsdb.fields[5] = grip;
|
||||
lapsdb.fields[6] = tyrec;
|
||||
lapsdb.fields[7] = time;
|
||||
lapsdb.fields[8] = cuts;
|
||||
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;
|
||||
|
||||
//slogt("sessions has %i rows", sess.numrows);
|
||||
|
||||
action = 2;
|
||||
|
||||
|
||||
int go = true;
|
||||
char lastsimstatus = false;
|
||||
|
||||
int screen = SESSIONS_SCREEN;
|
||||
char ch;
|
||||
box(bwin1, 0, 0);
|
||||
wrefresh(bwin1);
|
||||
int stint_useid = 0;
|
||||
int lap_useid = 0;
|
||||
while (go == true)
|
||||
{
|
||||
|
||||
if (lastselection != selection)
|
||||
{
|
||||
action = 1;
|
||||
lastselection = selection;
|
||||
}
|
||||
|
||||
if (action == 2)
|
||||
{
|
||||
slogt("going to perform an action");
|
||||
int err = E_NO_ERROR;
|
||||
sessions = getsessions(conn, "Sessions", &sess);
|
||||
if (sessions < 0)
|
||||
{
|
||||
go = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
curresults = sessions;
|
||||
}
|
||||
}
|
||||
|
||||
if (action == 3)
|
||||
{
|
||||
slogt("going to perform an action");
|
||||
|
||||
int err = E_NO_ERROR;
|
||||
stintsid = getstints(conn, "Stints", &stints, stint_useid);
|
||||
curresults = stintsid;
|
||||
if (stintsid < 0)
|
||||
{
|
||||
go = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
curresults = stintsid;
|
||||
}
|
||||
}
|
||||
if (action == 4)
|
||||
{
|
||||
slogt("going to perform an action");
|
||||
|
||||
int err = E_NO_ERROR;
|
||||
lapsresults = getlaps(conn, "laps", &lapsdb, lap_useid);
|
||||
slogt("laps query executed");
|
||||
curresults = lapsresults;
|
||||
if (lapsresults < 0)
|
||||
{
|
||||
go = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
curresults = lapsresults;
|
||||
}
|
||||
}
|
||||
|
||||
if (action > 0)
|
||||
{
|
||||
wclear(bwin1);
|
||||
|
||||
switch(screen)
|
||||
{
|
||||
case SESSIONS_SCREEN:
|
||||
|
||||
|
||||
for(int i=0; i<sessions+1; i++)
|
||||
{
|
||||
int displaycolumns = 6;
|
||||
int width1 = displaycolumns + 1;
|
||||
int width2 = displaycolumns * 2;
|
||||
|
||||
if (i == 0)
|
||||
{
|
||||
|
||||
wattrset(bwin1, COLOR_PAIR(2));
|
||||
wattron(bwin1, A_BOLD);
|
||||
mvwaddnstr(bwin1, 2, bwiny/2, "Sessions", -1);
|
||||
mvwaddnstr(bwin1, 3, bwiny/width2, "idx", -1);
|
||||
mvwaddnstr(bwin1, 3, bwiny/width1+bwiny/width2, "name", -1);
|
||||
mvwaddnstr(bwin1, 3, ((bwiny/width1)*2)+bwiny/width2, "track", -1);
|
||||
mvwaddnstr(bwin1, 3, ((bwiny/width1)*3)+bwiny/width2, "car", -1);
|
||||
mvwaddnstr(bwin1, 3, ((bwiny/width1)*4)+bwiny/width2, "stints", -1);
|
||||
mvwaddnstr(bwin1, 3, ((bwiny/width1)*5)+bwiny/width2, "time", -1);
|
||||
mvwhline(bwin1, 4, 0, 0, bwiny);
|
||||
wattroff(bwin1, A_BOLD);
|
||||
wattrset(bwin1, COLOR_PAIR(1));
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
if ( i == selection )
|
||||
{
|
||||
wattrset(bwin1, COLOR_PAIR(5));
|
||||
stint_useid = sess.rows[i-1].session_id;
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/width2, " * ", 3);
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/6, " ", 3);
|
||||
}
|
||||
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);
|
||||
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/width2+2, idchar, -1);
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/width2+bwiny/width1, "my session name", -1);
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/width2+((bwiny/width1)*2), sess.rows[i-1].track, -1);
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/width2+((bwiny/width1)*3), sess.rows[i-1].car, -1);
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/width2+((bwiny/width1)*4), lapschar, -1);
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/width2+((bwiny/width1)*5), sess.rows[i-1].start_time, -1);
|
||||
}
|
||||
wattrset(bwin1, COLOR_PAIR(1));
|
||||
}
|
||||
break;
|
||||
case STINTS_SCREEN:
|
||||
if (stintsid == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
for(int i=0; i<stintsid+1; i++)
|
||||
{
|
||||
if (i == 0)
|
||||
{
|
||||
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
|
||||
{
|
||||
|
||||
if ( i == selection )
|
||||
{
|
||||
wattrset(bwin1, COLOR_PAIR(5));
|
||||
lap_useid = stints.rows[i-1].stint_id;
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/6, " * ", 3);
|
||||
}
|
||||
else
|
||||
{
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/6, " ", 3);
|
||||
}
|
||||
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);
|
||||
|
||||
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;
|
||||
case LAPS_SCREEN:
|
||||
if (lapsresults == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
for(int i=0; i<lapsresults+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);
|
||||
mvwaddnstr(bwin1, 2, bwiny/2, "Laps", -1);
|
||||
mvwaddnstr(bwin1, 3, bwiny/width2, "idx", -1);
|
||||
mvwaddnstr(bwin1, 3, bwiny/width1+bwiny/width2, "name", -1);
|
||||
mvwaddnstr(bwin1, 3, ((bwiny/width1)*2)+bwiny/width2, "tyre", -1);
|
||||
mvwaddnstr(bwin1, 3, ((bwiny/width1)*3)+bwiny/width2, "maxspeed", -1);
|
||||
mvwhline(bwin1, 4, 0, 0, bwiny);
|
||||
wattroff(bwin1, A_BOLD);
|
||||
wattrset(bwin1, COLOR_PAIR(1));
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
//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 )
|
||||
{
|
||||
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/7 - 4, " 2 ", 3);
|
||||
}
|
||||
if ( i == selection )
|
||||
{
|
||||
wattrset(bwin1, COLOR_PAIR(5));
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/7, " * ", 3);
|
||||
}
|
||||
else
|
||||
{
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/7, " ", 3);
|
||||
|
||||
}
|
||||
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);
|
||||
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/width2+2, idchar, -1);
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/width2+bwiny/width1, "my session name", -1);
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/width2+((bwiny/width1)*2), lapsdb.rows[i-1].tyre, -1);
|
||||
mvwaddnstr(bwin1, 4+i, bwiny/width2+((bwiny/width1)*3), maxspeedchar, -1);
|
||||
}
|
||||
wattrset(bwin1, COLOR_PAIR(1));
|
||||
|
||||
}
|
||||
break;
|
||||
}
|
||||
action = 0;
|
||||
}
|
||||
|
||||
box(bwin1, 0, 0);
|
||||
wrefresh(bwin1);
|
||||
|
||||
scanf("%c", &ch);
|
||||
if(ch == 'q')
|
||||
{
|
||||
go = false;
|
||||
}
|
||||
if (ch == 'b')
|
||||
{
|
||||
switch(screen)
|
||||
{
|
||||
|
||||
case STINTS_SCREEN:
|
||||
action = 2;
|
||||
screen = SESSIONS_SCREEN;
|
||||
|
||||
|
||||
break;
|
||||
case LAPS_SCREEN:
|
||||
action = 3;
|
||||
screen = STINTS_SCREEN;
|
||||
break;
|
||||
}
|
||||
selection = 1;
|
||||
lastselection = 1;
|
||||
}
|
||||
if (ch == 'e')
|
||||
{
|
||||
switch(screen)
|
||||
{
|
||||
|
||||
case SESSIONS_SCREEN:
|
||||
action = 3;
|
||||
screen = STINTS_SCREEN;
|
||||
|
||||
|
||||
break;
|
||||
case STINTS_SCREEN:
|
||||
action = 4;
|
||||
screen = LAPS_SCREEN;
|
||||
break;
|
||||
}
|
||||
|
||||
selection = 1;
|
||||
lastselection = 1;
|
||||
}
|
||||
if (ch == 'g')
|
||||
{
|
||||
//selection1 = 363;
|
||||
//selection2 = 362;
|
||||
if (p->gnuplotfound == 1)
|
||||
{
|
||||
if (selection1 > 0 && selection2 > 0)
|
||||
{
|
||||
dumptelemetrytofile(conn, datadir, selection1, selection2);
|
||||
|
||||
slogi("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' || ch == 'l')
|
||||
{
|
||||
selection++;
|
||||
if (selection > curresults)
|
||||
{
|
||||
selection = curresults;
|
||||
}
|
||||
}
|
||||
if (ch == 'A' || ch == 'k')
|
||||
{
|
||||
selection--;
|
||||
if (selection <= 1)
|
||||
{
|
||||
selection = 1;
|
||||
}
|
||||
}
|
||||
if (ch == '1')
|
||||
{
|
||||
selection1 = lapsdb.rows[selection-1].lap_id;
|
||||
action = 1;
|
||||
}
|
||||
if (ch == '2')
|
||||
{
|
||||
selection2 = lapsdb.rows[selection-1].lap_id;
|
||||
action = 1;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
wrefresh(bwin1);
|
||||
delwin(bwin1);
|
||||
endwin();
|
||||
|
||||
h_close_db(conn);
|
||||
h_clean_connection(conn);
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
#include "../helper/parameters.h"
|
||||
#include "../helper/confighelper.h"
|
||||
|
||||
int browseloop(Parameters* p, char* datadir);
|
||||
|
|
@ -1,32 +1,22 @@
|
|||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <ncurses.h>
|
||||
#include <signal.h>
|
||||
#include <time.h>
|
||||
#include <sys/time.h>
|
||||
#include <MQTTClient.h>
|
||||
#include <poll.h>
|
||||
#include <termios.h>
|
||||
#include <hoel.h>
|
||||
#include <jansson.h>
|
||||
|
||||
#include "hoeldb.h"
|
||||
#include "telemetry.h"
|
||||
#include "gameloop.h"
|
||||
#include "../helper/parameters.h"
|
||||
#include "../helper/confighelper.h"
|
||||
#include "../helper/dirhelper.h"
|
||||
#include "../simulatorapi/simapi/simapi/simdata.h"
|
||||
#include "../simulatorapi/simapi/simapi/simmapper.h"
|
||||
#include "../slog/slog.h"
|
||||
|
||||
#define DEFAULT_UPDATE_RATE 60
|
||||
#define DATA_UPDATE_RATE 32
|
||||
#define TRACK_SAMPLE_RATE 4
|
||||
#define SIM_CHECK_RATE 1
|
||||
#include <json-c/json.h>
|
||||
|
||||
#define DEFAULT_UPDATE_RATE 100
|
||||
|
||||
#define ADDRESS "tcp://localhost:1883"
|
||||
#define CLIENTID "gilles"
|
||||
|
|
@ -135,171 +125,18 @@ void update_date()
|
|||
sprintf(datestring, "%.24s", asctime (timeinfo));
|
||||
}
|
||||
|
||||
|
||||
int mainloop(Parameters* p)
|
||||
{
|
||||
pthread_t ui_thread;
|
||||
pthread_t mqtt_thread;
|
||||
pthread_t mysql_thread;
|
||||
|
||||
SimData* simdata = malloc(sizeof(SimData));
|
||||
SimMap* simmap = malloc(sizeof(SimMap));
|
||||
|
||||
struct termios newsettings, canonicalmode;
|
||||
tcgetattr(0, &canonicalmode);
|
||||
newsettings = canonicalmode;
|
||||
newsettings.c_lflag &= (~ICANON & ~ECHO);
|
||||
newsettings.c_cc[VMIN] = 1;
|
||||
newsettings.c_cc[VTIME] = 0;
|
||||
tcsetattr(0, TCSANOW, &newsettings);
|
||||
char ch;
|
||||
struct pollfd mypoll = { STDIN_FILENO, POLLIN|POLLPRI };
|
||||
|
||||
p->simdata = simdata;
|
||||
p->simmap = simmap;
|
||||
fprintf(stdout, "Searching for sim data... Press q to quit...\n");
|
||||
|
||||
double update_rate = SIM_CHECK_RATE;
|
||||
int go = true;
|
||||
char lastsimstatus = false;
|
||||
while (go == true)
|
||||
{
|
||||
|
||||
getSim(simdata, simmap, &p->simon, &p->sim);
|
||||
|
||||
if (p->simon == true && simdata->simstatus > 1)
|
||||
{
|
||||
p->program_state = 1;
|
||||
if (p->cli == true)
|
||||
{
|
||||
if (pthread_create(&ui_thread, NULL, &clilooper, p) != 0)
|
||||
{
|
||||
printf("Uh-oh!\n");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (pthread_create(&ui_thread, NULL, &looper, p) != 0)
|
||||
{
|
||||
printf("Uh-oh!\n");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
//if (p->mqtt == true)
|
||||
//{
|
||||
// if (pthread_create(&mqtt_thread, NULL, &b4madmqtt, p) != 0)
|
||||
// {
|
||||
// printf("Uh-oh!\n");
|
||||
// return -1;
|
||||
// }
|
||||
//}
|
||||
if (p->mysql == true)
|
||||
{
|
||||
if (pthread_create(&mysql_thread, NULL, &simviewmysql, p) != 0)
|
||||
{
|
||||
printf("Uh-oh!\n");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
pthread_join(ui_thread, NULL);
|
||||
p->program_state = -1;
|
||||
//if (p->mqtt == true)
|
||||
//{
|
||||
// pthread_join(mqtt_thread, NULL);
|
||||
//}
|
||||
if (p->mysql == true)
|
||||
{
|
||||
pthread_join(mysql_thread, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
if (p->simon == true)
|
||||
{
|
||||
p->simon = false;
|
||||
fprintf(stdout, "Searching for sim data... Press q again to quit...\n");
|
||||
sleep(2);
|
||||
}
|
||||
|
||||
if( poll(&mypoll, 1, 1000.0/update_rate) )
|
||||
{
|
||||
scanf("%c", &ch);
|
||||
if(ch == 'q')
|
||||
{
|
||||
go = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(stdout, "\n");
|
||||
fflush(stdout);
|
||||
tcsetattr(0, TCSANOW, &canonicalmode);
|
||||
|
||||
free(simdata);
|
||||
free(simmap);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void* clilooper(void* thargs)
|
||||
{
|
||||
Parameters* p = (Parameters*) thargs;
|
||||
SimData* simdata = p->simdata;
|
||||
SimMap* simmap = p->simmap;
|
||||
|
||||
struct termios newsettings, canonicalmode;
|
||||
tcgetattr(0, &canonicalmode);
|
||||
newsettings = canonicalmode;
|
||||
newsettings.c_lflag &= (~ICANON & ~ECHO);
|
||||
newsettings.c_cc[VMIN] = 1;
|
||||
newsettings.c_cc[VTIME] = 0;
|
||||
tcsetattr(0, TCSANOW, &newsettings);
|
||||
char ch;
|
||||
struct pollfd mypoll = { STDIN_FILENO, POLLIN|POLLPRI };
|
||||
|
||||
fprintf(stdout, "Press q to quit...\n");
|
||||
fprintf(stdout, "Press c for a useful readout of car telemetry...\n");
|
||||
fprintf(stdout, "Press s for basic sesion information...\n");
|
||||
fprintf(stdout, "Press l for basic lap / stint information...\n");
|
||||
|
||||
double update_rate = DEFAULT_UPDATE_RATE;
|
||||
int go = true;
|
||||
char lastsimstatus = false;
|
||||
while (go == true && simdata->simstatus > 1)
|
||||
{
|
||||
simdatamap(simdata, simmap, p->sim);
|
||||
|
||||
if( poll(&mypoll, 1, 1000.0/update_rate) )
|
||||
{
|
||||
scanf("%c", &ch);
|
||||
if(ch == 'q')
|
||||
{
|
||||
go = false;
|
||||
}
|
||||
if(ch == 'c')
|
||||
{
|
||||
slogi("speed: %i gear: %i", simdata->velocity, simdata->gear);
|
||||
}
|
||||
if(ch == 's')
|
||||
{
|
||||
slogi("status: %i", simdata->simstatus);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(stdout, "\n");
|
||||
fflush(stdout);
|
||||
tcsetattr(0, TCSANOW, &canonicalmode);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void* looper(void* thargs)
|
||||
{
|
||||
Parameters* p = (Parameters*) thargs;
|
||||
SimData* simdata = p->simdata;
|
||||
SimMap* simmap = p->simmap;
|
||||
SimData* simdata = malloc(sizeof(SimData));
|
||||
SimMap* simmap = malloc(sizeof(SimMap));
|
||||
|
||||
int error = siminit(simdata, simmap, 1);
|
||||
if (error != GILLES_ERROR_NONE)
|
||||
{
|
||||
slogf("Fatal error getting simulator data");
|
||||
//return error;
|
||||
}
|
||||
|
||||
curses_init();
|
||||
|
||||
|
|
@ -307,17 +144,16 @@ void* looper(void* thargs)
|
|||
|
||||
int go = true;
|
||||
char lastsimstatus = false;
|
||||
while (go == true && simdata->simstatus > 1)
|
||||
while (go == true)
|
||||
{
|
||||
simdatamap(simdata, simmap, p->sim);
|
||||
simdatamap(simdata, simmap, 1);
|
||||
|
||||
wclear(win1);
|
||||
wclear(win2);
|
||||
wclear(win3);
|
||||
wclear(win4);
|
||||
|
||||
{
|
||||
// window 1 car diagnostics
|
||||
{ // window 1 car diagnostics
|
||||
|
||||
char spacer[14];
|
||||
sprintf(spacer, "\n");
|
||||
|
|
@ -472,8 +308,7 @@ void* looper(void* thargs)
|
|||
rectangle(18, 18, 22, 22); // right rear
|
||||
}
|
||||
|
||||
{
|
||||
// window 2 session info
|
||||
{ // window 2 session info
|
||||
|
||||
char spacer[14];
|
||||
sprintf(spacer, "\n");
|
||||
|
|
@ -536,8 +371,7 @@ void* looper(void* thargs)
|
|||
wattrset(win2, COLOR_PAIR(1));
|
||||
}
|
||||
|
||||
{
|
||||
// window 3 basic timing and scoring
|
||||
{ // window 3 basic timing and scoring
|
||||
|
||||
char spacer[14];
|
||||
sprintf(spacer, "\n");
|
||||
|
|
@ -602,8 +436,7 @@ void* looper(void* thargs)
|
|||
wattrset(win3, COLOR_PAIR(1));
|
||||
}
|
||||
|
||||
{
|
||||
// window 4 live standings timing and scoring
|
||||
{ // window 4 live standings timing and scoring
|
||||
char spacer[14];
|
||||
sprintf(spacer, "\n");
|
||||
waddstr(win4, spacer);
|
||||
|
|
@ -638,10 +471,8 @@ void* looper(void* thargs)
|
|||
for(i=0; i<displaycars; i++)
|
||||
{
|
||||
if((ihold+1)==simdata->cars[i].pos)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
wattrset(win4, COLOR_PAIR(2));
|
||||
int maxstrlen = 20;
|
||||
|
|
@ -722,191 +553,159 @@ void* looper(void* thargs)
|
|||
delwin(win1);
|
||||
endwin();
|
||||
|
||||
free(simdata);
|
||||
free(simmap);
|
||||
|
||||
//return 0;
|
||||
}
|
||||
|
||||
void* simviewmysql(void* thargs)
|
||||
void* b4madmqtt(void* thargs)
|
||||
{
|
||||
Parameters* p = (Parameters*) thargs;
|
||||
SimData* simdata = p->simdata;
|
||||
SimMap* simmap = p->simmap;
|
||||
SimData* simdata = malloc(sizeof(SimData));
|
||||
SimMap* simmap = malloc(sizeof(SimMap));
|
||||
long unix_time_start;
|
||||
char time_buff[11];
|
||||
|
||||
struct _h_result result;
|
||||
struct _h_connection* conn;
|
||||
conn = h_connect_pgsql(p->db_conn);
|
||||
|
||||
if (conn == NULL)
|
||||
int error = siminit(simdata, simmap, 1);
|
||||
if (error != GILLES_ERROR_NONE)
|
||||
{
|
||||
slogf("Unable to connect to configured Gilles database. Are the parameters in the config correct? Is the user allowed to access from this address?");
|
||||
p->err = E_FAILED_DB_CONN;
|
||||
return 0;
|
||||
}
|
||||
slogi("Starting telemetry");
|
||||
|
||||
int trackconfig = gettrack(conn, simdata->track);
|
||||
if (trackconfig == -1)
|
||||
{
|
||||
slogf("Problem performing select query. Does the db user have read permissions?");
|
||||
p->err = E_FAILED_DB_CONN;
|
||||
return 0;
|
||||
slogf("Fatal error getting simulator data");
|
||||
//return error;
|
||||
}
|
||||
|
||||
trackconfig = addtrackconfig(conn, trackconfig, simdata->track, simdata->trackdistancearound);
|
||||
if (trackconfig == -1)
|
||||
bool mqtt = p->mqtt;
|
||||
bool mqtt_connected = false;
|
||||
|
||||
MQTTClient client;
|
||||
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
|
||||
MQTTClient_message pubmsg = MQTTClient_message_initializer;
|
||||
MQTTClient_deliveryToken token;
|
||||
int rc;
|
||||
|
||||
// Create a new MQTT client
|
||||
MQTTClient_create(&client, ADDRESS, CLIENTID,
|
||||
MQTTCLIENT_PERSISTENCE_NONE, NULL);
|
||||
|
||||
// Connect to the MQTT server
|
||||
if (mqtt == true)
|
||||
{
|
||||
slogf("Problem performing insert query. Does the db user have write permissions?");
|
||||
p->err = E_FAILED_DB_CONN;
|
||||
return 0;
|
||||
conn_opts.keepAliveInterval = 20;
|
||||
conn_opts.cleansession = 1;
|
||||
if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS) {
|
||||
MQTTClient_disconnect(client, 10000);
|
||||
sloge("Failed to connect, return code %d", rc);
|
||||
return NULL;
|
||||
//exit(-1);
|
||||
}
|
||||
mqtt_connected = true;
|
||||
}
|
||||
slogt("Detected track configuration id: %i", trackconfig);
|
||||
int eventid = addevent(conn, trackconfig);
|
||||
int driverid = getdriver(conn, simdata->driver);
|
||||
driverid = adddriver(conn, driverid, simdata->driver);
|
||||
int carid = getcar(conn, simdata->car);
|
||||
carid = addcar(conn, carid, simdata->car);
|
||||
|
||||
// ?? close last session
|
||||
|
||||
int pitstatus = simdata->inpit;
|
||||
int sessionstatus = 0;
|
||||
int lastpitstatus = pitstatus;
|
||||
int lastsessionstatus = 0;
|
||||
int lap = 0;
|
||||
int lastlap = 0;
|
||||
int sector = 0;
|
||||
int lastsector = 0;
|
||||
|
||||
int stintid = 0;
|
||||
int stintlapid = 0;
|
||||
int sessionid = 0;
|
||||
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;
|
||||
lastlap = lap;
|
||||
double update_rate = DATA_UPDATE_RATE;
|
||||
struct pollfd mypoll = { STDIN_FILENO, POLLIN|POLLPRI };
|
||||
int go = true;
|
||||
int go = false;
|
||||
if (mqtt_connected == true)
|
||||
{
|
||||
go = true;
|
||||
}
|
||||
char lastsimstatus = false;
|
||||
int tick = 0;
|
||||
|
||||
|
||||
int track_samples = simdata->trackspline / TRACK_SAMPLE_RATE;
|
||||
slogt("track samples %i", track_samples);
|
||||
|
||||
int stintlaps = 1;
|
||||
int validstintlaps = 0;
|
||||
bool validind = true;
|
||||
|
||||
int* speeddata = malloc(track_samples * sizeof(simdata->velocity));
|
||||
int* rpmdata = malloc(track_samples * sizeof(simdata->rpms));
|
||||
int* geardata = malloc(track_samples * sizeof(simdata->gear));
|
||||
double* steerdata = malloc(track_samples * sizeof(simdata->steer));
|
||||
double* acceldata = malloc(track_samples * sizeof(simdata->gas));
|
||||
double* brakedata = malloc(track_samples * sizeof(simdata->brake));
|
||||
|
||||
int sectortimes[4];
|
||||
|
||||
if (p->program_state < 0)
|
||||
{
|
||||
go = false;
|
||||
}
|
||||
|
||||
while (go == true)
|
||||
while (go == true && p->program_state == 1)
|
||||
{
|
||||
|
||||
slogt("tick %i", tick);
|
||||
int pos = (int) track_samples * simdata->playerspline;
|
||||
slogt("pos %f normpos %i of samples %i", simdata->playerspline, pos, track_samples);
|
||||
|
||||
steerdata[pos] = simdata->steer;
|
||||
acceldata[pos] = simdata->gas;
|
||||
brakedata[pos] = simdata->brake;
|
||||
speeddata[pos] = simdata->velocity;
|
||||
rpmdata[pos] = simdata->rpms;
|
||||
geardata[pos] = simdata->gear;
|
||||
|
||||
|
||||
|
||||
|
||||
sessionstatus = simdata->session;
|
||||
lap = simdata->lap;
|
||||
sector = simdata->sectorindex;
|
||||
if (simdata->lapisvalid == false && validind == true)
|
||||
char simstatus = (simdata->simstatus > 0) ? true : false;
|
||||
if (simdata->simstatus > 0 && simstatus != lastsimstatus)
|
||||
{
|
||||
validind = false;
|
||||
//update_date();
|
||||
unix_time_start = (unsigned long) time(NULL);
|
||||
sprintf(time_buff, "%lu", unix_time_start);
|
||||
//sprintf(time_buff, "%lu", (unsigned long)time(NULL));
|
||||
//newdatestring = removeSpacesFromStr(datestring);
|
||||
}
|
||||
sectortimes[simdata->sectorindex] = simdata->lastsectorinms;
|
||||
if (sessionstatus != lastsessionstatus)
|
||||
lastsimstatus = simstatus;
|
||||
simdatamap(simdata, simmap, 1);
|
||||
|
||||
if (mqtt_connected == true && simdata->simstatus > 0)
|
||||
{
|
||||
closestint(conn, stintid, stintlaps, validstintlaps);
|
||||
closesession(conn, sessionid);
|
||||
if (sessionstatus > 1)
|
||||
|
||||
json_object *root = json_object_new_object();
|
||||
//if (!root)
|
||||
// return;
|
||||
|
||||
json_object *child = json_object_new_object();
|
||||
|
||||
struct timeval tv;
|
||||
gettimeofday(&tv, NULL);
|
||||
unsigned long long millisecondsSinceEpoch = (unsigned long long)(tv.tv_sec) * 1000 + (unsigned long long)(tv.tv_usec) / 1000;
|
||||
|
||||
json_object_object_add(root, "time", json_object_new_int64(millisecondsSinceEpoch)); //unix time milliseconds
|
||||
|
||||
const char* topic_root = "racing/gilles/TuxRacerX";
|
||||
//const char* game_name = "Assetto Corsa (64 bit)";
|
||||
const char* game_name = "assetto_64_bit";
|
||||
const char* session_type = "Practice";
|
||||
|
||||
json_object_object_add(child, "CarModel", json_object_new_string(simdata->car));
|
||||
json_object_object_add(child, "GameName", json_object_new_string(game_name));
|
||||
json_object_object_add(child, "SessionId", json_object_new_int(unix_time_start));
|
||||
json_object_object_add(child, "SessionTypeName", json_object_new_string("Practice"));
|
||||
json_object_object_add(child, "TrackCode", json_object_new_string(simdata->track));
|
||||
|
||||
json_object_object_add(child, "Clutch", json_object_new_double(simdata->clutch));
|
||||
json_object_object_add(child, "Brake", json_object_new_double(simdata->brake));
|
||||
json_object_object_add(child, "Throtte", json_object_new_double(simdata->gas));
|
||||
json_object_object_add(child, "HandBrake", json_object_new_double(simdata->handbrake));
|
||||
json_object_object_add(child, "SteeringAngle", json_object_new_double(simdata->steer));
|
||||
json_object_object_add(child, "Rpms", json_object_new_int(simdata->rpms));
|
||||
json_object_object_add(child, "Gear", json_object_new_int(simdata->gear));
|
||||
json_object_object_add(child, "SpeedMs", json_object_new_double(simdata->velocity * 0.2777778));
|
||||
json_object_object_add(child, "DistanceRoundTrack", json_object_new_double(simdata->trackdistancearound));
|
||||
json_object_object_add(child, "WorldPosition_x", json_object_new_double(simdata->worldposx));
|
||||
json_object_object_add(child, "WorldPosition_y", json_object_new_double(simdata->worldposy));
|
||||
json_object_object_add(child, "WorldPosition_z", json_object_new_double(simdata->worldposz));
|
||||
json_object_object_add(child, "CurrentLap", json_object_new_int(simdata->playerlaps));
|
||||
json_object_object_add(child, "CurrentLapTime", json_object_new_int(simdata->currentlapinseconds));
|
||||
json_object_object_add(child, "LapTimePrevious", json_object_new_int(simdata->lastlapinseconds));
|
||||
json_object_object_add(child, "CurrentLapIsValid", json_object_new_int(simdata->lapisvalid));
|
||||
json_object_object_add(child, "PreviousLapWasValid", json_object_new_int(1));
|
||||
|
||||
json_object_object_add(root, "telemetry", child);
|
||||
|
||||
slogi(json_object_to_json_string_ext(root, JSON_C_TO_STRING_PRETTY));
|
||||
|
||||
// TODO: generate this topic string only once
|
||||
char* topic = ( char* ) malloc(1 + strlen(topic_root) + strlen("/") + strlen(game_name) + strlen("/") + strlen(session_type)
|
||||
+ strlen("/") + strlen(simdata->car) + strlen("/") + strlen(simdata->track) + strlen("/") + 11);
|
||||
strcpy(topic, topic_root);
|
||||
strcat(topic, "/");
|
||||
strcat(topic, time_buff);
|
||||
strcat(topic, "/");
|
||||
strcat(topic, game_name);
|
||||
strcat(topic, "/");
|
||||
strcat(topic, simdata->track);
|
||||
strcat(topic, "/");
|
||||
strcat(topic, simdata->car);
|
||||
strcat(topic, "/");
|
||||
strcat(topic, session_type);
|
||||
|
||||
char* payload1;
|
||||
sprintf(payload1, json_object_to_json_string_ext(root, JSON_C_TO_STRING_PRETTY));
|
||||
pubmsg.payload = payload1;
|
||||
//pubmsg.payload = json_object_to_json_string_ext(root, JSON_C_TO_STRING_PRETTY);
|
||||
//pubmsg.payloadlen = strlen(json_object_to_json_string_ext(root, JSON_C_TO_STRING_PRETTY));
|
||||
pubmsg.payloadlen = strlen(payload1);
|
||||
pubmsg.qos= QOS;
|
||||
pubmsg.retained = 0;
|
||||
|
||||
MQTTClient_publishMessage(client, topic, &pubmsg, &token);
|
||||
}
|
||||
|
||||
}
|
||||
if (mqtt_connected == true)
|
||||
{
|
||||
sessionid = addsession(conn, eventid, carid, simdata->session, simdata->airtemp, simdata->tracktemp, simdata);
|
||||
MQTTClient_disconnect(client, 10000);
|
||||
}
|
||||
MQTTClient_destroy(&client);
|
||||
|
||||
//pitstatus = 1;
|
||||
stintlaps = 1;
|
||||
validstintlaps = 0;
|
||||
}
|
||||
pitstatus = simdata->inpit;
|
||||
if (simdata->inpit == true && pitstatus != lastpitstatus)
|
||||
{
|
||||
//pitstatus = 1;
|
||||
//}
|
||||
//if (pitstatus = 0 && pitstatus != lastpitstatus)
|
||||
//{
|
||||
// close last stint
|
||||
|
||||
closestint(conn, stintid, stintlaps, validstintlaps);
|
||||
stintid = addstint(conn, sessionid, driverid, carid, simdata);
|
||||
stintlaps = 1;
|
||||
validstintlaps = 0;
|
||||
}
|
||||
if (lap != lastlap)
|
||||
{
|
||||
slogt("New lap detected");
|
||||
stintlaps++;
|
||||
if (validind == true)
|
||||
{
|
||||
validstintlaps++;
|
||||
}
|
||||
|
||||
closelap(conn, stintlapid, sectortimes[1], sectortimes[2], simdata->lastsectorinms, 0, 0, 0, 0, simdata);
|
||||
|
||||
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;
|
||||
// assume lap is valid until it isn't
|
||||
validind = true;
|
||||
}
|
||||
|
||||
lastpitstatus = pitstatus;
|
||||
lastsessionstatus = sessionstatus;
|
||||
lastsector = sector;
|
||||
lastlap = lap;
|
||||
tick++;
|
||||
|
||||
|
||||
poll(&mypoll, 1, 1000 / DATA_UPDATE_RATE);
|
||||
|
||||
if (p->program_state < 0)
|
||||
{
|
||||
int telemid = addtelemetry(conn, track_samples, stintlapid);
|
||||
int b = updatetelemetrydata(conn, track_samples, telemid, stintlapid, speeddata, geardata, rpmdata, steerdata, acceldata, brakedata);
|
||||
closelap(conn, stintlapid, sectortimes[1], sectortimes[2], simdata->lastsectorinms, 0, 0, 0, 0, simdata);
|
||||
closestint(conn, stintid, stintlaps, validstintlaps);
|
||||
closesession(conn, sessionid);
|
||||
go = false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
h_close_db(conn);
|
||||
h_clean_connection(conn);
|
||||
free(simdata);
|
||||
free(simmap);
|
||||
return NULL;
|
||||
//return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,8 +1,5 @@
|
|||
#include "../helper/parameters.h"
|
||||
#include "../helper/confighelper.h"
|
||||
|
||||
int mainloop(Parameters* p);
|
||||
void* clilooper(void* params);
|
||||
void* looper(void* params);
|
||||
void* b4madmqtt(void* params);
|
||||
void* simviewmysql(void* params);
|
||||
|
|
|
|||
|
|
@ -1,676 +0,0 @@
|
|||
#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 "../simulatorapi/simapi/simapi/simdata.h"
|
||||
#include "../helper/confighelper.h"
|
||||
#include "../slog/slog.h"
|
||||
|
||||
int getLastInsertID(struct _h_connection* conn)
|
||||
{
|
||||
json_t* last_id = (h_last_insert_id(conn));
|
||||
int id = json_integer_value(last_id);
|
||||
json_decref(last_id);
|
||||
return id;
|
||||
}
|
||||
|
||||
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, const char* sessionname, SessionDbo* sess)
|
||||
{
|
||||
struct _h_result result;
|
||||
struct _h_data* data;
|
||||
char* query = malloc(515 * sizeof(char));
|
||||
slogt("Performing query sessions");
|
||||
|
||||
sprintf(query, "select sessions.session_id, events.event_id, sessions.event_type, table1.stints, track_config.display_name, cars.car_name, start_time "
|
||||
"FROM %s JOIN events ON sessions.event_id=events.event_id JOIN track_config ON events.track_config_id=track_config.track_config_id "
|
||||
"JOIN cars ON sessions.car_id=cars.car_id "
|
||||
"JOIN (Select session_id, COUNT(stint_id) AS stints FROM stints GROUP BY session_id) AS table1 ON table1.session_id=sessions.session_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));
|
||||
h_clean_result(&result);
|
||||
}
|
||||
else
|
||||
{
|
||||
sloge("Error executing query %s returned %i", query, errcode);
|
||||
free(query);
|
||||
return -1;
|
||||
}
|
||||
free(query);
|
||||
|
||||
return result.nb_rows;
|
||||
}
|
||||
|
||||
int getstints(struct _h_connection* conn, const char* sessionname, StintDbo* stint, int use_id)
|
||||
{
|
||||
struct _h_result result;
|
||||
struct _h_data* data;
|
||||
char* query = malloc(150 * sizeof(char));
|
||||
slogt("Performing query stints");
|
||||
|
||||
|
||||
sprintf(query, "select stint_id, driver_id, team_member_id, session_id, car_id, game_car_id, laps, valid_laps, best_lap_id FROM %s WHERE session_id=%i", "Stints", use_id);
|
||||
slogt("execute query %s", query);
|
||||
int errcode = h_query_select(conn, query, &result);
|
||||
if (errcode == H_OK)
|
||||
{
|
||||
stint->rows = malloc(sizeof(StintRowData) * result.nb_rows);
|
||||
get_row_results(result, stint->fields, stint->rows, sizeof(StintRowData));
|
||||
h_clean_result(&result);
|
||||
}
|
||||
else
|
||||
{
|
||||
sloge("Error executing query %s returned %i", query, errcode);
|
||||
free(query);
|
||||
return -1;
|
||||
}
|
||||
free(query);
|
||||
|
||||
return result.nb_rows;
|
||||
}
|
||||
|
||||
int getlaps(struct _h_connection* conn, const char* sessionname, LapDbo* laps, int use_id)
|
||||
{
|
||||
struct _h_result result;
|
||||
struct _h_data* data;
|
||||
char* query = malloc(250 * sizeof(char));
|
||||
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, finished_at FROM %s WHERE %s=%i", "Laps", "stint_id", use_id);
|
||||
int errcode = h_query_select(conn, query, &result);
|
||||
if (errcode == H_OK)
|
||||
{
|
||||
laps->rows = malloc(sizeof(LapRowData) * result.nb_rows);
|
||||
get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData));
|
||||
h_clean_result(&result);
|
||||
}
|
||||
else
|
||||
{
|
||||
sloge("Error executing query %s returned %i", query, errcode);
|
||||
free(query);
|
||||
return -1;
|
||||
}
|
||||
free(query);
|
||||
|
||||
return result.nb_rows;
|
||||
}
|
||||
|
||||
int gettrack(struct _h_connection* conn, const char* trackname)
|
||||
{
|
||||
|
||||
json_t* j_result;
|
||||
char* where_clause = h_build_where_clause(conn, "config_name=%s AND track_name=%s", "default", trackname);
|
||||
json_t* j_query = json_pack("{sss[s]s{s{ssss}}}", "table", "track_config", "columns", "track_config_id", "where", " ", "operator", "raw",
|
||||
"value", where_clause);
|
||||
|
||||
char* qq;
|
||||
int res = h_select(conn, j_query, &j_result, &qq);
|
||||
|
||||
// Deallocate j_query since it won't be needed anymore
|
||||
//json_decref(j_query);
|
||||
//h_free(where_clause);
|
||||
int track_config = -1;
|
||||
// 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);
|
||||
//if (index1 == 0)
|
||||
//{
|
||||
// slogw("no config for this track");
|
||||
//}
|
||||
//else {
|
||||
json_t* jj = json_array_get(j_result, index1-1);
|
||||
track_config = json_integer_value(json_object_get(jj, "track_config_id"));
|
||||
//}
|
||||
// Deallocate data result
|
||||
|
||||
//free(dump);
|
||||
}
|
||||
else
|
||||
{
|
||||
sloge("Error executing select query %s: %d", qq, res);
|
||||
}
|
||||
json_decref(j_result);
|
||||
free(qq);
|
||||
json_decref(j_query);
|
||||
h_free(where_clause);
|
||||
return track_config;
|
||||
}
|
||||
|
||||
int getdriver(struct _h_connection* conn, const char* driver_name)
|
||||
{
|
||||
json_t* j_result;
|
||||
char* where_clause = h_build_where_clause(conn, "driver_name=%s", driver_name);
|
||||
json_t* j_query = json_pack("{sss[s]s{s{ssss}}}","table", "drivers", "columns", "driver_id", "where", " ", "operator", "raw",
|
||||
"value", where_clause);
|
||||
|
||||
slogi("Looking for driver named %s", driver_name);
|
||||
char* qq;
|
||||
int res = h_select(conn, j_query, &j_result, &qq);
|
||||
//slogi("here your query: %s", qq);
|
||||
// Deallocate j_query since it won't be needed anymore
|
||||
int driver_id = -1;
|
||||
// Test query execution result
|
||||
if (res == H_OK)
|
||||
{
|
||||
// Print result
|
||||
char* dump = json_dumps(j_result, JSON_INDENT(2));
|
||||
slogt("json select result is\n%s", dump);
|
||||
int index1 = json_array_size(j_result);
|
||||
if (index1 == 0)
|
||||
{
|
||||
slogw("no driver by this name");
|
||||
}
|
||||
else
|
||||
{
|
||||
json_t* jj = json_array_get(j_result, index1-1);
|
||||
driver_id = json_integer_value(json_object_get(jj, "driver_id"));
|
||||
}
|
||||
// Deallocate data result
|
||||
free(dump);
|
||||
}
|
||||
else
|
||||
{
|
||||
sloge("Error executing select query %s: %d", qq, res);
|
||||
}
|
||||
json_decref(j_result);
|
||||
free(qq);
|
||||
json_decref(j_query);
|
||||
h_free(where_clause);
|
||||
return driver_id;
|
||||
}
|
||||
|
||||
int getcar(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", "cars", "columns", "car_id", "where", " ", "operator", "raw",
|
||||
"value", where_clause);
|
||||
|
||||
slogi("Looking for car named %s", carname);
|
||||
char* qq;
|
||||
int res = h_select(conn, j_query, &j_result, &qq);
|
||||
//slogi("here your query: %s", qq);
|
||||
// Deallocate j_query since it won't be needed anymore
|
||||
|
||||
int car_id = -1;
|
||||
// Test query execution result
|
||||
if (res == H_OK)
|
||||
{
|
||||
// Print result
|
||||
char* dump = json_dumps(j_result, JSON_INDENT(2));
|
||||
slogt("json select result is\n%s", dump);
|
||||
int index1 = json_array_size(j_result);
|
||||
if (index1 == 0)
|
||||
{
|
||||
slogw("no car by this name");
|
||||
}
|
||||
else
|
||||
{
|
||||
json_t* jj = json_array_get(j_result, index1-1);
|
||||
car_id = json_integer_value(json_object_get(jj, "car_id"));
|
||||
}
|
||||
// Deallocate data result
|
||||
free(dump);
|
||||
}
|
||||
else
|
||||
{
|
||||
sloge("Error executing select query %s: %d", qq, res);
|
||||
}
|
||||
json_decref(j_result);
|
||||
free(qq);
|
||||
json_decref(j_query);
|
||||
h_free(where_clause);
|
||||
return car_id;
|
||||
}
|
||||
|
||||
|
||||
// inserts
|
||||
int addtrackconfig(struct _h_connection* conn, int trackconfigid, const char* track, int length)
|
||||
{
|
||||
//track_config_id | track_name | config_name | display_name | country | city | length
|
||||
if (trackconfigid > 0)
|
||||
{
|
||||
return trackconfigid;
|
||||
}
|
||||
json_t* root = json_object();
|
||||
json_t* json_arr = json_array();
|
||||
|
||||
json_object_set_new( root, "table", json_string("track_config") );
|
||||
json_object_set_new( root, "values", json_arr );
|
||||
|
||||
json_t* values = json_object();
|
||||
json_object_set_new(values, "track_name", json_string(track));
|
||||
json_object_set_new(values, "config_name", json_string("default"));
|
||||
json_object_set_new(values, "display_name", json_string(track));
|
||||
json_object_set_new(values, "country", json_string("USA"));
|
||||
json_object_set_new(values, "city", json_string("USA"));
|
||||
json_object_set_new(values, "length", json_integer(length));
|
||||
|
||||
json_array_append(json_arr, values);
|
||||
char* qq;
|
||||
int res = h_insert(conn, root, &qq);
|
||||
json_decref(root);
|
||||
json_decref(values);
|
||||
|
||||
if (res != 0)
|
||||
{
|
||||
sloge("track config insert result %i", res);
|
||||
sloge("track config query %s", qq);
|
||||
return -1;
|
||||
}
|
||||
|
||||
trackconfigid = getLastInsertID(conn);
|
||||
return trackconfigid;
|
||||
}
|
||||
|
||||
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
|
||||
// | start_time | duration_min | elapsed_ms | laps | weather |
|
||||
// air_temp | road_temp | start_grip |
|
||||
json_t* root = json_object();
|
||||
json_t* json_arr = json_array();
|
||||
|
||||
json_object_set_new( root, "table", json_string("sessions") );
|
||||
json_object_set_new( root, "values", json_arr );
|
||||
|
||||
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()"));
|
||||
json_object_set_new(values, "session_name", json_string("default"));
|
||||
json_object_set_new(values, "air_temp", json_integer(airtemp));
|
||||
json_object_set_new(values, "road_temp", json_integer(tracktemp));
|
||||
json_object_set_new(values, "weather", json_string("Windy"));
|
||||
json_object_set_new(values, "http_port", json_integer(0));
|
||||
json_array_append(json_arr, values);
|
||||
|
||||
char* qq;
|
||||
int res = h_insert(conn, root, &qq);
|
||||
json_decref(root);
|
||||
json_decref(values);
|
||||
|
||||
if (res != 0)
|
||||
{
|
||||
sloge("track config insert result %i", res);
|
||||
sloge("track config query %s", qq);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return getLastInsertID(conn);
|
||||
}
|
||||
|
||||
int adddriver(struct _h_connection* conn, int driverid, const char* drivername)
|
||||
{
|
||||
if (driverid > 0)
|
||||
{
|
||||
return driverid;
|
||||
}
|
||||
json_t* root = json_object();
|
||||
json_t* json_arr = json_array();
|
||||
|
||||
json_object_set_new( root, "table", json_string("drivers") );
|
||||
json_object_set_new( root, "values", json_arr );
|
||||
|
||||
json_t* values = json_object();
|
||||
json_object_set_new(values, "driver_name", json_string(drivername));
|
||||
json_object_set_new(values, "prev_name", json_string(drivername));
|
||||
json_object_set_new(values, "steam64_id", json_integer(17));
|
||||
json_object_set_new(values, "country", json_string("USA"));
|
||||
json_array_append(json_arr, values);
|
||||
|
||||
char* qq;
|
||||
int res = h_insert(conn, root, &qq);
|
||||
json_decref(root);
|
||||
json_decref(values);
|
||||
|
||||
if (res != 0)
|
||||
{
|
||||
sloge("driver insert result %i", res);
|
||||
sloge("driver insert query %s", qq);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
driverid = getLastInsertID(conn);
|
||||
return driverid;
|
||||
}
|
||||
|
||||
|
||||
int addevent(struct _h_connection* conn, int track_config)
|
||||
{
|
||||
|
||||
json_t* root = json_object();
|
||||
json_t* json_arr = json_array();
|
||||
|
||||
json_object_set_new( root, "table", json_string("events") );
|
||||
json_object_set_new( root, "values", json_arr );
|
||||
|
||||
json_t* values = json_object();
|
||||
json_object_set_new(values, "track_config_id", json_integer(track_config));
|
||||
json_object_set_new(values, "event_name", json_string("default"));
|
||||
//event_id | server_name | track_config_id | event_name | team_event | active | livery_preview | use_number | practice_duration | quali_duration | race_duration | race_duration_type | race_wait_time | race_extra_laps | reverse_grid_positions
|
||||
json_array_append(json_arr, values);
|
||||
|
||||
char* qq;
|
||||
int res = h_insert(conn, root, &qq);
|
||||
json_decref(root);
|
||||
json_decref(values);
|
||||
|
||||
if (res != 0)
|
||||
{
|
||||
sloge("event insert result %i", res);
|
||||
sloge("event insert query %s", qq);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return getLastInsertID(conn);
|
||||
}
|
||||
|
||||
|
||||
int addstint(struct _h_connection* conn, int sessionid, int driverid, int carid, SimData* simdata)
|
||||
{
|
||||
|
||||
|
||||
json_t* root = json_object();
|
||||
json_t* json_arr = json_array();
|
||||
|
||||
json_object_set_new( root, "table", json_string("stints") );
|
||||
json_object_set_new( root, "values", json_arr );
|
||||
|
||||
json_t* values = json_object();
|
||||
|
||||
json_object_set_new(values, "driver_id", json_integer(driverid));
|
||||
//team_member_id
|
||||
json_object_set_new(values, "session_id", json_integer(sessionid));
|
||||
json_object_set_new(values, "car_id", json_integer(carid));
|
||||
json_object_set_new(values, "game_car_id", json_integer(carid));
|
||||
json_object_set_new(values, "laps", json_integer(0));
|
||||
json_object_set_new(values, "valid_laps", json_integer(0));
|
||||
json_object_set_new(values, "tyre", json_string(simdata->tyrecompound) );
|
||||
// best_lap_id
|
||||
json_object_set_new(values, "is_finished", json_integer(0));
|
||||
|
||||
json_object_set_new(values, "started_at", json_string("NOW()") );
|
||||
json_array_append(json_arr, values);
|
||||
|
||||
char* qq;
|
||||
int res = h_insert(conn, root, &qq);
|
||||
json_decref(root);
|
||||
json_decref(values);
|
||||
|
||||
if (res != 0)
|
||||
{
|
||||
sloge("stint insert result %i", res);
|
||||
sloge("stint insert query %s", qq);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return getLastInsertID(conn);
|
||||
}
|
||||
|
||||
int addstintlap(struct _h_connection* conn, int stintid, SimData* simdata)
|
||||
{
|
||||
|
||||
slogt("adding stint lap");
|
||||
// stint laps
|
||||
// stint_lap_id | stint_id | sector_1 | sector_2 | sector_3 | grip | tyre | time | cuts | crashes
|
||||
// max_speed | avg_speed | finished_at
|
||||
json_t* root = json_object();
|
||||
json_t* json_arr = json_array();
|
||||
|
||||
json_object_set_new( root, "table", json_string("laps") );
|
||||
json_object_set_new( root, "values", json_arr );
|
||||
|
||||
json_t* values = json_object();
|
||||
|
||||
json_object_set_new(values, "stint_id", json_integer(stintid));
|
||||
json_object_set_new(values, "tyre", json_string(simdata->tyrecompound) );
|
||||
json_array_append(json_arr, values);
|
||||
|
||||
char* qq;
|
||||
int res = h_insert(conn, root, &qq);
|
||||
json_decref(root);
|
||||
json_decref(values);
|
||||
|
||||
if (res != 0)
|
||||
{
|
||||
sloge("stint lap insert result %i", res);
|
||||
sloge("stint lap insert query %s", qq);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return getLastInsertID(conn);
|
||||
}
|
||||
|
||||
int addcar(struct _h_connection* conn, int carid, const char* carname)
|
||||
{
|
||||
|
||||
// car_id | display_name | car_name | manufacturer | car_class
|
||||
|
||||
if (carid > 0)
|
||||
{
|
||||
return carid;
|
||||
}
|
||||
json_t* root = json_object();
|
||||
json_t* json_arr = json_array();
|
||||
|
||||
json_object_set_new( root, "table", json_string("cars") );
|
||||
json_object_set_new( root, "values", json_arr );
|
||||
|
||||
json_t* values = json_object();
|
||||
json_object_set_new(values, "display_name", json_string(carname));
|
||||
json_object_set_new(values, "car_name", json_string(carname));
|
||||
json_object_set_new(values, "manufacturer", json_string("Unknown"));
|
||||
json_object_set_new(values, "car_class", json_string("Unknown"));
|
||||
json_array_append(json_arr, values);
|
||||
|
||||
char* qq;
|
||||
int res = h_insert(conn, root, &qq);
|
||||
json_decref(root);
|
||||
json_decref(values);
|
||||
|
||||
if (res != 0)
|
||||
{
|
||||
sloge("car insert result %i", res);
|
||||
sloge("car insert query %s", qq);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return getLastInsertID(conn);
|
||||
}
|
||||
|
||||
int addtelemetry(struct _h_connection* conn, int points, int stintid)
|
||||
{
|
||||
|
||||
slogt("adding telemetry record");
|
||||
|
||||
json_t* root = json_object();
|
||||
json_t* json_arr = json_array();
|
||||
|
||||
json_object_set_new( root, "table", json_string("telemetry") );
|
||||
json_object_set_new( root, "values", json_arr );
|
||||
|
||||
json_t* values = json_object();
|
||||
json_object_set_new(values, "lap_id", json_integer(stintid));
|
||||
json_object_set_new(values, "points", json_integer(points));
|
||||
json_array_append(json_arr, values);
|
||||
|
||||
char* qq;
|
||||
int res = h_insert(conn, root, &qq);
|
||||
json_decref(root);
|
||||
json_decref(values);
|
||||
|
||||
if (res != 0)
|
||||
{
|
||||
sloge("telemetry insert result %i", res);
|
||||
sloge("telemetry insert query %s", qq);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return getLastInsertID(conn);
|
||||
}
|
||||
|
||||
|
||||
int closelap(struct _h_connection* conn, int lapid, int sector1, int sector2, int sector3, int cuts, int crashes, int maxspeed, int avgspeed, SimData* simdata)
|
||||
{
|
||||
|
||||
// stint laps
|
||||
// lap_id | stint_id | sector_1 | sector_2 | sector_3 | grip | tyre | time | cuts | crashes
|
||||
// max_speed | avg_speed | finished_at
|
||||
|
||||
slogt("closing previous lap ", lapid);
|
||||
|
||||
char* query = malloc((sizeof(char)*650));
|
||||
sprintf(query, "UPDATE %s SET %s=%i, %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", "time", simdata->lastlap, "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 errcode = h_query_update(conn, query);
|
||||
if (errcode != H_OK)
|
||||
{
|
||||
sloge("Error executing query %s returned %i", query, errcode);
|
||||
free(query);
|
||||
return -1;
|
||||
}
|
||||
|
||||
slogt("closed previous lap");
|
||||
free(query);
|
||||
return errcode;
|
||||
}
|
||||
|
||||
int closesession(struct _h_connection* conn, int sessionid)
|
||||
{
|
||||
|
||||
slogt("closing previous session ", sessionid);
|
||||
// best_lap_id
|
||||
|
||||
// session_id | event_id | event_type | track_time | session_name
|
||||
// | start_time | duration_min | elapsed_ms | laps | weather |
|
||||
// air_temp | road_temp | start_grip | end_grip | is_finished
|
||||
|
||||
char* query = malloc((sizeof(char)*100));
|
||||
sprintf(query, "UPDATE %s SET is_finished=1, finished_at=NOW() WHERE session_id=%i",
|
||||
"sessions", sessionid);
|
||||
|
||||
int errcode = h_query_update(conn, query);
|
||||
if (errcode != H_OK)
|
||||
{
|
||||
sloge("Error executing query %s returned %i", query, errcode);
|
||||
free(query);
|
||||
return -1;
|
||||
}
|
||||
|
||||
slogt("closed previous session");
|
||||
free(query);
|
||||
return errcode;
|
||||
}
|
||||
|
||||
|
||||
int closestint(struct _h_connection* conn, int stintid, int stintlaps, int validstintlaps)
|
||||
{
|
||||
|
||||
// best_lap_id
|
||||
slogt("closing previous stint ", stintid);
|
||||
|
||||
char* query = malloc((sizeof(char)*146));
|
||||
sprintf(query, "UPDATE %s SET %s = %i, %s = %i, is_finished=1, finished_at=NOW() WHERE stint_id=%i",
|
||||
"stints", "laps", stintlaps, "valid_laps", validstintlaps, stintid);
|
||||
|
||||
int errcode = h_query_update(conn, query);
|
||||
if (errcode != H_OK)
|
||||
{
|
||||
sloge("Error executing query %s returned %i", query, errcode);
|
||||
free(query);
|
||||
return -1;
|
||||
}
|
||||
|
||||
slogt("closed previous stint");
|
||||
free(query);
|
||||
return errcode;
|
||||
}
|
||||
|
|
@ -1,173 +0,0 @@
|
|||
|
||||
#ifndef _HOELDB_H
|
||||
#define _HOELDB_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include "../simulatorapi/simapi/simapi/simdata.h"
|
||||
|
||||
typedef struct DBData DBData;
|
||||
typedef struct DBField DBField;
|
||||
typedef struct SessionFieldsData SessionFieldsData;
|
||||
typedef struct SessionFields SessionFields;
|
||||
typedef struct Session Session;
|
||||
typedef unsigned char PDBTimeStamp[27];
|
||||
|
||||
struct DBField
|
||||
{
|
||||
size_t offset;
|
||||
size_t size;
|
||||
int colnum;
|
||||
int type;
|
||||
char name[20];
|
||||
};
|
||||
|
||||
//struct SessionFields
|
||||
//{
|
||||
// DBField session_id;
|
||||
// DBField laps;
|
||||
//};
|
||||
|
||||
typedef struct SessionRowData
|
||||
{
|
||||
int session_id;
|
||||
int event_id;
|
||||
int event_type;
|
||||
//char track_time[5];
|
||||
//char session_name[50];
|
||||
//char start_time[6];
|
||||
//int duration_min;
|
||||
//int elapsed_ms;
|
||||
int laps;
|
||||
unsigned char track[150];
|
||||
unsigned char car[150];
|
||||
PDBTimeStamp start_time;
|
||||
//char weather[100];
|
||||
//double air_temp;
|
||||
//double road_temp;
|
||||
//double start_grip;
|
||||
//double current_grip;
|
||||
//int is_finished;
|
||||
//char finish_time[6];
|
||||
//char last_activity[6];
|
||||
//int http_port;
|
||||
|
||||
}
|
||||
SessionRowData;
|
||||
|
||||
//struct SessionFieldsData
|
||||
//{
|
||||
// int session_id;
|
||||
// int laps;
|
||||
//};
|
||||
|
||||
typedef struct StintRowData
|
||||
{
|
||||
int stint_id;
|
||||
int driver_id;
|
||||
int team_member_id;
|
||||
int session_id;
|
||||
int car_id;
|
||||
int game_car_id;
|
||||
int laps;
|
||||
int valid_laps;
|
||||
int best_lap_id;
|
||||
unsigned char tyre[10];
|
||||
}
|
||||
StintRowData;
|
||||
|
||||
typedef struct LapRowData
|
||||
{
|
||||
int lap_id;
|
||||
int stint_id;
|
||||
int sector_1;
|
||||
int sector_2;
|
||||
int sector_3;
|
||||
double grip;
|
||||
unsigned char tyre[10];
|
||||
int time;
|
||||
int cuts;
|
||||
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;
|
||||
}
|
||||
LapRowData;
|
||||
|
||||
typedef struct SessionDbo
|
||||
{
|
||||
int numrows;
|
||||
bool hasdata;
|
||||
|
||||
DBField fields[7];
|
||||
SessionRowData* rows;
|
||||
}
|
||||
SessionDbo;
|
||||
|
||||
typedef struct StintDbo
|
||||
{
|
||||
int numrows;
|
||||
bool hasdata;
|
||||
|
||||
DBField fields[9];
|
||||
StintRowData* rows;
|
||||
}
|
||||
StintDbo;
|
||||
|
||||
typedef struct LapDbo
|
||||
{
|
||||
int numrows;
|
||||
bool hasdata;
|
||||
|
||||
DBField fields[13];
|
||||
LapRowData* rows;
|
||||
}
|
||||
LapDbo;
|
||||
|
||||
int getLastInsertID(struct _h_connection* conn);
|
||||
|
||||
void get_row_results(struct _h_result result, DBField* fields, void* rows, size_t rowsize);
|
||||
|
||||
int getsessions(struct _h_connection* conn, const char* sessionname, SessionDbo* sess);
|
||||
|
||||
int getstints(struct _h_connection* conn, const char* sessionname, StintDbo* stint, int use_id);
|
||||
|
||||
int getlaps(struct _h_connection* conn, const char* sessionname, LapDbo* laps, int use_id);
|
||||
|
||||
int gettrack(struct _h_connection* conn, const char* trackname);
|
||||
|
||||
int getdriver(struct _h_connection* conn, const char* driver_name);
|
||||
|
||||
int getcar(struct _h_connection* conn, const char* carname);
|
||||
|
||||
int addtrackconfig(struct _h_connection* conn, int trackconfigid, const char* track, int length);
|
||||
|
||||
int adddriver(struct _h_connection* conn, int driverid, const char* drivername);
|
||||
|
||||
int addevent(struct _h_connection* conn, int track_config);
|
||||
|
||||
int addsession(struct _h_connection* conn, int eventid, int carid, int eventtype, int airtemp, int tracktemp, SimData* simdata);
|
||||
|
||||
int addstint(struct _h_connection* conn, int sessionid, int driverid, int carid, SimData* simdata);
|
||||
|
||||
int addstintlap(struct _h_connection* conn, int stintid, SimData* simdata);
|
||||
|
||||
int addcar(struct _h_connection* conn, int carid, const char* carname);
|
||||
|
||||
int addtelemetry(struct _h_connection* conn, int points, int stintid);
|
||||
|
||||
int closelap(struct _h_connection* conn, int lapid, int sector1, int sector2, int sector3, int cuts, int crashes, int maxspeed, int avgspeed, SimData* simdata);
|
||||
|
||||
int closestint(struct _h_connection* conn, int stintid, int stintlaps, int validstintlaps);
|
||||
|
||||
int closesession(struct _h_connection* conn, int sessionid);
|
||||
#endif
|
||||
|
|
@ -1,297 +0,0 @@
|
|||
|
||||
#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", "rpms1", "gear1", "brake1", "accel1", "steer1", "speed2", "rpms2", "gear2", "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;
|
||||
}
|
||||
|
||||
void print_bytes(void* ptr, int size)
|
||||
{
|
||||
char* pp = malloc((size*2)+1);
|
||||
char output[(size * 2) + 1];
|
||||
char* ppp = &output[0];
|
||||
unsigned char* p = ptr;
|
||||
int i;
|
||||
for (i=0; i<size; i++)
|
||||
{
|
||||
slogt("%02hhX", p[i]);
|
||||
ppp += sprintf(ppp, "%02X", p[i]);
|
||||
//snprintf(pp, (size*2)+1, "%s%02hhX", pp, p[i]);
|
||||
}
|
||||
slogt("\n");
|
||||
slogt("bytes %s", output);
|
||||
}
|
||||
|
||||
int updatetelemetry(struct _h_connection* conn, int telemid, int size, const char* column, void* data)
|
||||
{
|
||||
|
||||
//char *pp = malloc((size*2)+1);
|
||||
char output[(size * 2) + 1];
|
||||
char* ppp = &output[0];
|
||||
unsigned char* p = data;
|
||||
int i;
|
||||
for (i=0; i<size; i++)
|
||||
{
|
||||
ppp += sprintf(ppp, "%02hhX", p[i]);
|
||||
//snprintf(pp, (size*2)+1, "%s%02hhX", pp, p[i]);
|
||||
}
|
||||
|
||||
char* query = malloc((sizeof(char)*71)+(sizeof(column))+(size*2)+1);
|
||||
sprintf(query, "UPDATE telemetry SET %s = decode('%s', 'hex') WHERE telemetry_id = %i", column, &output, telemid);
|
||||
int res1 = h_query_update(conn, query);
|
||||
//int res1 = h_insert(conn, j_query, NULL);
|
||||
slogt("got res %i", res1);
|
||||
free(query);
|
||||
|
||||
return res1;
|
||||
}
|
||||
|
||||
int updatetelemetrydata(struct _h_connection* conn, int tracksamples, int telemid, int lapid,
|
||||
int* speeddata, int* rpmdata, int* geardata,
|
||||
double* steerdata, double* acceldata, double* brakedata)
|
||||
{
|
||||
int b = 0;
|
||||
b = updatetelemetry(conn, telemid, tracksamples*sizeof(double), "steer", steerdata);
|
||||
b = updatetelemetry(conn, telemid, tracksamples*sizeof(double), "accel", acceldata);
|
||||
b = updatetelemetry(conn, telemid, tracksamples*sizeof(double), "brake", brakedata);
|
||||
b = updatetelemetry(conn, telemid, tracksamples*sizeof(int), "rpms", rpmdata);
|
||||
b = updatetelemetry(conn, telemid, tracksamples*sizeof(int), "gear", geardata);
|
||||
b = updatetelemetry(conn, telemid, tracksamples*sizeof(int), "speed", speeddata);
|
||||
|
||||
return b;
|
||||
}
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
#ifndef _TELEMETRY_H
|
||||
#define _TELEMETRY_H
|
||||
|
||||
int dumptelemetrytofile(struct _h_connection* conn, char* datadir, int lap1id, int lap2id);
|
||||
|
||||
void print_bytes(void* ptr, int size);
|
||||
|
||||
int updatetelemetrydata(struct _h_connection* conn, int tracksamples, int telemid, int lapid,
|
||||
int* speeddata, int* rpmdata, int* geardata,
|
||||
double* steerdata, double* acceldata, double* brakedata);
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,287 @@
|
|||
#include <unistd.h>
|
||||
|
||||
#include "SDL/SDL.h"
|
||||
#include "SDL/SDL_getenv.h"
|
||||
|
||||
// Define the primary surface for display
|
||||
SDL_Surface* scrMain = NULL;
|
||||
//<File !Start!>
|
||||
// FILE: [FerrariF1Wheel.c]
|
||||
// Created by GUIslice Builder version: [0.17.b20]
|
||||
//
|
||||
// GUIslice Builder Generated File
|
||||
//
|
||||
// For the latest guides, updates and support view:
|
||||
// https://github.com/ImpulseAdventure/GUIslice
|
||||
//
|
||||
//<File !End!>
|
||||
//
|
||||
|
||||
// ------------------------------------------------
|
||||
// Headers to include
|
||||
// ------------------------------------------------
|
||||
#include "../GUIslice/src/GUIslice.h"
|
||||
#include "../GUIslice/src/GUIslice_drv.h"
|
||||
|
||||
// Include any extended elements
|
||||
//<Includes !Start!>
|
||||
//<Includes !End!>
|
||||
|
||||
// ------------------------------------------------
|
||||
// Defines for resources
|
||||
// ------------------------------------------------
|
||||
#define MAX_PATH 255
|
||||
//<PathStorage !Start!>
|
||||
//<PathStorage !End!>
|
||||
|
||||
// ------------------------------------------------
|
||||
// Headers and Defines for fonts
|
||||
// ------------------------------------------------
|
||||
//<Fonts !Start!>
|
||||
#define FONT_FREE_MONOB96 "/usr/share/fonts/truetype/freefont/FreeMonoBold.ttf"
|
||||
//<Fonts !End!>
|
||||
|
||||
// ------------------------------------------------
|
||||
// Defines for resources
|
||||
// ------------------------------------------------
|
||||
//<Resources !Start!>
|
||||
//<Resources !End!>
|
||||
|
||||
// ------------------------------------------------
|
||||
// Enumerations for pages, elements, fonts, images
|
||||
// ------------------------------------------------
|
||||
//<Enum !Start!>
|
||||
enum {E_PG_MAIN};
|
||||
enum {E_GEAR_TEXT};
|
||||
// Must use separate enum for fonts with MAX_FONT at end to use gslc_FontSet.
|
||||
enum {E_FREEMONOBOLD96PT,MAX_FONT};
|
||||
//<Enum !End!>
|
||||
|
||||
// ------------------------------------------------
|
||||
// Instantiate the GUI
|
||||
// ------------------------------------------------
|
||||
|
||||
// ------------------------------------------------
|
||||
// Define the maximum number of elements and pages
|
||||
// ------------------------------------------------
|
||||
//<ElementDefines !Start!>
|
||||
#define MAX_PAGE 1
|
||||
|
||||
#define MAX_ELEM_PG_MAIN 1 // # Elems total on page
|
||||
#define MAX_ELEM_PG_MAIN_RAM MAX_ELEM_PG_MAIN // # Elems in RAM
|
||||
//<ElementDefines !End!>
|
||||
|
||||
// ------------------------------------------------
|
||||
// Create element storage
|
||||
// ------------------------------------------------
|
||||
// GUI Elements
|
||||
gslc_tsGui m_gui;
|
||||
gslc_tsDriver m_drv;
|
||||
gslc_tsFont m_asFont[MAX_FONT];
|
||||
gslc_tsPage m_asPage[MAX_PAGE];
|
||||
|
||||
//<GUI_Extra_Elements !Start!>
|
||||
gslc_tsElem m_asPage1Elem[MAX_ELEM_PG_MAIN_RAM];
|
||||
gslc_tsElemRef m_asPage1ElemRef[MAX_ELEM_PG_MAIN];
|
||||
|
||||
|
||||
gslc_tsElemRef* pElemRef = NULL;
|
||||
|
||||
#define MAX_STR 100
|
||||
|
||||
//<GUI_Extra_Elements !End!>
|
||||
|
||||
// ------------------------------------------------
|
||||
// Program Globals
|
||||
// ------------------------------------------------
|
||||
bool m_bQuit = false;
|
||||
|
||||
// Save some element references for direct access
|
||||
//<Save_References !Start!>
|
||||
//<Save_References !End!>
|
||||
|
||||
|
||||
// Configure environment variables suitable for display
|
||||
// - These may need modification to match your system
|
||||
// environment and display type
|
||||
// - Defaults for GSLC_DEV_FB and GSLC_DEV_TOUCH are in GUIslice_config.h
|
||||
// - Note that the environment variable settings can
|
||||
// also be set directly within the shell via export
|
||||
// (or init script).
|
||||
// - eg. export TSLIB_FBDEVICE=/dev/fb1
|
||||
void UserInitEnv()
|
||||
{
|
||||
#if defined(DRV_DISP_SDL1) || defined(DRV_DISP_SDL2)
|
||||
setenv((char*)"FRAMEBUFFER",GSLC_DEV_FB,1);
|
||||
setenv((char*)"SDL_FBDEV",GSLC_DEV_FB,1);
|
||||
setenv((char*)"SDL_VIDEODRIVER",GSLC_DEV_VID_DRV,1);
|
||||
#endif
|
||||
|
||||
#if defined(DRV_TOUCH_TSLIB)
|
||||
setenv((char*)"TSLIB_FBDEVICE",GSLC_DEV_FB,1);
|
||||
setenv((char*)"TSLIB_TSDEVICE",GSLC_DEV_TOUCH,1);
|
||||
setenv((char*)"TSLIB_CALIBFILE",(char*)"/etc/pointercal",1);
|
||||
setenv((char*)"TSLIB_CONFFILE",(char*)"/etc/ts.conf",1);
|
||||
setenv((char*)"TSLIB_PLUGINDIR",(char*)"/usr/local/lib/ts",1);
|
||||
#endif
|
||||
}
|
||||
|
||||
// Define debug message function
|
||||
static int16_t DebugOut(char ch) { fputc(ch,stderr); return 0; }
|
||||
|
||||
// ------------------------------------------------
|
||||
// Callback Methods
|
||||
// ------------------------------------------------
|
||||
//<Button Callback !Start!>
|
||||
//<Button Callback !End!>
|
||||
//<Checkbox Callback !Start!>
|
||||
//<Checkbox Callback !End!>
|
||||
//<Keypad Callback !Start!>
|
||||
//<Keypad Callback !End!>
|
||||
//<Spinner Callback !Start!>
|
||||
//<Spinner Callback !End!>
|
||||
//<Listbox Callback !Start!>
|
||||
//<Listbox Callback !End!>
|
||||
//<Draw Callback !Start!>
|
||||
//<Draw Callback !End!>
|
||||
//<Slider Callback !Start!>
|
||||
//<Slider Callback !End!>
|
||||
//<Tick Callback !Start!>
|
||||
//<Tick Callback !End!>
|
||||
|
||||
// ------------------------------------------------
|
||||
// Create page elements
|
||||
// - strPath: Path to executable passed in to locate resource files
|
||||
// ------------------------------------------------
|
||||
bool InitGUI(char *strPath)
|
||||
{
|
||||
//gslc_tsElemRef* pElemRef = NULL;
|
||||
|
||||
//<InitGUI !Start!>
|
||||
gslc_PageAdd(&m_gui,E_PG_MAIN,m_asPage1Elem,MAX_ELEM_PG_MAIN_RAM,m_asPage1ElemRef,MAX_ELEM_PG_MAIN);
|
||||
// NOTE: The current page defaults to the first page added. Here we explicitly
|
||||
// ensure that the main page is the correct page no matter the add order.
|
||||
gslc_SetPageCur(&m_gui,E_PG_MAIN);
|
||||
|
||||
|
||||
// Set Background to a flat color
|
||||
gslc_SetBkgndColor(&m_gui,GSLC_COL_BLACK);
|
||||
|
||||
// -----------------------------------
|
||||
// PAGE: E_PG_MAIN
|
||||
|
||||
// Create E_GEAR_TEXT text label
|
||||
pElemRef = gslc_ElemCreateTxt(&m_gui,E_GEAR_TEXT,E_PG_MAIN,(gslc_tsRect){140,90,33,49},
|
||||
(char*)"N",0,E_FREEMONOBOLD96PT);
|
||||
|
||||
gslc_ElemSetFillEn(&m_gui,pElemRef,false);
|
||||
//<InitGUI !End!>
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void* wheel()
|
||||
{
|
||||
// --------------------------------------
|
||||
// Initialization
|
||||
// --------------------------------------
|
||||
|
||||
// Update the environment variables for SDL to
|
||||
// work correctly with the external display on
|
||||
// LINUX frame buffer 1 (fb1).
|
||||
putenv((char*) "FRAMEBUFFER=/dev/fb1");
|
||||
putenv((char*) "SDL_FBDEV=/dev/fb1");
|
||||
|
||||
// Initialize SDL
|
||||
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
|
||||
fprintf(stderr, "ERROR in SDL_Init(): %s\n", SDL_GetError());
|
||||
return 0;
|
||||
}
|
||||
atexit(SDL_Quit);
|
||||
|
||||
// Fetch the best video mode
|
||||
// - Note that the Raspberry Pi generally defaults
|
||||
// to a 16bits/pixel framebuffer
|
||||
const SDL_VideoInfo* vInfo = SDL_GetVideoInfo();
|
||||
if (!vInfo) {
|
||||
fprintf(stderr, "ERROR in SDL_GetVideoInfo(): %s\n", SDL_GetError());
|
||||
return 0;
|
||||
}
|
||||
int nResX = vInfo->current_w;
|
||||
int nResY = vInfo->current_h;
|
||||
int nDepth = vInfo->vfmt->BitsPerPixel;
|
||||
|
||||
// Configure the video mode
|
||||
// - SDL_SWSURFACE appears to be most robust mode
|
||||
int nFlags = SDL_SWSURFACE | SDL_FULLSCREEN;
|
||||
scrMain = SDL_SetVideoMode(nResX, nResY, nDepth, nFlags);
|
||||
if (scrMain == 0) {
|
||||
fprintf(stderr, "ERROR in SDL_SetVideoMode(): %s\n", SDL_GetError());
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
bool bOk = true;
|
||||
char acTxt[MAX_STR];
|
||||
|
||||
// ------------------------------------------------
|
||||
// Initialize
|
||||
// ------------------------------------------------
|
||||
gslc_InitDebug(&DebugOut);
|
||||
UserInitEnv();
|
||||
|
||||
if (!gslc_Init(&m_gui,&m_drv,m_asPage,MAX_PAGE,m_asFont,MAX_FONT)) { exit(1); }
|
||||
|
||||
// ------------------------------------------------
|
||||
// Load Fonts
|
||||
// ------------------------------------------------
|
||||
//<Load_Fonts !Start!>
|
||||
//
|
||||
bOk = gslc_FontSet(&m_gui,E_FREEMONOBOLD96PT,GSLC_FONTREF_FNAME,FONT_FREE_MONOB96,96);
|
||||
if (!bOk) { fprintf(stderr,"ERROR: FontAdd failed: %s\n",FONT_FREE_MONOB96); exit(1); }
|
||||
//<Load_Fonts !End!>
|
||||
|
||||
// ------------------------------------------------
|
||||
// Create graphic elements
|
||||
// ------------------------------------------------
|
||||
InitGUI("."); // Pass executable path to find resource files
|
||||
|
||||
// ------------------------------------------------
|
||||
// Start up display on main page
|
||||
// ------------------------------------------------
|
||||
//<Startup !Start!>
|
||||
//<Startup !End!>
|
||||
// ------------------------------------------------
|
||||
// Main event loop
|
||||
// ------------------------------------------------
|
||||
|
||||
m_bQuit = false;
|
||||
while (!m_bQuit) {
|
||||
|
||||
// ----------------------------------------------
|
||||
// Update GUI Elements
|
||||
// ----------------------------------------------
|
||||
|
||||
//TODO - Add update code for any text, gauges, or sliders
|
||||
|
||||
// ----------------------------------------------
|
||||
// Periodically call GUIslice update function
|
||||
// ----------------------------------------------
|
||||
gslc_Update(&m_gui);
|
||||
sleep(2);
|
||||
gslc_ElemSetTxtStr(&m_gui, pElemRef, "2");
|
||||
|
||||
gslc_Update(&m_gui);
|
||||
sleep(2);
|
||||
m_bQuit = true;
|
||||
} // bQuit
|
||||
|
||||
// ------------------------------------------------
|
||||
// Close down display
|
||||
// ------------------------------------------------
|
||||
|
||||
gslc_Quit(&m_gui);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1 @@
|
|||
void* wheel(void* params);
|
||||
|
|
@ -1,4 +1,3 @@
|
|||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/stat.h>
|
||||
|
|
@ -6,22 +5,42 @@
|
|||
#include <unistd.h>
|
||||
#include <libconfig.h>
|
||||
#include <pthread.h>
|
||||
#include <basedir_fs.h>
|
||||
|
||||
#include "gameloop/gameloop.h"
|
||||
#include "gameloop/browseloop.h"
|
||||
#include "helper/parameters.h"
|
||||
#include "helper/dirhelper.h"
|
||||
#include "helper/confighelper.h"
|
||||
#include "slog/slog.h"
|
||||
|
||||
#define PROGRAM_NAME "gilles"
|
||||
|
||||
int create_dir(char* dir)
|
||||
{
|
||||
struct stat st = {0};
|
||||
if (stat(dir, &st) == -1)
|
||||
{
|
||||
mkdir(dir, 0700);
|
||||
}
|
||||
}
|
||||
|
||||
char* create_user_dir(char* dirtype)
|
||||
{
|
||||
char* home_dir_str = gethome();
|
||||
char* config_dir_str = ( char* ) malloc(1 + strlen(home_dir_str) + strlen(dirtype) + strlen("gilles/"));
|
||||
strcpy(config_dir_str, home_dir_str);
|
||||
strcat(config_dir_str, dirtype);
|
||||
strcat(config_dir_str, "gilles/");
|
||||
|
||||
create_dir(config_dir_str);
|
||||
free(config_dir_str);
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
|
||||
Parameters* p = malloc(sizeof(Parameters));
|
||||
GillesSettings* gs = malloc(sizeof(GillesSettings));;
|
||||
|
||||
ConfigError ppe = getParameters(argc, argv, p);
|
||||
if (ppe == E_SUCCESS_AND_EXIT)
|
||||
{
|
||||
|
|
@ -31,15 +50,22 @@ int main(int argc, char** argv)
|
|||
p->program_state = 1;
|
||||
|
||||
char* home_dir_str = gethome();
|
||||
|
||||
char* cachedir = create_user_dir(home_dir_str, ".cache", PROGRAM_NAME);
|
||||
create_user_dir("/.config/");
|
||||
create_user_dir("/.cache/");
|
||||
char* config_file_str = ( char* ) malloc(1 + strlen(home_dir_str) + strlen("/.config/") + strlen("gilles/gilles.config"));
|
||||
char* cache_dir_str = ( char* ) malloc(1 + strlen(home_dir_str) + strlen("/.cache/gilles/"));
|
||||
strcpy(config_file_str, home_dir_str);
|
||||
strcat(config_file_str, "/.config/");
|
||||
strcpy(cache_dir_str, home_dir_str);
|
||||
strcat(cache_dir_str, "/.cache/gilles/");
|
||||
strcat(config_file_str, "gilles/gilles.config");
|
||||
|
||||
slog_config_t slgCfg;
|
||||
slog_config_get(&slgCfg);
|
||||
slgCfg.eColorFormat = SLOG_COLORING_TAG;
|
||||
slgCfg.eDateControl = SLOG_TIME_ONLY;
|
||||
strcpy(slgCfg.sFileName, "gilles.log");
|
||||
strcpy(slgCfg.sFilePath, cachedir);
|
||||
strcpy(slgCfg.sFilePath, cache_dir_str);
|
||||
slgCfg.nTraceTid = 0;
|
||||
slgCfg.nToScreen = 1;
|
||||
slgCfg.nUseHeap = 0;
|
||||
|
|
@ -56,50 +82,42 @@ int main(int argc, char** argv)
|
|||
slog_disable(SLOG_DEBUG);
|
||||
}
|
||||
|
||||
char* configdir = create_user_dir(home_dir_str, ".config", PROGRAM_NAME);
|
||||
char* datadir = create_user_dir(home_dir_str, ".local/share", PROGRAM_NAME);
|
||||
pthread_t ui_thread;
|
||||
pthread_t mqtt_thread;
|
||||
|
||||
xdgHandle xdg;
|
||||
if(!xdgInitHandle(&xdg))
|
||||
if (pthread_create(&ui_thread, NULL, &looper, p) != 0)
|
||||
{
|
||||
slogf("Function xdgInitHandle() failed, is $HOME unset?");
|
||||
printf("Uh-oh!\n");
|
||||
return -1;
|
||||
}
|
||||
if (p->mqtt == true)
|
||||
{
|
||||
if (pthread_create(&mqtt_thread, NULL, &b4madmqtt, p) != 0)
|
||||
{
|
||||
printf("Uh-oh!\n");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
char* config_file_str = get_config_file(p->config_path, &xdg);
|
||||
int err = loadconfig(config_file_str, p);
|
||||
pthread_join(ui_thread, NULL);
|
||||
p->program_state = -1;
|
||||
if (p->mqtt == true)
|
||||
{
|
||||
pthread_join(mqtt_thread, NULL);
|
||||
}
|
||||
|
||||
free(config_file_str);
|
||||
xdgWipeHandle(&xdg);
|
||||
free(cache_dir_str);
|
||||
|
||||
if (err == E_NO_ERROR)
|
||||
{
|
||||
if (p->program_action == A_PLAY)
|
||||
{
|
||||
mainloop(p);
|
||||
}
|
||||
else
|
||||
{
|
||||
browseloop(p, datadir);
|
||||
}
|
||||
if (p->err != E_NO_ERROR)
|
||||
{
|
||||
sloge("Error occured during execution.");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
configcleanup:
|
||||
//config_destroy(&cfg);
|
||||
|
||||
cleanup_final:
|
||||
freeparams(p);
|
||||
free(gs);
|
||||
free(p);
|
||||
|
||||
free(configdir);
|
||||
free(datadir);
|
||||
free(cachedir);
|
||||
|
||||
exit(0);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -2,125 +2,37 @@
|
|||
#include <stdbool.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
|
||||
#include "confighelper.h"
|
||||
|
||||
#include "../slog/slog.h"
|
||||
#include "parameters.h"
|
||||
|
||||
//int strtogame(const char* game, GillesSettings* gs)
|
||||
//{
|
||||
// slogd("Checking for %s in list of supported simulators.", game);
|
||||
// if (strcmp(game, "ac") == 0)
|
||||
// {
|
||||
// slogd("Setting simulator to Assetto Corsa");
|
||||
// gs->sim_name = SIMULATOR_ASSETTO_CORSA;
|
||||
// }
|
||||
// else
|
||||
// if (strcmp(game, "test") == 0)
|
||||
// {
|
||||
// slogd("Setting simulator to Test Data");
|
||||
// gs->sim_name = SIMULATOR_GILLES_TEST;
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// slogi("%s does not appear to be a supported simulator.", game);
|
||||
// return GILLES_ERROR_INVALID_SIM;
|
||||
// }
|
||||
// return GILLES_ERROR_NONE;
|
||||
//}
|
||||
|
||||
int loaddbconfig(config_t* cfg, Parameters* p)
|
||||
int strtogame(const char* game, GillesSettings* gs)
|
||||
{
|
||||
config_setting_t* config_db_array = NULL;
|
||||
config_db_array = config_lookup(cfg, "db");
|
||||
|
||||
config_setting_t* config_db = NULL;
|
||||
config_db = config_setting_get_elem(config_db_array, 0);
|
||||
|
||||
if (config_db == NULL) {
|
||||
slogi("found no db settings");
|
||||
return E_BAD_CONFIG;
|
||||
slogd("Checking for %s in list of supported simulators.", game);
|
||||
if (strcmp(game, "ac") == 0)
|
||||
{
|
||||
slogd("Setting simulator to Assetto Corsa");
|
||||
gs->sim_name = SIMULATOR_ASSETTO_CORSA;
|
||||
}
|
||||
const char* temp;
|
||||
config_setting_lookup_string(config_db, "user", &temp);
|
||||
p->db_user = strdup(temp);
|
||||
config_setting_lookup_string(config_db, "password", &temp);
|
||||
p->db_pass = strdup(temp);
|
||||
config_setting_lookup_string(config_db, "server", &temp);
|
||||
p->db_serv = strdup(temp);
|
||||
config_setting_lookup_string(config_db, "database", &temp);
|
||||
p->db_dbnm = strdup(temp);
|
||||
|
||||
size_t strsize = strlen(p->db_user) + strlen(p->db_pass) + strlen(p->db_serv) + strlen(p->db_dbnm) + 29 + 1;
|
||||
p->db_conn = malloc(strsize);
|
||||
|
||||
snprintf(p->db_conn, strsize, "host=%s dbname=%s user=%s password=%s", p->db_serv, p->db_dbnm, p->db_user, p->db_pass);
|
||||
|
||||
return E_NO_ERROR;
|
||||
}
|
||||
|
||||
int loadconfig(const char* config_file_str, Parameters* p)
|
||||
else
|
||||
if (strcmp(game, "test") == 0)
|
||||
{
|
||||
config_t cfg;
|
||||
config_init(&cfg);
|
||||
if (!config_read_file(&cfg, config_file_str))
|
||||
{
|
||||
fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
|
||||
slogd("Setting simulator to Test Data");
|
||||
gs->sim_name = SIMULATOR_GILLES_TEST;
|
||||
}
|
||||
else
|
||||
{
|
||||
slogi("Parsing config file");
|
||||
slogi("%s does not appear to be a supported simulator.", game);
|
||||
return GILLES_ERROR_INVALID_SIM;
|
||||
}
|
||||
return GILLES_ERROR_NONE;
|
||||
}
|
||||
|
||||
|
||||
if (p->program_action == A_BROWSE)
|
||||
int loadconfig(const char* config_file)
|
||||
{
|
||||
char* gnuplotbin = "/usr/bin/gnuplot";
|
||||
config_setting_t* config_graph_array = NULL;
|
||||
config_graph_array = config_lookup(&cfg, "graph");
|
||||
|
||||
config_setting_t* config_graph = NULL;
|
||||
config_graph = config_setting_get_elem(config_graph_array, 0);
|
||||
|
||||
if (config_graph == NULL) {
|
||||
slogi("found no graph settings");
|
||||
return E_BAD_CONFIG;
|
||||
}
|
||||
const char* temp;
|
||||
config_setting_lookup_string(config_graph, "gnuplotfile", &temp);
|
||||
p->gnuplot_file = strdup(temp);
|
||||
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)
|
||||
{
|
||||
int err = loaddbconfig(&cfg, p);
|
||||
if (err != E_NO_ERROR)
|
||||
{
|
||||
return err;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
config_destroy(&cfg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -8,6 +8,13 @@
|
|||
|
||||
#include "parameters.h"
|
||||
|
||||
typedef enum
|
||||
{
|
||||
SIMULATOR_GILLES_TEST = 0,
|
||||
SIMULATOR_ASSETTO_CORSA = 1
|
||||
}
|
||||
Simulator;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
SIMULATOR_UPDATE_DEFAULT = 0,
|
||||
|
|
@ -18,6 +25,15 @@ typedef enum
|
|||
}
|
||||
SimulatorUpdate;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
GILLES_ERROR_NONE = 0,
|
||||
GILLES_ERROR_UNKNOWN = 1,
|
||||
GILLES_ERROR_INVALID_SIM = 2,
|
||||
GILLES_ERROR_NODATA = 4,
|
||||
}
|
||||
GillesError;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
ProgramAction program_action;
|
||||
|
|
@ -25,8 +41,6 @@ typedef struct
|
|||
}
|
||||
GillesSettings;
|
||||
|
||||
int loadconfig(const char* config_file_str, Parameters* p);
|
||||
|
||||
int strtogame(const char* game, GillesSettings* gs);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -11,65 +11,8 @@
|
|||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
|
||||
|
||||
#include <string.h>
|
||||
|
||||
|
||||
|
||||
#include "../slog/slog.h"
|
||||
|
||||
|
||||
#define CONFIG_FILE "gilles/gilles.config"
|
||||
|
||||
void create_dir(char* dir)
|
||||
{
|
||||
struct stat st = {0};
|
||||
if (stat(dir, &st) == -1)
|
||||
{
|
||||
mkdir(dir, 0700);
|
||||
}
|
||||
}
|
||||
|
||||
char* create_user_dir(char* home_dir_str, const char* dirtype, const char* programname)
|
||||
{
|
||||
// +3 for slashes
|
||||
size_t ss = (4 + strlen(home_dir_str) + strlen(dirtype) + strlen(programname));
|
||||
char* config_dir_str = malloc(ss);
|
||||
|
||||
snprintf (config_dir_str, ss, "%s/%s/%s/", home_dir_str, dirtype, programname);
|
||||
|
||||
slogt("creating dir for %s if necessary", config_dir_str);
|
||||
create_dir(config_dir_str);
|
||||
return config_dir_str;
|
||||
}
|
||||
|
||||
|
||||
char* get_config_file(const char* confpath, xdgHandle* xdg)
|
||||
{
|
||||
if ((confpath != NULL) && (strcmp(confpath, "") != 0))
|
||||
{
|
||||
slogw("Using custom config path %s", confpath);
|
||||
return strdup(confpath);
|
||||
}
|
||||
|
||||
const char* relpath = CONFIG_FILE;
|
||||
char* confpath1 = xdgConfigFind(relpath, xdg);
|
||||
slogi("config path is %s", confpath1);
|
||||
return confpath1;
|
||||
}
|
||||
|
||||
|
||||
char* get_dir_with_default(const char* dirpath, char* defaultpath)
|
||||
{
|
||||
if ((dirpath != NULL) && (strcmp(dirpath, "") != 0))
|
||||
{
|
||||
slogw("Using custom config path %s", dirpath);
|
||||
return strdup(dirpath);
|
||||
}
|
||||
|
||||
return defaultpath;
|
||||
}
|
||||
|
||||
char* gethome()
|
||||
{
|
||||
char* homedir = getenv("HOME");
|
||||
|
|
|
|||
|
|
@ -3,16 +3,10 @@
|
|||
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <basedir_fs.h>
|
||||
|
||||
void create_dir(char* dir);
|
||||
char* create_user_dir(char* home_dir_str, const char* dirtype, const char* programpath);
|
||||
char* gethome();
|
||||
char* str2md5(const char* str, int length);
|
||||
bool does_directory_exist(char* path, char* dirname);
|
||||
void restrict_folders_to_cache(char* path, int cachesize);
|
||||
void delete_dir(char* path);
|
||||
char* get_config_file(const char* confpath, xdgHandle* xdg);
|
||||
char* get_dir_with_default(const char* dirpath, char* defaultpath);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -8,34 +8,6 @@
|
|||
#include <argtable2.h>
|
||||
#include <regex.h>
|
||||
|
||||
int freeparams(Parameters* p)
|
||||
{
|
||||
if(p->sim_string != NULL)
|
||||
{
|
||||
free(p->sim_string);
|
||||
}
|
||||
if (p->mysql == true || p->program_action == A_BROWSE)
|
||||
{
|
||||
if(p->db_user != NULL)
|
||||
{
|
||||
free(p->db_user);
|
||||
}
|
||||
if(p->db_conn != NULL)
|
||||
{
|
||||
free(p->db_conn);
|
||||
}
|
||||
}
|
||||
if (p->program_action == A_BROWSE)
|
||||
{
|
||||
free(p->gnuplot_bin);
|
||||
}
|
||||
if (p->config_path != NULL)
|
||||
{
|
||||
free(p->config_path);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
ConfigError getParameters(int argc, char** argv, Parameters* p)
|
||||
{
|
||||
|
||||
|
|
@ -43,107 +15,64 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
|
|||
|
||||
// set return structure defaults
|
||||
p->program_action = 0;
|
||||
p->cli = false;
|
||||
p->mqtt = false;
|
||||
p->mysql = false;
|
||||
p->simon = false;
|
||||
p->verbosity_count = 0;
|
||||
|
||||
// setup argument handling structures
|
||||
const char* progname = "Gilles";
|
||||
const char* progname = "gilles";
|
||||
|
||||
struct arg_lit* arg_verbosity0 = arg_litn("v","verbose", 0, 2, "increase logging verbosity");
|
||||
struct arg_lit* arg_verbosity1 = arg_litn("v","verbose", 0, 2, "increase logging verbosity");
|
||||
struct arg_lit* arg_verbosity = arg_litn("v","verbose", 0, 2, "increase logging verbosity");
|
||||
|
||||
struct arg_rex* cmd1 = arg_rex1(NULL, NULL, "play", NULL, REG_ICASE, NULL);
|
||||
struct arg_rex* cmd2 = arg_rex1(NULL, NULL, "browse", NULL, REG_ICASE, NULL);
|
||||
struct arg_str* arg_cpath = arg_strn("f", "configpath", "<path of config>", 0, 1, NULL);
|
||||
struct arg_str* arg_sim = arg_strn("s", "sim", "<gamename>", 0, 1, NULL);
|
||||
struct arg_lit* arg_cli = arg_lit0("c", "textui", "text only ui");
|
||||
struct arg_lit* arg_mqtt = arg_lit0("Q", "mqtt", "send data to local mqtt server with connection settings speciifed in config");
|
||||
struct arg_lit* arg_mysql = arg_lit0("M", "mysql", "send data to local mysql server with connection settings specified in config");
|
||||
struct arg_lit* help0 = arg_litn(NULL,"help", 0, 1, "print this help and exit");
|
||||
struct arg_lit* vers0 = arg_litn(NULL,"version", 0, 1, "print version information and exit");
|
||||
struct arg_end* end0 = arg_end(20);
|
||||
struct arg_lit* help1 = arg_litn(NULL,"help", 0, 1, "print this help and exit");
|
||||
struct arg_lit* vers1 = arg_litn(NULL,"version", 0, 1, "print version information and exit");
|
||||
struct arg_end* end1 = arg_end(20);
|
||||
void* argtable0[] = {cmd1,arg_sim,arg_verbosity0,arg_cli,arg_mqtt,arg_mysql,help0,vers0,end0};
|
||||
void* argtable1[] = {cmd2,arg_verbosity1,help1,vers1,end1};
|
||||
int nerrors0;
|
||||
int nerrors1;
|
||||
struct arg_lit* arg_mqtt = arg_lit0("S", NULL, "send data to local mqtt server");
|
||||
struct arg_lit* help = arg_litn(NULL,"help", 0, 1, "print this help and exit");
|
||||
struct arg_lit* vers = arg_litn(NULL,"version", 0, 1, "print version information and exit");
|
||||
struct arg_end* end = arg_end(20);
|
||||
void* argtable[] = {cmd1,arg_sim,arg_verbosity,arg_mqtt,help,vers,end};
|
||||
int nerrors;
|
||||
|
||||
|
||||
|
||||
if (arg_nullcheck(argtable0) != 0)
|
||||
{
|
||||
printf("%s: insufficient memory\n",progname);
|
||||
goto cleanup;
|
||||
}
|
||||
if (arg_nullcheck(argtable1) != 0)
|
||||
if (arg_nullcheck(argtable) != 0)
|
||||
{
|
||||
printf("%s: insufficient memory\n",progname);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
nerrors0 = arg_parse(argc,argv,argtable0);
|
||||
nerrors1 = arg_parse(argc,argv,argtable1);
|
||||
nerrors = arg_parse(argc,argv,argtable);
|
||||
|
||||
if (nerrors0==0)
|
||||
if (nerrors==0)
|
||||
{
|
||||
p->program_action = A_PLAY;
|
||||
p->sim_string = strdup(arg_sim->sval[0]);
|
||||
p->verbosity_count = arg_verbosity0->count;
|
||||
if (arg_cli->count > 0)
|
||||
{
|
||||
p->cli = true;
|
||||
}
|
||||
p->sim_string = arg_sim->sval[0];
|
||||
p->verbosity_count = arg_verbosity->count;
|
||||
if (arg_mqtt->count > 0)
|
||||
{
|
||||
p->mqtt = true;
|
||||
}
|
||||
if (arg_mysql->count > 0)
|
||||
{
|
||||
p->mysql = true;
|
||||
}
|
||||
if (arg_cpath->sval[0] != NULL)
|
||||
{
|
||||
p->config_path = strdup(arg_cpath->sval[0]);
|
||||
}
|
||||
exitcode = E_SUCCESS_AND_DO;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (nerrors1==0)
|
||||
{
|
||||
p->program_action = A_BROWSE;
|
||||
//p->sim_string = strdup(arg_sim->sval[0]);
|
||||
p->verbosity_count = arg_verbosity1->count;
|
||||
exitcode = E_SUCCESS_AND_DO;
|
||||
}
|
||||
}
|
||||
|
||||
// interpret some special cases before we go through trouble of reading the config file
|
||||
if (help0->count > 0)
|
||||
if (help->count > 0)
|
||||
{
|
||||
printf("Usage: %s\n", progname);
|
||||
arg_print_syntax(stdout,argtable0,"\n");
|
||||
arg_print_syntax(stdout,argtable1,"\n");
|
||||
printf("\nReport bugs on the github github.com/spacefreak18/gilles.\n");
|
||||
printf("\nReport bugs on the github github.com/spacefreak18/csimtelem.\n");
|
||||
exitcode = E_SUCCESS_AND_EXIT;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if (vers0->count > 0)
|
||||
if (vers->count > 0)
|
||||
{
|
||||
printf("%s Simulator Monitor\n",progname);
|
||||
printf("%s Simulator Hardware Manager\n",progname);
|
||||
printf("October 2022, Paul Dino Jones\n");
|
||||
exitcode = E_SUCCESS_AND_EXIT;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
cleanup:
|
||||
arg_freetable(argtable0,sizeof(argtable0)/sizeof(argtable0[0]));
|
||||
arg_freetable(argtable1,sizeof(argtable1)/sizeof(argtable1[0]));
|
||||
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
|
||||
return exitcode;
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,43 +3,19 @@
|
|||
|
||||
#include <stdbool.h>
|
||||
|
||||
#include "../simulatorapi/simapi/simapi/simapi.h"
|
||||
#include "../simulatorapi/simapi/simapi/simdata.h"
|
||||
#include "../simulatorapi/simapi/simapi/simmapper.h"
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char* sim_string;
|
||||
int program_action;
|
||||
int program_state;
|
||||
char* config_path;
|
||||
char* gnuplot_file;
|
||||
char* gnuplot_bin;
|
||||
int gnuplotfound;
|
||||
|
||||
bool cli;
|
||||
const char* sim_string;
|
||||
bool mqtt;
|
||||
bool mysql;
|
||||
bool simon;
|
||||
int verbosity_count;
|
||||
int err;
|
||||
|
||||
char* db_user;
|
||||
char* db_serv;
|
||||
char* db_dbnm;
|
||||
char* db_pass;
|
||||
char* db_conn;
|
||||
|
||||
Simulator sim;
|
||||
SimData* simdata;
|
||||
SimMap* simmap;
|
||||
}
|
||||
Parameters;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
A_PLAY = 0,
|
||||
A_BROWSE = 1,
|
||||
}
|
||||
ProgramAction;
|
||||
|
||||
|
|
@ -51,17 +27,7 @@ typedef enum
|
|||
}
|
||||
ConfigError;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
E_NO_ERROR = 0,
|
||||
E_BAD_CONFIG = 1,
|
||||
E_FAILED_DB_CONN = 2,
|
||||
E_DB_QUERY_FAIL = 3,
|
||||
}
|
||||
GillesError;
|
||||
|
||||
ConfigError getParameters(int argc, char** argv, Parameters* p);
|
||||
int freeparams(Parameters* p);
|
||||
|
||||
struct _errordesc
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
Subproject commit 51e29ec8e32cb70c455b381a84f7614f6594516f
|
||||
Subproject commit 618920440e0eb60f6209bdb4cb734b366c32780c
|
||||
Loading…
Reference in New Issue