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; }