FILE *reinit_timer(FILE *port, char *name, int config, int lanes_expected)
{
FILE *fd;
char tmp[LINE_LEN];
int lanes;
printf("Wow, something's messed with your timer. Let's try again.\n");
close_timer(port);
printf("Please power cycle your timer.\n");
printf("If you have a USB timer, just unplug it, wait a few seconds, and reconnect\n");
printf("it to the SAME port.\n");
printf("\nWhen you're done, press Enter and we'll try to get reconnected.\n");
retry:
fgets(tmp, LINE_LEN, stdin);
printf("Opening port.\n");
fd = open_timer(name, config);
if (!fd) {
printf("Eek! Unable to open timer port! Please power cycle it again.\n");
printf("Double-check that you plugged your USB timer into the same port!\n");
printf("Press Enter to try again. (Ctrl-C to give up - you will lose all results.)\n");
goto retry;
}
/* reset timer */
lanes = init_timer(fd);
if (lanes != lanes_expected) {
close_timer(fd);
printf("Eek! Invalid number of lanes! (Expected %d, got %d from timer.\n", lanes_expected, lanes);
printf("Please power cycle your timer again and check all sensor connections.\n");
printf("Press Enter to try again. (Ctrl-C to give up - you will lose all results.)\n");
goto retry;
}
return fd;
}
int connector::connect_handler(file_io&, int type) {
int n;
socklen_t len;
if (type & reactor::poll_close) {
_fd.close();
return fail;
}
if (type & (reactor::poll_out | reactor::poll_err)) {
close_timer();
len = sizeof(int);
ll_sys_failed_return(getsockopt(_fd, SOL_SOCKET, SO_ERROR, &n, &len));
if (n || (type & reactor::poll_err)) {
if (ll_ok(do_emit(_fd, reactor::poll_err))) {
if (_interval) {
_timer = _timermgr->schedule(_conntime + _interval, &connector::timer_handler, this);
return fail;
}
}
return fail;
}
else {
_timer = _timermgr->idle(&connector::connect_ready, this);
return ok;
}
}
return ok;
}
void connector::close()
{
if (!_emitting) {
if (_fd.opened()) {
_reactor->close(_fd);
}
close_timer();
}
}
void tcpudp_act_cyc(uint8_t cycact)
{
switch (cycact)
{
case 0:
tcpip_flag_ = 0;
close_timer();
break;
case 1:
tcpip_flag_ = 1;
open_timer();
break;
default:
break;
}
}
/* lua call spec:
Success: status(true), nil = timer:start(timeout)
Failure: status(false), error message = timer:start(timeout)
*/
static int start_user_timer(lua_State* l_thread) {
LUA_GET_TIMER_OR_ERROR(l_thread, 1, timer);
if (timer->state != INIT) {
/* Timer is already started by another lua thread */
return error_to_lua(l_thread, "Timer already in use by another thread");
}
int timeout = lua_tointeger(l_thread, 2);
if (timeout <= 0) {
return error_to_lua(l_thread, "Invalid timeout value %d specified", timeout);
}
int rc = uv_timer_start(&timer->handle, on_user_timer_timeout, timeout, 0);
if (rc) {
close_timer(timer);
return error_to_lua(l_thread, "Error starting timer: %s", uv_strerror(rc));
}
timer->state = TICKING;
lua_pushboolean(l_thread, 1);
return 1;
}
LUA_OBJ_METHOD static int timer_gc(lua_State *L) {
LUA_GET_TIMER_OR_RETURN(L, 1, timer);
close_timer(timer);
return 0;
}
LUA_OBJ_METHOD static int close_timer_lua(lua_State* l_thread) {
LUA_GET_TIMER_OR_RETURN(l_thread, 1, timer);
close_timer(timer);
return 0;
}
/**
* @brief Parses command line options and implements application logic
*
* @param argc number of arguments in the command line
* @param argv table with command line argument strings
*
* @return Process exit code
*/
int main(int argc, char *argv[])
{
const long long freq_nanosecs = freq_ms * 1000LL * 1000LL;
int core_id, lock_data = 1, exit_val = EXIT_SUCCESS;
if (argc < 3) {
printf("Usage: %s <core_id> <lock|nolock>\n", argv[0]);
exit(EXIT_FAILURE);
}
if (strcasecmp(argv[2], "nolock") != 0 &&
strcasecmp(argv[2], "lock") != 0) {
printf("Invalid data lock setting '%s'!\n", argv[2]);
printf("Usage: %s <core_id> <lock|nolock>\n", argv[0]);
exit(EXIT_FAILURE);
}
core_id = atoi(argv[1]);
lock_data = (strcasecmp(argv[2], "nolock") == 0) ? 0 : 1;
/* allocate memory blocks */
main_data_ptr = init_memory(main_data_size);
timer_data_ptr = init_memory(timer_data_size);
if (main_data_ptr == NULL || timer_data_ptr == NULL) {
exit_val = EXIT_FAILURE;
goto error_exit1;
}
if (lock_data) {
/* initialize PQoS and lock the data */
if (init_pqos() != 0) {
exit_val = EXIT_FAILURE;
goto error_exit1;
}
/* lock the timer data */
if (dlock_init(timer_data_ptr,
timer_data_size, 1 /* CLOS */, core_id) != 0) {
printf("Pseudo data lock error!\n");
exit_val = EXIT_FAILURE;
goto error_exit1;
}
}
tsc_init(&timer_prof, "Timer Handler");
if (init_timer(freq_nanosecs) != 0) {
printf("Timer start error!\n");
exit_val = EXIT_FAILURE;
goto error_exit2;
}
main_thread((char *)main_data_ptr, main_data_size);
(void) close_timer();
tsc_print(&timer_prof);
error_exit2:
if (lock_data)
dlock_exit();
error_exit1:
if (lock_data)
(void) close_pqos();
if (main_data_ptr != NULL)
free(main_data_ptr);
if (timer_data_ptr != NULL)
free(timer_data_ptr);
return exit_val;
}
int main(int argc, char **argv)
{
FILE *port;
char *filename;
int c, i, j, tmp;
int debugmode = 0;
int lanes;
float times[MAX_LANES];
float prev_times[MAX_LANES][4];
int prev_head = 0;\
char *tmpbuf[10];
/* parse command line options */
if (argc == 1) {
usage();
return 0;
}
opterr = 0;
while ((c = getopt (argc, argv, "dp:")) != -1) {
switch (c) {
case 'd':
printf("Debugging mode enabled\n");
debugmode = 1;
break;
case 'p':
filename = optarg;
break;
case '?':
default:
usage();
return 1;
}
}
/* open timer */
port = open_timer(filename, !debugmode);
if (!port) {
fprintf(stderr, "Eek! Unable to open timer port! Cannot continue.\n");
fprintf(stderr, "Possible problems:\n");
fprintf(stderr, "\tbad filename for port (if USB timer, check dmesg for port id\n");
fprintf(stderr, "\tno write access to device (check permissions or run as root)\n");
fprintf(stderr, "\tUSB timer not connected\n");
return 1;
}
/* reset timer */
lanes = init_timer(port);
if (!lanes) {
fprintf(stderr, "Eek! Cannot initialize timer! Cannot continue!\n");
fprintf(stderr, "Make sure your timer is supported by this program.\n");
close_timer(port);
return 1;
}
memset(prev_times, 0, sizeof(float) * 3 * MAX_LANES);
printf("Press enter to continue.\n");
fgets(tmpbuf, 10, stdin);
/* main loop */
while (1) {
printf("Begin racing when ready.\n");
tmp = get_times(port, lanes, times, debugmode);
printf("Run is complete. Results:\n");
if (tmp > 0) {
/* good race! */
display_winner(tmp);
printf("\n");
// save current time, drop last time
display_times(lanes, times);
for (j = 0; j < lanes; j++) {
prev_times[j][prev_head] = times[j];
}
printf("\nPrevious results:\n");
i = prev_head - 1;
if (i < 0)
i = 3;
while (i != prev_head) {
for (j = 0; j < lanes; j++)
printf("\t%1.4f", prev_times[j][i]);
printf("\n");
i--;
if (i < 0)
i = 3;
}
prev_head++;
if (prev_head == 4)
prev_head = 0;
}
if (tmp == 0) {
printf("Null race result! Please redo this run.\n");
}
if (tmp < 0) {
port = reinit_timer(port, filename, !debugmode, lanes);
/* if this returns, we've succeeded */
}
printf("Press enter to continue, X to exit.\n");
fgets(tmpbuf, 10, stdin);
if (strchr(tmpbuf, 'x') || strchr(tmpbuf, 'X'))
break;
rearm_timer(port, debugmode);
}
/* all done */
printf("\nDone.\n");
close_timer(port);
return 0;
}
