void do_job(int job, type t, const char* work_path)
{
//won't return until the vina job has been done
char cmd[MAX_CMD_LEN];
char conf[MAX_FILENAME];
printf("%d do job \n", t);
gen_filename(conf, job, CONF);
if (t == CPU)
{
strcpy(cmd, "cd ");
strcat(cmd, work_path);
strcat(cmd, " && ");
strcat(cmd, "./vina --config ");
strcat(cmd, conf);
strcat(cmd, "> /dev/null");
} else {
strcpy(cmd, "ssh mic0 \"");
strcat(cmd, "cd ");
strcat(cmd, work_path);
strcat(cmd, " && ");
strcat(cmd, "./vina_mic --config ");
strcat(cmd, conf);
strcat(cmd, "> /dev/null \"");
}
system(cmd);
}
void write_registers_tofile(mbdport *mp, element *pv, logging *lp, mbdinfo *mip)
{
FILE *fp;
int i;
int j;
int saved_err;
char *logfilename;
char logpath[MAX_PATH_LEN];
logfilename = gen_filename(mip->uuid);
snprintf(logpath, sizeof(logpath), "%s/%s", lp->sens_logdir,
logfilename);
if (lp->verbosity == LOG_VERBOSE)
logger("writing to sensor log directory", lp, mip);
if ((fp = fopen(logpath, "w")) == NULL) {
saved_err = errno;
err("can't open sensor log directory to write data", lp, mip,
saved_err);
}
for (j = 0; j < mp->read_count; j++) {
int ix = posmatch(j, 0, mp->read_count, pv);
if (ix == -1)
continue;
char outstring[512];
char buf[80];
strcpy(outstring, SENSOR_READING_HEADER);
for (i = 0; i < mp->read_count; i++) {
ix = posmatch(j, i, mp->read_count, pv);
if (ix == -1)
continue;
snprintf(buf, sizeof(buf), ",%s:%.2f",
pv[ix].tag, pv[ix].value_scaled);
strcat(outstring, buf);
}
fputs(outstring, fp);
fputc('\n', fp);
}
fclose(fp);
free(logfilename);
}
// Members of class DIR
int
conv_dir(DIRENTRY* flights, lpb p, int countonly)
{
int number_of_flights;
DIRENTRY de; // directory entry
byte Haupttyp, Untertyp;
byte l; // length of DS
lpb p2; // Pointer to the beginning of the content of a vrb or vrt
tm olddate;
memset(&olddate, 0, sizeof(olddate));
int olddate_flg = 0;
int flight_of_day = 0;
long temptime;
tm timetm1;
memset(&timetm1, 0, sizeof(timetm1));
int bfv = 0;
number_of_flights = 0;
char pilot1[17];
char pilot2[17];
char pilot3[17];
char pilot4[17];
memset(&de, 0, sizeof(de));
while (1) {//number_of_flights < MAXDIRENTRY) {
Haupttyp = (p[0] & rectyp_msk);
switch (Haupttyp) {
case rectyp_sep: // Initialize Dir-Entry
de.serno = 0;
de.pilot[0] = 0;
pilot1[0] = 0;
pilot2[0] = 0;
pilot3[0] = 0;
pilot4[0] = 0;
de.takeoff = 0;
de.filename[0] = 0;
bfv = p[0] & ~rectyp_msk;
if (bfv > max_bfv)
return -1;
l = 1;
break;
case rectyp_vrt: // getim'ter variabler DS oder
case rectyp_vrb: // ungetim'ter variabler DS
l = p[1];
switch (Haupttyp) {
case rectyp_vrb:
p2 = p + 2;
break;
case rectyp_vrt:
p2 = p + 3;
break;
default:
p2 = p;
break;
}
Untertyp = (p2[0]);
switch (Untertyp) {
case FLDCID: // Read pilotname
memcpy(de.competitionid, &p2[1], sizeof(de.competitionid));
de.competitionid[sizeof(de.competitionid) - 1] = 0;
break;
case FLDGID: // Read pilotname
memcpy(de.gliderid, &p2[1], sizeof(de.gliderid));
de.gliderid[sizeof(de.gliderid) - 1] = 0;
break;
case FLDPLT1: // Read pilotname
memcpy(pilot1, &p2[1], sizeof(pilot1));
pilot1[sizeof(pilot1) - 1] = 0;
break;
case FLDPLT2: // Read pilotname
memcpy(pilot2, &p2[1], sizeof(pilot2));
pilot2[sizeof(pilot2) - 1] = 0;
break;
case FLDPLT3: // Read pilotname
memcpy(pilot3, &p2[1], sizeof(pilot3));
pilot3[sizeof(pilot3) - 1] = 0;
break;
case FLDPLT4: // Read pilotname
memcpy(pilot4, &p2[1], sizeof(pilot4));
pilot4[sizeof(pilot4) - 1] = 0;
break;
case FLDHDR: // Read serial number
de.serno = 256 * p2[1] + p2[2];
break;
case FLDETKF: // set takeoff flag
de.takeoff = 1;
break;
}
break;
case 0xC0:
l = 1;
break;
case rectyp_pos:
l = pos_ds_size[bfv][0];
break;
case rectyp_poc:
if (p[2] & 0x80) { // Endebedingung
return number_of_flights;
}
l = pos_ds_size[bfv][1];
break;
case rectyp_tnd:
// speichert in timetm1 den aktuellen tnd-DS ab
temptime = 65536L * p[2] + 256L * p[3] + p[4];
timetm1.tm_sec = temptime % 3600;
timetm1.tm_hour = temptime / 3600;
timetm1.tm_min = 0;
timetm1.tm_mday = 10 * (p[7] >> 4) + (p[7] & 0x0f);
timetm1.tm_mon = 10 * (p[6] >> 4) + (p[6] & 0x0f) - 1;
timetm1.tm_year = 10 * (p[5] >> 4) + (p[5] & 0x0f);
// Y2K-handling
if (timetm1.tm_year < 80)
timetm1.tm_year += 100;
timetm1.tm_isdst = -1;
//JMW TODO mktime(&timetm1);
l = 8;
break;
case rectyp_end:
if (!countonly) {
// setzt firsttime und lasttime aufgrund der Werte im sta-DS
temptime = 65536L * p[4] + 256L * p[5] + p[6]; // Aufzeichnungsbeginn
de.firsttime = timetm1;
de.firsttime.tm_sec -= temptime % 3600;
de.firsttime.tm_hour -= temptime / 3600;
de.firsttime.tm_isdst = -1;
//JMW TODO mktime(&de.firsttime);
de.lasttime = de.firsttime;
temptime = 65536L * p[1] + 256L * p[2] + p[3]; // Aufzeichnungsdauer
de.recordingtime = temptime;
de.lasttime.tm_sec += temptime % 3600;
de.lasttime.tm_hour += temptime / 3600;
de.lasttime.tm_isdst = -1;
//JMW TODO mktime(&de.lasttime);
if (!olddate_flg) {
olddate = de.firsttime;
flight_of_day = 0;
olddate_flg = 1;
}
if ((olddate.tm_mday == de.firsttime.tm_mday) && (olddate.tm_mon
== de.firsttime.tm_mon)
&& (olddate.tm_year == de.firsttime.tm_year))
flight_of_day++;
else {
olddate = de.firsttime;
flight_of_day = 1;
olddate_flg = 1;
}
strcat(de.pilot, pilot1);
strcat(de.pilot, pilot2);
strcat(de.pilot, pilot3);
strcat(de.pilot, pilot4);
gen_filename(&de, flight_of_day);
flights[number_of_flights] = de;
}
number_of_flights++;
l = 7;
break;
default:
return -1;
};
p += l;
}
return -1;
}
int main(int argc, char* argv[])
{
int i = 0;
int fd;
struct pollfd* mfds = (struct pollfd*)calloc(1, sizeof(struct pollfd));
int mfd_count = 0;
int nr;
struct input_event event;
int store_fd;
char** dev_name;
if(argc < 2)
{
fprintf(stderr, "error input\n");
usage(argv[0]);
exit(-1);
}
if(strcmp(argv[1], "a1") == 0)
{
dev_name = dev_name_a1;
}
else if (strcmp(argv[1], "a310") == 0)
{
dev_name = dev_name_a310;
}
else if (strcmp(argv[1], "a810") == 0)
{
dev_name = dev_name_a810;
}
else
{
fprintf(stderr, "error input argv[1]: %s\n", argv[1]);
usage(argv[0]);
exit(-1);
}
i = 0;
while(dev_name[i] != NULL)
{
printf("open %s\n", dev_name[i]);
fd = open_dev(dev_name[i]);
if(fd > 0)
{
struct pollfd* new_mfds = (struct pollfd*)realloc(mfds, sizeof(struct pollfd)*(mfd_count + 1));
if(new_mfds == NULL)
{
fprintf(stderr, "realloc out of memeory\n");
return -1;
}
mfds = new_mfds;
mfds[i].fd = fd;
mfds[i].events = POLLIN;
mfd_count++;
}
i++;
}
//open store file
store_fd = open(gen_filename(), O_RDWR|O_CREAT);
if(store_fd < 0)
{
fprintf(stderr, "fail to open record file\n");
exit(-1);
}
while(1)
{
nr = poll(mfds, mfd_count, 0);
if(nr <= 0)
continue;
for(i = 0; i < mfd_count; i++)
{
if(mfds[i].revents == POLLIN)
{
int ret = read(mfds[i].fd, &event, sizeof(event));
if(ret == sizeof(event))
{
show_event(&event);
store_event(store_fd, &event);
}
}
}
}
return 0;
}
