void Compression::compress_huffman() {
std::map<int, int> frequency = calculate_frequency(*reader);
BinaryTree tree(frequency);
print_tree(tree);
PrefixCodes prefix_codes(tree);
prefix_codes.print_stdout();
write_coded_file(reader, writer, prefix_codes);
}
/*************************************************************************
* Function Name: Timer0IntrHandler
* Parameters: none
*
* Return: none
*
* Description: Timer 0 interrupt handler
*
*************************************************************************/
void Timer0IntrHandler (void)
{
update_touch_coordinates();
// FIO0PIN_bit.P0_19 = 1;
// ========== LCD - touch meassurement loop: START
switch_touch_meassure_channel();
// ========== LCD - touch meassurement loop: STOP
// if (Touch_data.state==(Y_ch || confirm))
// FIO0PIN_bit.P0_11 = 1;
adc_start(); //Start the ADC, ADC will be done before next timer interrupt
//it has higer priority and will therefore be handlet first
httpd_tick_count++;
if((httpd_tick_count)%(TIMER0_TICK_PER_SEC/HTTPD_TICK_PER_SEC) == 0) {
httpd_tick();
httpd_tick_count = 0;
}
tick_count++;
update_real_time();
//calculate_p_p_values();
//frequency calculation: START
//frequency calculation: STOP
if(detect_ZeroCrossing(ADdata.previous_filtered_measurement, ADdata.current_filtered_measurement))
{
//Calculate RMS value
V_RMS = calculate_X_RMS(V_RMS_2_accumulator);
I_RMS = calculate_X_RMS(I_RMS_2_accumulator);
P_RMS = ((P_RMS_2_accumulator)/(tick_count));
//CAlculate peak value from RMS value
ADC_p_p.v_max = sqrt(2)*V_RMS;
ADC_p_p.v_min = -sqrt(2)*V_RMS;
//Clear RMS accumulator
V_RMS_2_accumulator=0.0;
I_RMS_2_accumulator=0.0;
P_RMS_2_accumulator=0.0;
calculate_frequency(tick_count);
tick_count=0;
}
dac_timer++;
if(dac_timer == DAC_MAXIMUM) {
dac_timer = 0;
blink_timer++;
if(blink_timer == FREQUENCY/5) {
toggle_led(1);
// toggle_led(2);
blink_timer = 0;
f_out = frequency;
if(Relay1_button_state==1)
FIO0PIN_bit.P0_11 = 1;
else{
if(frequency>=RELAY_ON_FREQUENCY && relays_status(bulb) != 1) {
toggle_relays(bulb, 1);
}
else if(frequency<=RELAY_OFF_FREQUENCY && relays_status(bulb) != 0){
toggle_relays(bulb, 0);
}
}
if(Relay2_button_state==1)
FIO0PIN_bit.P0_19 = 1;
else{
if(frequency>=RELAY_ON_FREQUENCY && relays_status(socket) != 1) {
toggle_relays(socket, 1);
}
else if(frequency<=RELAY_OFF_FREQUENCY && relays_status(socket) != 0){
toggle_relays(socket, 0);
}
}
}
}
// Write data to DAC
dac_write(Data);
// clear interrupt
timer0_interrupt_reset();
// FIO0PIN_bit.P0_19 = 0;
// FIO0PIN_bit.P0_11 = 0;
VICADDRESS = 0;
}
int main( int argc, char *argv[] )
{
bool print_usage_and_exit = false;
bool generate = false;
long number_count = 100;
bool has_number_count = false;
int number_min = 1;
bool has_number_min = false;
int number_max = 255;
bool has_number_max = false;
int seed = 0;
bool has_seed = false;
const char* ifile_name = NULL;
const char* ofile_name = NULL;
const char* cfile_name = NULL;
///overallocate the numbers a bit, just in case
int* number_array = malloc(sizeof(int)*argc);
size_t number_array_size = 0;
if (!number_array)
{
printf("error allocating, somethings wrong\n");
exit(-1);
}
for (int i = 1; i < argc; ++i)
{
const char* argi = argv[i];
//if (atoi(argi) != 0 || arg_is_zero(argi))
if (atoi(argi) != 0 || arg_is_zero(argi))
{
///this was a number input
number_array[number_array_size] = atoi(argi);
number_array_size++;
continue;
}
char dash = argi[0];
if (strlen(argi) != 2 || dash != '-')
{
print_usage();
return -1;
}
char flag = argi[1];
if (flag == 'u')
{
if (print_usage_and_exit) {
///Example: ./Lab1 -u -u
print_usage();
return -1;
}
print_usage_and_exit = true;
continue;
}
if (flag == 'g')
{
if (generate || number_array_size > 0) {
///Example: ./Lab1 -g -g
///Example: ./Lab1 -g 5 5
print_usage();
return -1;
}
generate = true;
continue;
}
if (!(i + 1 < argc))
{
///Example: ./Lab1 -m
print_usage();
return -1;
}
if (flag == 'n')
{
if (has_number_count)
{
///Example: ./Lab1 -n <number> -n <number>
print_usage();
return -1;
//continue;
}
const char* next_arg_i = argv[i+1];
char* next_arg_i_end = NULL;
has_number_count = true;
number_count = strtol( /*first character in string*/next_arg_i
, /*this will change the end pointer point to the last character strtol parses as a number*/
&next_arg_i_end
, /*base*/10);
if (number_count == 0 && arg_is_not_zero(next_arg_i))
{
///Example: ./Lab1 -n NOTANUMBER
print_usage();
return -1;
}
i++;
continue;
}
if (flag == 'm')
{
if (has_number_min)
{
///Example: ./Lab1 -m <min> -m <min>
print_usage();
return -1;
}
const char* next_arg_i = argv[i+1];
char* next_arg_i_end = NULL;
has_number_min = true;
number_min = strtol( /*first character in string*/next_arg_i
, /*this will change the end pointer point to the last character strtol parses as a number*/
&next_arg_i_end
, /*base*/10);
if (number_min == 0 && arg_is_not_zero(next_arg_i))
{
///Example: ./Lab1 -m NOTANUMBER
print_usage();
return -1;
}
i++;
continue;
}
if (flag == 'M')
{
if (has_number_max)
{
///Example: ./Lab1 -M <max> -M <max>
print_usage();
return -1;
}
const char* next_arg_i = argv[i+1];
char* next_arg_i_end = NULL;
has_number_max = true;
number_max = strtol( /*first character in string*/next_arg_i
, /*this will change the end pointer point to the last character strtol parses as a number*/
&next_arg_i_end
, /*base*/10);
if (number_max == 0 && arg_is_not_zero(next_arg_i))
{
///Example: ./Lab1 -M NOTANUMBER
print_usage();
return -1;
}
i++;
continue;
}
if (flag == 's')
{
if (has_seed)
{
///Example: ./Lab1 -s <seed> -s <seed>
print_usage();
return -1;
}
const char* next_arg_i = argv[i+1];
char* next_arg_i_end = NULL;
has_seed = true;
seed = strtol( /*first character in string*/next_arg_i
, /*this will change the end pointer point to the last character strtol parses as a number*/
&next_arg_i_end
, /*base*/10);
if (seed == 0 && arg_is_not_zero(next_arg_i))
{
///Example: ./Lab1 -s NOTANUMBER
print_usage();
return -1;
}
i++;
continue;
}
if (flag == 'i')
{
if (ifile_name != NULL)
{
///Example: ./Lab1 -i INPUTFILE -i INPUTFILE
print_usage();
return -1;
}
ifile_name = argv[i+1];
i++;
continue;
}
if (flag == 'o')
{
if (ofile_name != NULL)
{
///Example: ./Lab1 -o OUTPUTFILE -o OUTPUTFILE
print_usage();
return -1;
}
ofile_name = argv[i+1];
i++;
continue;
}
if (flag == 'c')
{
if (cfile_name != NULL)
{
///Example: ./Lab1 -c OUTPUTFILE -c OUTPUTFILE
print_usage();
return -1;
}
cfile_name = argv[i+1];
i++;
continue;
}
}
if (print_usage_and_exit)
{
print_usage();
exit(0);
}
if (ifile_name)
{
free(number_array);
number_array = get_input_from_file(ifile_name, &number_array_size);
}
FILE* ofile = NULL;
if (ofile_name)
{
ofile = fopen(ofile_name, "w");
if (!ofile)
{
printf("Cannot open %s for writing\n", ofile_name);
exit(-1);
}
}
FILE* cfile = NULL;
if (cfile_name)
{
cfile = fopen(cfile_name, "w");
if (!cfile)
{
printf("Cannot open %s for writing\n", cfile_name);
exit(-1);
}
}
if (!generate && number_array_size == 0)
{
fprintf(stdout, "Enter the number count\n");
fflush(stdout);
free(number_array);
int ret = fscanf(stdin, "%zi", &number_array_size);
fgetc(stdin);
if (ret == EOF)
{
fprintf(stdout, "Error reading from command line\n");
exit(-1);
}
number_array = (int*)malloc(sizeof(int)*number_array_size);
for (int i = 0; i < number_array_size; ++i)
{
int value;
int ret = fscanf(stdin, "%i", &value);
if (ret == EOF)
{
fprintf(stdout, "Error reading from command line\n");
exit(-1);
}
fgetc(stdin);
number_array[i] = value;
}
}
sort_nums(number_array, number_array_size);
if (generate)
{
if(has_number_count)
{
if(has_number_max && has_number_min && !(has_seed) && !(ofile)) //3
min_num_Max(number_count, number_min, number_max);
if(has_number_max && has_number_min && has_seed && ofile) // 1
min_num_Max_seed(number_count, number_min, number_max, seed, ofile);
if(has_number_max && has_number_min && has_seed && !(ofile)) // 2 //7
min_num_Max_seed_Nf(number_count, number_min, number_max, seed);
else if(has_number_max && !(has_number_min) && !(has_seed) && !(ofile)) // 15
max_num(number_count,number_max);
else if (has_number_min &&!(has_number_max) && !(has_seed) && !(ofile)) //4
min_num(number_count,number_min);
else if(has_number_max && !(has_number_min) && (has_seed)&& !(ofile)) //12
max_num_seed(number_count,number_max,seed);
else if (has_number_min &&!(has_number_max) && (has_seed) && !(ofile) ) //5
min_num_seed(number_count,number_min,seed);
else if (has_number_min &&!(has_number_max) && !(has_seed) && (ofile) ) //6
min_num_of(number_count,number_min,ofile);
else if (has_number_min && (has_number_max) && !(has_seed) && (ofile) ) //8 // I have problem here
min_max_num_of(number_count,number_min,number_max,ofile);
else if (!(has_number_min) && (has_number_max) && !(has_seed) && (ofile) ) //9 // I am heve problem
max_num_of(number_count,number_max,ofile);
else if (!(has_number_min) && !(has_number_max) && (has_seed) && (ofile) ) //10 // completed
num_seed_of(number_count,seed,ofile);
else if (!(has_number_min) && !(has_number_max) && !(has_seed) && (ofile) ) //11 // result in negative
num_of(number_count,ofile);
else if(has_seed && !(has_number_min) && !(has_number_max) && !(ofile)) //14 // good
random_case_generator_seed(number_count,seed);
else if (!(has_number_min) && (has_number_max) && (has_seed) && (ofile) ) //13 // good
max_num_of_seed(number_count,number_max,seed,ofile);
if(has_number_count && !(has_seed) && !(has_number_max) && !(has_number_min) && !(ofile)) //16
random_num_generator(number_count);
if (has_number_count)
{
goto here;
}
}
if(!(has_number_count))
{
if(has_number_max && has_number_min && !(has_seed) && !(ofile)) //3 /////////////// Done
min_num_Max_nd(number_min, number_max);
if(has_number_max && has_number_min && has_seed && ofile) // 1 /////////////////Done
min_num_Max_seed_nd( number_min, number_max, seed, ofile); //done
if(has_number_max && has_number_min && has_seed && !(ofile)) // 2 //7 ////////////// Done
min_num_Max_seed_Nf_nd( number_min, number_max, seed);
else if(has_number_max && !(has_number_min) && !(has_seed) && !(ofile)) // 15 /////////// Done
max_num_nd(number_max);
else if (has_number_min &&!(has_number_max) && !(has_seed) && !(ofile)) //4 //////////// Done
min_num_nd(number_min);
else if(has_number_max && !(has_number_min) && (has_seed)&& !(ofile)) //12 /////////// Done
max_num_seed_nd(number_max,seed);
else if (has_number_min &&!(has_number_max) && (has_seed) && !(ofile) ) //5 /////////// Done
min_num_seed_nd(number_min,seed);
else if (has_number_min &&!(has_number_max) && !(has_seed) && (ofile) ) //6 //////////// Done
min_num_of_nd(number_min,ofile);
else if (has_number_min && (has_number_max) && !(has_seed) && (ofile) ) //8 //////////// Done
min_max_num_of_nd(number_min,number_max,ofile);
else if (!(has_number_min) && (has_number_max) && !(has_seed) && (ofile) ) //9 //////////// Done
max_num_of_nd(number_max,ofile);
else if (!(has_number_min) && !(has_number_max) && (has_seed) && (ofile) ) //10 //////////// Done
num_seed_of_nd(seed,ofile);
else if (!(has_number_min) && !(has_number_max) && !(has_seed) && (ofile) ) //11 //////////// Problem
num_of_nd(ofile);
else if(has_seed && !(has_number_min) && !(has_number_max) && !(ofile)) //14 // good //////// Done
random_case_generator_seed_nd(seed);
else if (!(has_number_min) && (has_number_max) && (has_seed) && (ofile) ) //13 // good /////// Done
max_num_of_seed_nd(number_max,seed,ofile);
if (!(has_number_count) && !(has_seed) && !(has_number_max) && !(has_number_min) && !(ofile)) //// Done
{
random_case_generator();
}
}
here:
printf("");
}
else {
///get input from user
const char* userid = getenv("USER");
size_t useridlen = strlen(userid);
Begin_clock();
for (int i = 0; i < useridlen; ++i)
{
char c = userid[i];
int freq = calculate_frequency(c, number_array, number_array_size);
if (cfile) fprintf(cfile, "%c %d\t%d\n", c, (int)c, freq);
if (!cfile) fprintf(stdout, "%c %d\t%d\n", c, (int)c, freq);
}
if (ofile) {
for (int i = 0; i < number_array_size; ++i)
{
fprintf(ofile, "%d\n", number_array[i]);
}
fprintf(ofile, "\n");
}
if (!ofile) {
for (int i = 0; i < number_array_size; ++i)
{
printf("\n");
fprintf(stdout, "%d\t", number_array[i]);
}
printf("\n");
}
Eng_clock();
Calculate_Time();
}
return 0;
}
/***********************************
* MAIN
* *********************************/
int main(int argc, char *argv[]){
Connection connection;
write_error_ptr = &write_error; //initialize the function pointer to write error
//parse arguments
if(argc == 4){
//first argument is always name of program or empty string
connection.planebone_ip=argv[1];
connection.port_number_server_to_planebone=atoi(argv[2]);
connection.port_number_planebone_to_server=atoi(argv[3]);
}else{
printf("wrong parameters: planebone ip - send port number - receive port number\n");
exit(EXIT_FAILURE);
}
pthread_t thread_server_to_planebone;
//create a second thread which executes server_to_planebone
if(pthread_create(&thread_server_to_planebone, NULL, server_to_planebone,&connection)) {
error_write(FILENAME,"error creating lisa thread");
exit(EXIT_FAILURE);
}
/*-------------------------START OF FIRST THREAD: PLANEBONE TO SERVER------------------------*/
static UDP udp_server;
uint8_t input_stream[MAX_INPUT_STREAM_SIZE];
timeval tv_now;
UDP_err_handler(openUDPServerSocket(&udp_server,connection.port_number_planebone_to_server,UDP_SOCKET_TIMEOUT),write_error_ptr);
//init the data decode pointers
init_decoding();
/*
* WHAT WE EXPECT:
* IMU_ACCEL_RAW 204
* IMU_GYRO_RAW 203
* IMU_MAG_RAW 205
* BARO_RAW 221
* GPS_INT 155
* AIRSPEED_ETS 57
* SYSMON 33
* UART_ERROR 208
* ACTUATORS_received 105
* */
int IMU_ACCEL_RAW_received=0;
int IMU_GYRO_RAW_received=0;
int IMU_MAG_RAW_received=0;
int BARO_RAW_received=0;
int GPS_INT_received=0;
int AIRSPEED_received=0;
int SVINFO_received=0;
int SYSMON_received=0;
int UART_ERROR_received=0;
int ACTUATORS_received=0;
int NMEA_IIMWV_received = 0;
int NMEA_WIXDR_received = 0;
int err;
#if ANALYZE
Analyze an_imu_accel_raw_freq,an_imu_accel_raw_lat;
int an_imu_accel_freq_done=0,an_imu_accel_lat_done=0;
init_analyze(&an_imu_accel_raw_freq,2000);
init_analyze(&an_imu_accel_raw_lat,2000);
Analyze an_imu_gyro_raw_freq,an_imu_gyro_raw_lat;
int an_imu_gyro_freq_done=0,an_imu_gyro_lat_done=0;
init_analyze(&an_imu_gyro_raw_freq,2000);
init_analyze(&an_imu_gyro_raw_lat,2000);
Analyze an_imu_mag_raw_freq,an_imu_mag_raw_lat;
int an_imu_mag_freq_done=0,an_imu_mag_lat_done=0;
init_analyze(&an_imu_mag_raw_freq,2000);
init_analyze(&an_imu_mag_raw_lat,2000);
Analyze an_baro_raw_freq,an_baro_raw_lat;
int an_baro_raw_freq_done=0,an_baro_raw_lat_done=0;
init_analyze(&an_baro_raw_freq,2000);
init_analyze(&an_baro_raw_lat,2000);
Analyze an_gps_int_freq,an_gps_int_lat;
int an_gps_int_freq_done=0,an_gps_int_lat_done=0;
init_analyze(&an_gps_int_freq,40);
init_analyze(&an_gps_int_lat,40);
Analyze an_airspeed_ets_freq,an_airspeed_ets_lat;
int an_airspeed_ets_freq_done=0,an_airspeed_ets_lat_done=0;
init_analyze(&an_airspeed_ets_freq,100);
init_analyze(&an_airspeed_ets_lat,100);
Analyze an_actuators_freq,an_actuators_lat;
int an_actuators_freq_done=0,an_actuators_lat_done=0;
init_analyze(&an_actuators_freq,500);
init_analyze(&an_actuators_lat,500);
Analyze an_UART_errors_freq,an_UART_errors_lat;
int an_UART_errors_freq_done=0,an_UART_errors_lat_done=0;
init_analyze(&an_UART_errors_freq,50);
init_analyze(&an_UART_errors_lat,50);
Analyze an_sys_mon_freq,an_sys_mon_lat;
int an_sys_mon_freq_done=0,an_sys_mon_lat_done=0;
init_analyze(&an_sys_mon_freq,50);
init_analyze(&an_sys_mon_lat,50);
#endif
int recv_len;
size_t data_len = sizeof(input_stream);
while (1){
// err = receiveUDPServerData(&udp_server,(void *)&input_stream, sizeof(input_stream)); //blocking !!!
//1. retreive UDP data form planebone from ethernet port.
err = receiveUDPServerData(&udp_server,(void *)&input_stream, data_len, &recv_len); //blocking !!!
if (recv_len != 30) {
printf("Wrong number of bytes in received UDP packet!\n");
printf("Expected 30 bytes, Received %d bytes!\n", recv_len);
err = UDP_ERR_RECV;
}
UDP_err_handler(err,write_error_ptr);
if(err == UDP_ERR_NONE){
gettimeofday(&tv_now,NULL); //timestamp from receiving to calculate latency
#if DEBUG > 0
printf("message raw: ");
int i;
for(i=0;i<input_stream[1];i++){
printf("%d ",input_stream[i]);
}
printf("\n");
printf("start hex: %x\n", input_stream[0]);
printf("length: %d\n", input_stream[1]);
printf("send id: %d\n", input_stream[2]);
printf("message id: %d\n", input_stream[3]);
printf("checksum1: %d\n", input_stream[input_stream[1]-2]);
printf("checksum2: %d\n", input_stream[input_stream[1]-1]);
// printf("%d", input_stream[3]);
printf("\n");
#endif
//2. decode data
int err = data_decode(input_stream);
DEC_err_handler(err,write_error_ptr);
if(err==DEC_ERR_NONE){
switch_read_write(); //only switch read write if data decoding was succesfull
Data* data = get_read_pointer();
if(input_stream[3]==IMU_GYRO_RAW){
IMU_GYRO_RAW_received=1;
}else if(input_stream[3]==IMU_ACCEL_RAW){
IMU_ACCEL_RAW_received=1;
}else if(input_stream[3]==IMU_MAG_RAW){
IMU_MAG_RAW_received=1;
}else if(input_stream[3]==BARO_RAW){
BARO_RAW_received=1;
}else if(input_stream[3]==GPS_INT){
GPS_INT_received=1;
}else if(input_stream[3]==AIRSPEED_ETS){
AIRSPEED_received=1;
}else if(input_stream[3]==SVINFO){
SVINFO_received=1;
}else if(input_stream[3]==SYSMON){
SYSMON_received=1;
}else if(input_stream[3]==UART_ERRORS){
UART_ERROR_received=1;
}else if(input_stream[3]==ACTUATORS){
ACTUATORS_received=1;
}else if(input_stream[3]==NMEA_IIMWV_ID){
NMEA_IIMWV_received=1;
}else if(input_stream[3]==NMEA_WIXDR_ID){
NMEA_WIXDR_received=1;
}
/*printf("IMU_GYRO_RAW_received %d\n",IMU_GYRO_RAW_received);
printf("IMU_ACCEL_RAW_received %d\n",IMU_ACCEL_RAW_received);
printf("IMU_MAG_RAW_received %d\n",IMU_MAG_RAW_received);
printf("BARO_RAW_received %d\n",BARO_RAW_received);
printf("GPS_INT_received %d\n",GPS_INT_received);
printf("AIRSPEED_received %d\n",AIRSPEED_received);
printf("SVINFO_received %d\n",SVINFO_received);
printf("SYSMON_received %d\n",SYSMON_received);
printf("UART_ERROR_received %d\n",UART_ERROR_received);
printf("ACTUATORS_received %d\n",ACTUATORS_received);
printf("NMEA_IIMWV_received %d\n",NMEA_IIMWV_received);
printf("NMEA_WIXDR_received %d\n",NMEA_WIXDR_received);
printf("\n");*/
if(input_stream[3]==BARO_RAW){
#if ANALYZE
if(calculate_frequency(&an_baro_raw_freq,data->lisa_plane.baro_raw.tv)==1){
an_baro_raw_freq_done=1;
}
if(calculate_latency(&an_baro_raw_lat,data->lisa_plane.baro_raw.tv,tv_now)==1){
an_baro_raw_lat_done=1;
}
#endif
/*int i;
printf("Baro_raw content:");
print_mem((void *)&data->lisa_plane.baro_raw,sizeof(Baro_raw));
printf("abs %d\n",data->lisa_plane.baro_raw.abs);
printf("diff %d\n",data->lisa_plane.baro_raw.diff);
printf("\n\n\n");*/
}
if(input_stream[3]==IMU_GYRO_RAW){
#if ANALYZE
if(calculate_frequency(&an_imu_gyro_raw_freq,data->lisa_plane.imu_gyro_raw.tv)==1){
an_imu_gyro_freq_done=1;
}
if(calculate_latency(&an_imu_gyro_raw_lat,data->lisa_plane.imu_gyro_raw.tv,tv_now)==1){
an_imu_gyro_lat_done=1;
}
#endif
/* int i;
printf("Imu_gyro_raw content:");
print_mem((void *)&data->lisa_plane.imu_gyro_raw,sizeof(Imu_gyro_raw));
printf("\n");
printf("gp %d\n",data->lisa_plane.imu_gyro_raw.gp);
printf("gq %d\n",data->lisa_plane.imu_gyro_raw.gq);
printf("gr %d\n",data->lisa_plane.imu_gyro_raw.gr);
print_latency(data->lisa_plane.imu_gyro_raw.tv);
printf("\n\n\n");*/
}
if(input_stream[3]==IMU_ACCEL_RAW){
#if ANALYZE
if(calculate_frequency(&an_imu_accel_raw_freq,data->lisa_plane.imu_accel_raw.tv)==1){
an_imu_accel_freq_done=1;
}
if(calculate_latency(&an_imu_accel_raw_lat,data->lisa_plane.imu_accel_raw.tv,tv_now)==1){
an_imu_accel_lat_done=1;
}
#endif
/*int i;
printf("Imu_accel_raw content:");
print_mem((void *)&data->lisa_plane.imu_accel_raw,sizeof(Imu_accel_raw));
printf("\n");
printf("ax %d\n",data->lisa_plane.imu_accel_raw.ax);
printf("ay %d\n",data->lisa_plane.imu_accel_raw.ay);
printf("az %d\n",data->lisa_plane.imu_accel_raw.az);
printf("\n");
printf("\n\n\n");*/
}
if(input_stream[3]==IMU_MAG_RAW){
#if ANALYZE
if(calculate_frequency(&an_imu_mag_raw_freq,data->lisa_plane.imu_mag_raw.tv)==1){
an_imu_mag_freq_done=1;
}
if(calculate_latency(&an_imu_mag_raw_lat,data->lisa_plane.imu_mag_raw.tv,tv_now)==1){
an_imu_mag_lat_done=1;
}
#endif
}
if(input_stream[3]==AIRSPEED_ETS){
#if ANALYZE
if(calculate_frequency(&an_airspeed_ets_freq,data->lisa_plane.airspeed_ets.tv)==1){
an_airspeed_ets_freq_done=1;
}
if(calculate_latency(&an_airspeed_ets_lat,data->lisa_plane.airspeed_ets.tv,tv_now)==1){
an_airspeed_ets_lat_done=1;
}
#endif
/*int i;
printf("airspeed content:");
print_mem((void *)&data->lisa_plane.airspeed_ets,sizeof(Airspeed_ets));
char temp[64];
timestamp_to_timeString(data->lisa_plane.airspeed_ets.tv,temp);
printf("send time %s\n",temp);
printf("adc %d\n",data->lisa_plane.airspeed_ets.adc);
printf("offset %d\n",data->lisa_plane.airspeed_ets.offset);
printf("scaled %f\n",data->lisa_plane.airspeed_ets.scaled);*/
}
if(input_stream[3]==GPS_INT){
#if ANALYZE
if(calculate_frequency(&an_gps_int_freq,data->lisa_plane.gps_int.tv)==1){
an_gps_int_freq_done=1;
}
if(calculate_latency(&an_gps_int_lat,data->lisa_plane.gps_int.tv,tv_now)==1){
an_gps_int_lat_done=1;
}
#endif
/*int i;
printf("Gps_int_message content:");
print_mem((void *)&data->lisa_plane.gps_int,sizeof(Gps_int));
printf("\n");
printf("ecef_x %d\n",data->lisa_plane.gps_int.ecef_x);
printf("ecef_y %d\n",data->lisa_plane.gps_int.ecef_y);
printf("ecef_z %d\n",data->lisa_plane.gps_int.ecef_z);
printf("lat %d\n",data->lisa_plane.gps_int.lat);
printf("lon %d\n",data->lisa_plane.gps_int.lon);
printf("alt %d\n",data->lisa_plane.gps_int.alt);
printf("hmsl %d\n",data->lisa_plane.gps_int.hmsl);
printf("ecef_xd %d\n",data->lisa_plane.gps_int.ecef_xd);
printf("ecef_yd %d\n",data->lisa_plane.gps_int.ecef_yd);
printf("ecef_zd %d\n",data->lisa_plane.gps_int.ecef_zd);
printf("pacc %d\n",data->lisa_plane.gps_int.pacc);
printf("sacc %d\n",data->lisa_plane.gps_int.sacc);
printf("tow %d\n",data->lisa_plane.gps_int.tow);
printf("pdop %d\n",data->lisa_plane.gps_int.pdop);
printf("numsv %d\n",data->lisa_plane.gps_int.numsv);
printf("fix %d\n",data->lisa_plane.gps_int.fix);
print_latency(data->lisa_plane.gps_int.tv);*/
}
if(input_stream[3]==SYSMON){
#if ANALYZE
if(calculate_frequency(&an_sys_mon_freq,data->lisa_plane.sys_mon.tv)==1){
an_sys_mon_freq_done=1;
}
if(calculate_latency(&an_sys_mon_lat,data->lisa_plane.sys_mon.tv,tv_now)==1){
an_sys_mon_lat_done=1;
}
#endif
/* int i;
printf("sysmon content:");
print_mem((void *)&data->lisa_plane.sys_mon,sizeof(Sys_mon));
printf("\n");
printf("periodic_time %d\n",data->lisa_plane.sys_mon.periodic_time);
printf("periodic_cycle %d\n",data->lisa_plane.sys_mon.periodic_cycle);
printf("periodic_cycle_min %d\n",data->lisa_plane.sys_mon.periodic_cycle_min);
printf("periodic_cycle_max %d\n",data->lisa_plane.sys_mon.periodic_cycle_max);
printf("event_number %d\n",data->lisa_plane.sys_mon.event_number);
printf("cpu_load %d\n",data->lisa_plane.sys_mon.cpu_load);
print_latency(data->lisa_plane.sys_mon.tv);*/
}
if(input_stream[3]==UART_ERRORS){
#if ANALYZE
if(calculate_frequency(&an_UART_errors_freq,data->lisa_plane.uart_errors.tv)==1){
an_UART_errors_freq_done=1;
}
if(calculate_latency(&an_UART_errors_lat,data->lisa_plane.uart_errors.tv,tv_now)==1){
an_UART_errors_lat_done=1;
}
#endif
/* int i;
printf("uart error content:");
print_mem((void *)&data->lisa_plane.uart_errors,sizeof(UART_errors));
printf("overrun_cnt %d\n",data->lisa_plane.uart_errors.overrun_cnt);
printf("noise_err_cnt %d\n",data->lisa_plane.uart_errors.noise_err_cnt);
printf("framing_err_cnt %d\n",data->lisa_plane.uart_errors.framing_err_cnt);
printf("bus_number %d\n",data->lisa_plane.uart_errors.bus_number);
print_latency(data->lisa_plane.uart_errors.tv);*/
}
if(input_stream[3]==ACTUATORS){
#if ANALYZE
if(calculate_frequency(&an_actuators_freq,data->lisa_plane.actuators.tv)==1){
an_actuators_freq_done=1;
}
if(calculate_latency(&an_actuators_lat,data->lisa_plane.actuators.tv,tv_now)==1){
an_actuators_lat_done=1;
}
#endif
/*int i;
printf("actuators content:");
print_mem((void *)&data->lisa_plane.actuators,sizeof(Actuators));
printf("arr_length %d\n",data->lisa_plane.actuators.arr_length);
for(i=0;i<data->lisa_plane.actuators.arr_length;i++){
printf("servo_%d %d\n",i,data->lisa_plane.actuators.values[i]);
}
print_latency(data->lisa_plane.actuators.tv);*/
}
if(input_stream[3]==BEAGLE_ERROR){
//printf("beagle bone error content:");
//print_mem((void *)&data->bone_plane.error,sizeof(Beagle_error));
switch(data->bone_plane.error.library){
case UDP_L:
UDP_err_handler(data->bone_plane.error.error_code,write_error_ptr);
break;
case UART_L:
UART_err_handler(data->bone_plane.error.error_code,write_error_ptr);
break;
case DECODE_L:
DEC_err_handler(data->bone_plane.error.error_code,write_error_ptr);
break;
case LOG_L:
LOG_err_handler(data->bone_plane.error.error_code,write_error_ptr);
break;
}
}
if(input_stream[3]==NMEA_IIMWV_ID){
printf("NMEA_IIMWV_ID content:");
print_mem((void *)&data->bone_wind.nmea_iimmwv,sizeof(NMEA_IIMWV));
printf("wind angle %lf\n",data->bone_wind.nmea_iimmwv.wind_angle);
printf("relative %c\n",data->bone_wind.nmea_iimmwv.relative);
printf("wind speed %lf\n",data->bone_wind.nmea_iimmwv.wind_speed);
printf("wind speed unit %c\n",data->bone_wind.nmea_iimmwv.wind_speed_unit);
printf("status %c\n",data->bone_wind.nmea_iimmwv.status);
char temp[64];
timestamp_to_timeString16(data->bone_wind.nmea_iimmwv.tv,temp);
printf("send time: %s\n",temp);
printf("\n");
}
if(input_stream[3]==NMEA_WIXDR_ID){
printf("NMEA_WIXDR_ID content:");
print_mem((void *)&data->bone_wind.nmea_wixdr,sizeof(NMEA_WIXDR));
printf("Temperature %lf\n",data->bone_wind.nmea_wixdr.temperature);
printf("unit %c\n",data->bone_wind.nmea_wixdr.unit);
char temp[64];
timestamp_to_timeString16(data->bone_wind.nmea_wixdr.tv,temp);
printf("send time: %s\n",temp);
printf("\n");
}
if(input_stream[3]==LINE_ANGLE_ID){
// Send a character (to gpio of arduino)
// to stop the arduino-timer
/*
FILE *myFile;
myFile = fopen("/dev/ttyUSB0", "w");
fputs ("a", myFile);
fclose (myFile);
*/
printf("LINE_ANGLE_ID content:");
print_mem((void *)&data->bone_arm.line_angle,sizeof(LINE_ANGLE));
printf("Azimuth %i\n",data->bone_arm.line_angle.azimuth_raw);
printf("Elevation %i\n",data->bone_arm.line_angle.elevation_raw);
// printf("unit %c\n",data->bone_wind.nmea_wixdr.unit);
//char temp[64];
//timestamp_to_timeString16(data->bone_arm.line_angle.tv,temp);
//printf("send time: %s\n",temp);
printf("\n");
}
}else{
printf("UNKNOW PACKAGE with id %d\n",input_stream[3]);
exit(1);
}
}
#if ANALYZE
if(an_imu_accel_freq_done==1 &&
an_imu_accel_lat_done==1 &&
an_imu_gyro_freq_done==1 &&
an_imu_gyro_lat_done==1 &&
an_imu_mag_freq_done==1 &&
an_imu_mag_lat_done==1 &&
an_baro_raw_lat_done==1 &&
an_baro_raw_freq_done==1 &&
an_airspeed_ets_lat_done==1 &&
an_airspeed_ets_freq_done==1 &&
an_actuators_lat_done==1 &&
an_actuators_freq_done==1 &&
an_UART_errors_lat_done==1 &&
an_UART_errors_freq_done==1 &&
an_sys_mon_lat_done==1 &&
an_sys_mon_freq_done==1)
{
printf("ANALYZE RESULTS - IMU_ACCEL_RAW:\n");
printf("avg period:\t %0.4f ms\n",(get_avg(&an_imu_accel_raw_freq)));
printf("avg freq:\t %0.4f hz\n",1/(get_avg(&an_imu_accel_raw_freq))*1e3);
printf("avg latency\t %0.4f ms\n",get_avg(&an_imu_accel_raw_lat));
printf("\n");
dump_buffer_to_file(&an_imu_accel_raw_freq,"analyze/imu_accel_raw_per.csv");
dump_buffer_to_file(&an_imu_accel_raw_lat,"analyze/imu_accel_raw_lat.csv");
destroy_analyze(&an_imu_accel_raw_freq);
destroy_analyze(&an_imu_accel_raw_lat);
printf("ANALYZE RESULTS - IMU_GYRO_RAW:\n");
printf("avg period:\t %0.4f ms\n",(get_avg(&an_imu_gyro_raw_freq)));
printf("avg freq:\t %0.4f hz\n",1/(get_avg(&an_imu_gyro_raw_freq))*1e3);
printf("avg latency\t %0.4f ms\n",get_avg(&an_imu_gyro_raw_lat));
printf("\n");
dump_buffer_to_file(&an_imu_gyro_raw_freq,"analyze/imu_gyro_raw_per.csv");
dump_buffer_to_file(&an_imu_gyro_raw_lat,"analyze/imu_gyro_raw_lat.csv");
destroy_analyze(&an_imu_gyro_raw_freq);
destroy_analyze(&an_imu_gyro_raw_lat);
printf("ANALYZE RESULTS - IMU_MAG_RAW:\n");
printf("avg period:\t %0.4f ms\n",(get_avg(&an_imu_mag_raw_freq)));
printf("avg freq:\t %0.4f hz\n",1/(get_avg(&an_imu_mag_raw_freq))*1e3);
printf("avg latency\t %0.4f ms\n",get_avg(&an_imu_mag_raw_lat));
printf("\n");
dump_buffer_to_file(&an_imu_mag_raw_freq,"analyze/imu_mag_raw_per.csv");
dump_buffer_to_file(&an_imu_mag_raw_lat,"analyze/imu_mag_raw_lat.csv");
destroy_analyze(&an_imu_mag_raw_freq);
destroy_analyze(&an_imu_mag_raw_lat);
printf("ANALYZE RESULTS - BARO_RAW:\n");
printf("avg period:\t %0.4f ms\n",(get_avg(&an_baro_raw_freq)));
printf("avg freq:\t %0.4f hz\n",1/(get_avg(&an_baro_raw_freq))*1e3);
printf("avg latency\t %0.4f ms\n",get_avg(&an_baro_raw_lat));
printf("\n");
dump_buffer_to_file(&an_baro_raw_freq,"analyze/baro_raw_per.csv");
dump_buffer_to_file(&an_baro_raw_lat,"analyze/baro_raw_lat.csv");
destroy_analyze(&an_baro_raw_freq);
destroy_analyze(&an_baro_raw_lat);
printf("ANALYZE RESULTS - GPS_INT:\n");
printf("avg period:\t %0.4f ms\n",get_avg(&an_gps_int_freq));
printf("avg freq:\t %0.4f hz\n",1/(get_avg(&an_gps_int_freq))*1e3);
printf("avg latency\t %0.4f ms\n",get_avg(&an_gps_int_lat));
printf("\n");
dump_buffer_to_file(&an_gps_int_freq,"analyze/gps_int_per.csv");
dump_buffer_to_file(&an_gps_int_lat,"analyze/gps_int_lat.csv");
destroy_analyze(&an_gps_int_freq);
destroy_analyze(&an_gps_int_lat);
printf("ANALYZE RESULTS - AIRSPEED_ETS:\n");
printf("avg period:\t %0.4f ms\n",get_avg(&an_airspeed_ets_freq));
printf("avg freq:\t %0.4f hz\n",1/(get_avg(&an_airspeed_ets_freq))*1e3);
printf("avg latency\t %0.4f ms\n",get_avg(&an_airspeed_ets_lat));
printf("\n");
dump_buffer_to_file(&an_airspeed_ets_freq,"analyze/airspeed_ets_per.csv");
dump_buffer_to_file(&an_airspeed_ets_lat,"analyze/airspeed_ets_lat.csv");
destroy_analyze(&an_airspeed_ets_freq);
destroy_analyze(&an_airspeed_ets_lat);
printf("ANALYZE RESULTS - ACTUATORS:\n");
printf("avg period:\t %0.4f ms\n",get_avg(&an_actuators_freq));
printf("avg freq:\t %0.4f hz\n",1/(get_avg(&an_actuators_freq))*1e3);
printf("avg latency\t %0.4f ms\n",get_avg(&an_actuators_lat));
printf("\n");
dump_buffer_to_file(&an_actuators_freq,"analyze/actuators_per.csv");
dump_buffer_to_file(&an_actuators_lat,"analyze/actuators_lat.csv");
destroy_analyze(&an_actuators_freq);
destroy_analyze(&an_actuators_lat);
printf("ANALYZE RESULTS - UART_ERRORS:\n");
printf("avg period:\t %0.4f ms\n",get_avg(&an_UART_errors_freq));
printf("avg freq:\t %0.4f hz\n",1/(get_avg(&an_UART_errors_freq))*1e3);
printf("avg latency\t %0.4f ms\n",get_avg(&an_UART_errors_lat));
printf("\n");
dump_buffer_to_file(&an_UART_errors_freq,"analyze/UART_errors_per.csv");
dump_buffer_to_file(&an_UART_errors_lat,"analyze/UART_errors_lat.csv");
destroy_analyze(&an_UART_errors_freq);
destroy_analyze(&an_UART_errors_lat);
printf("ANALYZE RESULTS - SYS_MON:\n");
printf("avg period:\t %0.4f ms\n",get_avg(&an_sys_mon_freq));
printf("avg freq:\t %0.4f hz\n",1/(get_avg(&an_sys_mon_freq))*1e3);
printf("avg latency\t %0.4f ms\n",get_avg(&an_sys_mon_lat));
printf("\n");
dump_buffer_to_file(&an_sys_mon_freq,"analyze/sys_mon_per.csv");
dump_buffer_to_file(&an_sys_mon_lat,"analyze/sys_mon_lat.csv");
destroy_analyze(&an_sys_mon_freq);
destroy_analyze(&an_sys_mon_lat);
exit(1);
}
#endif
}
UDP_err_handler(closeUDPServerSocket(&udp_server),write_error_ptr);
/*------------------------END OF FIRST THREAD------------------------*/
//wait for the second thread to finish
if(pthread_join(thread_server_to_planebone, NULL)) {
error_write(FILENAME,"error joining thread_lisa_to_pc");
exit(EXIT_FAILURE);
}
return 0;
}
