void
goto_line(int new_line)
{
char c;
while (ln < new_line) {
if (read(entry, &c, 1) != 1 || c == '\0') notif_error("[EOF]");
if (c == '\n') ln++;
}
store_line();
ln = new_line;
}
void
copy_lines(int m)
{
int cnt = ln;
char c;
if (m < ln) notif_error("Cannot copy previous line(s)");
do {
if (read(entry, &c, 1) != 1) notif_error("Error reading entry");
if (c == '\n') cnt++;
if (write(outfile, &c, 1) != 1) notif_error("Error writing outfile");
} while (cnt <= m);
store_line();
ln = m + 1;
}
void process_test_stream(void)
{
int forever = TRUE;
char *callsign;
double lat, lon, alt;
date_time_t wall_time;
time_t last_store = 0;
init_test_data();
while (forever) {
PMU_auto_register("Got data");
get_test_data(&callsign, &lat, &lon, &alt);
/*
* substitute wall clock time for gps time
*/
wall_time.unix_time = time(NULL);
uconvert_from_utime(&wall_time);
if((wall_time.unix_time - last_store) >= Glob->params.data_interval) {
store_line(&wall_time, lat, lon, alt, callsign,
0.0, 0.0, 0.0, 0.0, 0, 0, 0, 0);
if (Glob->params.use_spdb) {
if (Glob->params.single_database) {
store_single_spdb(&wall_time, lat, lon, alt, callsign);
} else {
store_mult_spdb(&wall_time, lat, lon, alt, callsign);
}
} /* if (Glob->params.use_spdb) */
last_store = wall_time.unix_time;
} /* if((wall_time.unix_time - last_store) ... */
sleep(1);
} /* while (forever) */
free_test_data();
}
void ConfParser::parse_file(std::string filename)
{
std::ifstream infile (filename.c_str());
bool in_domains = false;
std::string line;
std::string key;
std::string value;
while( std::getline(infile, line) ) {
if (line.size() != 0) {
//Remove comments if necessary
int eol = line.find("#");
if (eol != -1) {
line = line.substr(eol,line.size()-eol);
}
std::istringstream is_line(line);
//Handle the DOMAINS array
if (in_domains) {
this->m_domains.push_back(this->handle_array_line(line));
if (line.find("]") != std::string::npos) {
in_domains = false;
}
}
//Else look for the key=value structure
else if( std::getline(is_line, key, '=') ) {
if( std::getline(is_line, value) ) {
if (key.compare("DOMAINS")==0) {
in_domains = true;
this->m_domains.push_back(this->handle_array_line(value));
}
else {
store_line(key, value);
}
}
}
else {
std::cerr << "Non-valid line in conf file: "<<line<<std::endl;
exit(EXIT_FAILURE);
}
}
}
}
void
main(int argc, char** argv)
{
if (argc < 3)
notif_error("Missing argument(s)\n");
mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH;
if ((entry = open(argv[1], O_RDONLY)) == -1)
notif_error("Cannot open entry file");
if ((outfile = open(argv[2], O_WRONLY | O_TRUNC | O_CREAT, mode)) == -1)
notif_error("Cannot open output file");
ln = 1;
store_line();
while (1) {
read_instr();
inter_instr();
}
close(entry);
close(outfile);
}
/* Does the actual processing of the frame */
static void do_work(ppu_data_t ppu_data) {
struct image input;
struct image big_image;
dprintf("SPU[%d] ppu_data.input:%p ppu_big_img:%p sizeof(struct image):%lu\n",
ppu_data.spe_id, (void *)ppu_data.input,
(void *)ppu_data.big_image, sizeof(struct image));
/* Get input image and big_image details */
mfc_get((void *)(&input), (uint32_t)(ppu_data.input),
(uint32_t)(sizeof(struct image)), tag_id, 0, 0);
mfc_get((void *)(&big_image), (uint32_t)(ppu_data.big_image),
(uint32_t)(sizeof(struct image)), tag_id, 0, 0);
waittag(tag_id);
dprintf("SPU[%d] got structs\n"\
"input.width=%u\tinput.height=%u\n"\
"big_image.width=%u\tbig_image.height=%u\n"\
"input.data=%p\tbig_image.data=%p\n",
ppu_data.spe_id, input.width, input.height, big_image.width,
big_image.height, (void *)input.data, (void *)big_image.data);
struct image img_chunk;
unsigned int buf_line_sz = input.width * NUM_CHANNELS;
int transfer_sz = 4 * buf_line_sz;
img_chunk.width = input.width;
img_chunk.height = 4;
alloc_image(&img_chunk);
struct image img_scaled_line;
img_scaled_line.width = input.width / SCALE_FACTOR;
img_scaled_line.height = 1;
/* Hack for memory align of local image data to have the same 4 bits in its
* address as the remote corresponding address in PPU
*/
int left_padding = (ppu_data.spe_id % 4) * 4;
unsigned char* addr_to_free = malloc_align(NUM_CHANNELS * 3 * sizeof(char) +
left_padding, 4);
img_scaled_line.data = addr_to_free + left_padding;
unsigned int i;
/* Process 4 lines from the initial image at a time */
for (i = 0; i < input.height / img_chunk.height; ++i) {
/* Get the image chunk from PPU through DMA transfer */
dprintf("SPU[%d] getting image_chunk %d of size %d\n",
ppu_data.spe_id, i, transfer_sz);
dprintf("SPU[%d] input.data=%p img_chunk.data=%p "\
"start_addr=%p\n", ppu_data.spe_id, (void *)input.data,
(void *)img_chunk.data, (void *)((uint32_t)(input.data) + i * transfer_sz));
mfc_get((void *)(img_chunk.data), (uint32_t)(input.data) + i * transfer_sz,
(uint32_t)(transfer_sz), tag_id, 0, 0);
waittag(tag_id);
dprintf("SPU[%d] got image_chunk %d\n", ppu_data.spe_id, i);
compute_lines_average(&img_chunk, buf_line_sz);
/* Make average for column. avg = (c0.r + c1.r) / 2 etc*/
compute_columns_average(&img_chunk, &img_scaled_line);
store_line(&img_scaled_line, ppu_data, &big_image, i);
}
free_image(&img_chunk);
free_align(addr_to_free);
}
void process_realtime_stream(FILE *tty_file)
{
int forever = TRUE;
char line[BUFSIZ];
char spaced_line[BUFSIZ];
char callsign[8];
int ilat, ilon;
int itas, igps_alt, ipres_alt;
int itdry, ilwjw, idewpt;
int ice_count;
int left_burn, right_burn, flare_state, snowmax_state;
int igps_var, igps_err, iarnav_warn;
date_time_t gps_time, wall_time;
time_t last_store = 0;
while (forever) {
/*
* wait for data, registering once per second while waiting
*/
while (ta_read_select(tty_file, 1000) != 1) {
PMU_auto_register("Waiting for data");
}
PMU_auto_register("Got data");
if (fgets(line, BUFSIZ, tty_file) == NULL) {
fprintf(stderr, "ERROR - %s:process_stream\n", Glob->prog_name);
perror(Glob->params.input_device);
return;
}
add_spaces(line, spaced_line);
if (Glob->params.debug) {
fprintf(stderr, "Input line:\n%s", line);
fprintf(stderr, "Spaced line:\n%s\n", spaced_line);
}
if (sscanf(spaced_line,
"%s %d %d %d %d %d %d %d %d %d"
"%d %d %d %d %2d %2d %2d %d %d %d",
callsign, &ilat, &ilon, &itas, &igps_alt, &ipres_alt,
&itdry, &ilwjw, &idewpt, &ice_count,
&left_burn, &right_burn, &flare_state, &snowmax_state,
&gps_time.hour, &gps_time.min, &gps_time.sec,
&igps_var, &igps_err, &iarnav_warn) == 20) {
if (Glob->params.debug) {
fprintf(stderr, "Decoding : %s", line);
fprintf(stderr, "Callsign : %s\n", callsign);
fprintf(stderr, "lat : %g\n", ilat / 10000.0);
fprintf(stderr, "lon : %g\n", ilon / 10000.0);
fprintf(stderr, "tas : %d\n", itas);
fprintf(stderr, "gps_alt : %g\n", igps_alt / 100.0);
fprintf(stderr, "pres_alt : %g\n", ipres_alt / 100.0);
fprintf(stderr, "tdry : %g\n", itdry / 10.0);
fprintf(stderr, "lwJW : %g\n", ilwjw / 100.0);
fprintf(stderr, "dewpt : %g\n", idewpt / 10.0);
fprintf(stderr, "left burn : %d\n", left_burn);
fprintf(stderr, "right burn : %d\n", right_burn);
fprintf(stderr, "flare state: %d\n", flare_state);
fprintf(stderr, "snow state : %d\n", snowmax_state);
fprintf(stderr, "time : %.2d:%.2d:%.2d\n",
gps_time.hour, gps_time.min, gps_time.sec);
fprintf(stderr, "gps var : %d\n", igps_var);
fprintf(stderr, "gps err : %d\n", igps_err);
fprintf(stderr, "arnav code : %d\n", iarnav_warn);
}
/*
* substitute wall clock time for gps time
*/
wall_time.unix_time = time(NULL);
uconvert_from_utime(&wall_time);
if((wall_time.unix_time - last_store) >= Glob->params.data_interval) {
store_line(&wall_time,
(double) ilat / 10000.0,
(double) ilon / 10000.0,
(double) ipres_alt / 100.0,
callsign,
itas,
(double) itdry / 10.0,
(double) ilwjw / 100.0,
(double) idewpt / 10.0,
left_burn,
right_burn,
flare_state,
snowmax_state);
if (Glob->params.use_spdb) {
if (Glob->params.single_database) {
store_single_spdb(&wall_time,
(double) ilat / 10000.0,
(double) ilon / 10000.0,
(double) ipres_alt / 100.0,
callsign);
} else {
store_mult_spdb(&wall_time,
(double) ilat / 10000.0,
(double) ilon / 10000.0,
(double) ipres_alt / 100.0,
callsign);
}
} /* if (Glob->params.use_spdb) */
last_store = wall_time.unix_time;
} /* if((wall_time.unix_time - last_store) ... */
} else {
if (Glob->params.debug) {
fprintf(stderr, "WARNING - %s:process_stream\n", Glob->prog_name);
fprintf(stderr, "Cannot decode: %s\n", (char *) spaced_line);
}
}
} /* while (forever) */
}
