static void endpoint_init(const type_t *t, void *obj) { (void) t; // silence unused warning tn_endpoint_t *fsep = (tn_endpoint_t*)obj; reg_init(&(fsep->base.files), "tcp_endpoint_files", 16); fsep->base.ptype = &tcp_provider; fsep->base.is_temporary = 0; fsep->base.is_assigned = 0; reg_append(&endpoints, fsep); }
gboolean go(gpointer user_data) { cmdline *cmd = user_data; Control* control = object_get_control((Object*)cmd->user_data); #ifdef __arm__ reg_init(); #endif control_emit_goto_system_state(control,"BMC_STARTING"); //g_main_loop_quit(cmd->loop); return FALSE; }
/* * Startup initialization of a MIX machine. * Sets condition and overflow bits, clears registers, * and creates and initializes memory. * param machine - MIX machine to initialize. */ void startup_init(mix_pt machine) { printf("Starting MIX machine...\n"); // Set the status bits for the comparison bit and overflow bit to: // EQUAL and NO_OVERFLOW, repectively. machine->condition = EQUAL; machine->overflow = NO_OVERFLOW; // Initialize registers to +0. reg_init(machine); // Create and initialize memory. mem_init(machine); }
symbol* gen_para_regs(symbol* parameters, symbol* vars) { char *registers[6] = {"rdi", "rsi", "rdx", "rcx", "r8", "r9"}; int i = 0; symbol *para_start = parameters; while (parameters != (symbol *)NULL) { if (i > 5) { not_supported("more than 6 function parameters"); } parameters->reg = strdup(registers[i++]); parameters = parameters->next; } #ifdef MY_DEBUG printf("#-- ASSIGNING PARAMETER REGISTERS\n"); tbl_print(para_start); printf("\n"); #endif reg_init(para_start); var_init(vars); return para_start; }
void * os_llcallchain_dyn_create(page_t *page) { dyn_llcallchain_t *dyn; cmd_llcallchain_t *cmd = CMD_LLCALLCHAIN(&page->cmd); int i; if ((dyn = zalloc(sizeof (dyn_llcallchain_t))) == NULL) { return (NULL); } dyn->pid = cmd->pid; dyn->lwpid = cmd->lwpid; dyn->addr = cmd->addr; dyn->size = cmd->size; strncpy(dyn->desc, cmd->desc, WIN_DESCBUF_SIZE); dyn->desc[WIN_DESCBUF_SIZE - 1] = 0; if ((i = reg_init(&dyn->msg, 0, 1, g_scr_width, 2, A_BOLD)) < 0) goto L_EXIT; if ((i = reg_init(&dyn->buf_caption, 0, i, g_scr_width, 2, A_BOLD | A_UNDERLINE)) < 0) goto L_EXIT; if ((i = reg_init(&dyn->buf_data, 0, i, g_scr_width, 1, 0)) < 0) goto L_EXIT; if ((i = reg_init(&dyn->chain_caption, 0, i, g_scr_width, 2, A_BOLD | A_UNDERLINE)) < 0) goto L_EXIT; if ((i = reg_init(&dyn->pad, 0, i, g_scr_width, 1, 0)) < 0) goto L_EXIT; if ((reg_init(&dyn->chain_data, 0, i, g_scr_width, g_scr_height - i - 2, 0)) < 0) goto L_EXIT; reg_buf_init(&dyn->chain_data, NULL, win_callchain_line_get); reg_scroll_init(&dyn->chain_data, B_TRUE); return (dyn); L_EXIT: free(dyn); return (NULL); }
static void tnp_init(void) { reg_init(&endpoints, "tcp_endpoints", 5); }
int main(void) { int i; uint16_t sensor_sample_count; struct sensor_s sensor; struct angle_s angle; uint16_t radio_frame_count; struct radio_raw_s radio_raw; struct radio_s radio; float radio_pitch_smooth; float radio_roll_smooth; float error_pitch; float error_roll; float error_yaw; float error_pitch_z; float error_roll_z; float error_yaw_z; float p_pitch; float i_pitch; float d_pitch; float p_roll; float i_roll; float d_roll; float pitch_p_term; float pitch_i_term; float pitch_d_term; float roll_p_term; float roll_i_term; float roll_d_term; float yaw_p_term; float yaw_i_term; float yaw_d_term; float pitch; float roll; float yaw; float motor[4]; int32_t motor_clip[4]; uint32_t motor_raw[4]; uint16_t vbat_sample_count; int32_t t1; int32_t t2; _Bool flag_acro_z; _Bool error; uint16_t sensor_sample_count1; host_buffer_tx_t host_buffer_tx; /* Variable initialisation -----------------------------------------------------*/ flag_sensor = 0; flag_radio = 0; flag_vbat = 0; flag_rf = 0; flag_host = 0; flag_sensor_host_read = 0; flag_rf_host_read = 0; flag_timeout_sensor = 0; flag_timeout_radio = 0; flag_armed = 0; flag_acro = 1; flag_acro_z = 0; flag_beep_user = 0; flag_beep_radio = 0; flag_beep_sensor = 0; flag_beep_host = 0; flag_beep_vbat = 0; sensor_sample_count = 0; sensor_error_count = 0; angle.pitch = 0; angle.roll = 0; radio_frame_count = 0; radio_error_count = 0; radio_pitch_smooth = 0; radio_roll_smooth = 0; pitch_i_term = 0; roll_i_term = 0; yaw_i_term = 0; vbat_sample_count = 0; rf_error_count = 0; sensor_sample_count1 = 0; /* Setup -----------------------------------------------------*/ board_init(); // BOARD_DEPENDENT SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk; // Disable Systick interrupt, not needed anymore (but can still use COUNTFLAG) reg_init(); /* Loop ---------------------------------------------------------------------------- -----------------------------------------------------------------------------------*/ while (1) { // Processing time t1 = (int32_t)get_timer_process(); /* Process radio commands -----------------------------------------------------*/ if (flag_radio) { flag_radio = 0; // Decode radio commands error = radio_decode(&radio_frame, &radio_raw, &radio); if (error) { radio_error_count++; radio_synch(); } else { reset_timeout_radio(); flag_beep_radio = 0; // Stop beeping radio_frame_count++; // Arm procedure if (radio.aux[0] < 0.33f) flag_armed = 0; else if (!flag_armed && (radio.aux[0] > 0.33f) && ((radio.throttle < 0.01f))) flag_armed = 1; if (radio.aux[0] < 0.66f) flag_acro = 1; else flag_acro = 0; // Expo and smooth radio_expo(&radio, flag_acro); // Beep if requested if (radio.aux[1] > 0.33f) flag_beep_user = 1; else flag_beep_user = 0; // Send data to host if ((REG_DEBUG__CASE > 0) && ((radio_frame_count & REG_DEBUG__MASK) == 0)) { if (REG_DEBUG__CASE == 4) host_send((uint8_t*)&radio_raw, sizeof(radio_raw)); else if (REG_DEBUG__CASE == 5) host_send((uint8_t*)&radio, sizeof(radio)); } // Toggle LED at rate of Radio flag if ((radio_frame_count & 0x3F) == 0) toggle_led_radio(); } } /* Process sensors -----------------------------------------------------------------------*/ if (flag_sensor) { flag_sensor = 0; sensor_sample_count++; flag_beep_sensor = 0; // Disable beeping // Record sensor transaction time t2 = (int32_t)timer_sensor[1] - (int32_t)timer_sensor[0]; if (t2 < 0) t2 += 0xFFFF; if ((REG_CTRL__TIME_MAXHOLD == 0) || (((uint16_t)t2 > time_sensor) && REG_CTRL__TIME_MAXHOLD)) time_sensor = (uint16_t)t2; // Recovery time before activating yaw agnle transfer if (flag_acro != flag_acro_z) sensor_sample_count1 = 0; else if (sensor_sample_count1 < RECOVERY_TIME) sensor_sample_count1++; // Procees sensor data mpu_process_samples(&sensor_raw, &sensor); // Estimate angle angle_estimate(&sensor, &angle, (sensor_sample_count1 == RECOVERY_TIME)); // Smooth pitch and roll commands in angle mode if (!flag_acro) { radio_pitch_smooth += filter_alpha_radio * radio.pitch - filter_alpha_radio * radio_pitch_smooth; radio_roll_smooth += filter_alpha_radio * radio.roll - filter_alpha_radio * radio_roll_smooth; } // Previous error error_pitch_z = error_pitch; error_roll_z = error_roll; error_yaw_z = error_yaw; // Current error if (flag_acro) { error_pitch = sensor.gyro_x - radio.pitch * (float)REG_RATE__PITCH_ROLL; error_roll = sensor.gyro_y - radio.roll * (float)REG_RATE__PITCH_ROLL; } else { error_pitch = angle.pitch - radio_pitch_smooth * (float)REG_RATE__ANGLE; error_roll = angle.roll - radio_roll_smooth * (float)REG_RATE__ANGLE; } error_yaw = sensor.gyro_z - radio.yaw * (float)REG_RATE__YAW; // Switch PID coefficients for acro if (flag_acro != flag_acro_z) { if (flag_acro) { p_pitch = REG_P_PITCH; i_pitch = REG_I_PITCH; d_pitch = REG_D_PITCH; p_roll = REG_P_ROLL; i_roll = REG_I_ROLL; d_roll = REG_D_ROLL; } else { p_pitch = REG_P_PITCH_ANGLE; i_pitch = REG_I_PITCH_ANGLE; d_pitch = REG_D_PITCH_ANGLE; p_roll = REG_P_ROLL_ANGLE; i_roll = REG_I_ROLL_ANGLE; d_roll = REG_D_ROLL_ANGLE; } } // P,I and D pitch_p_term = error_pitch * p_pitch; roll_p_term = error_roll * p_roll; yaw_p_term = error_yaw * REG_P_ROLL; if ((!flag_armed && (REG_CTRL__ARM_TEST == 0)) || (flag_acro != flag_acro_z)) { pitch_i_term = 0; roll_i_term = 0; } else { pitch_i_term += error_pitch * i_pitch; roll_i_term += error_roll * i_roll; } if (!flag_armed && (REG_CTRL__ARM_TEST == 0)) yaw_i_term = 0; else yaw_i_term += error_yaw * REG_I_YAW; pitch_d_term = (error_pitch - error_pitch_z) * d_pitch; roll_d_term = (error_roll - error_roll_z) * d_roll; yaw_d_term = (error_yaw - error_yaw_z) * REG_D_YAW; flag_acro_z = flag_acro; // Clip I if (pitch_i_term < -I_MAX) pitch_i_term = -I_MAX; else if (pitch_i_term > I_MAX) pitch_i_term = I_MAX; if (roll_i_term < -I_MAX) roll_i_term = -I_MAX; else if (roll_i_term > I_MAX) roll_i_term = I_MAX; if (yaw_i_term < -I_MAX) yaw_i_term = -I_MAX; else if (yaw_i_term > I_MAX) yaw_i_term = I_MAX; // P+I+D pitch = pitch_p_term + pitch_i_term + pitch_d_term; roll = roll_p_term + roll_i_term + roll_d_term; yaw = yaw_p_term + yaw_i_term + yaw_d_term; // Clip P+I+D if (pitch < -PID_MAX) pitch = -PID_MAX; else if (pitch > PID_MAX) pitch = PID_MAX; if (roll < -PID_MAX) roll = -PID_MAX; else if (roll > PID_MAX) roll = PID_MAX; if (yaw < -PID_MAX) yaw = -PID_MAX; else if (yaw > PID_MAX) yaw = PID_MAX; // Desactivate throttle when arm test if (REG_CTRL__ARM_TEST > 0) radio.throttle = 0; // Motor matrix motor[0] = radio.throttle * (float)REG_MOTOR__RANGE + roll + pitch - yaw; motor[1] = radio.throttle * (float)REG_MOTOR__RANGE + roll - pitch + yaw; motor[2] = radio.throttle * (float)REG_MOTOR__RANGE - roll - pitch - yaw; motor[3] = radio.throttle * (float)REG_MOTOR__RANGE - roll + pitch + yaw; // Offset and clip motor value for (i=0; i<4; i++) { motor_clip[i] = (int32_t)motor[i] + (int32_t)REG_MOTOR__ARMED; if (motor_clip[i] < (int32_t)REG_MOTOR__START) motor_clip[i] = (int32_t)REG_MOTOR__START; else if (motor_clip[i] > (int32_t)MOTOR_MAX) motor_clip[i] = (int32_t)MOTOR_MAX; } // Motor command for (i=0; i<4; i++) { if (REG_MOTOR_TEST__SELECT & (1 << i)) motor_raw[i] = (uint32_t)REG_MOTOR_TEST__VALUE; else if (flag_armed || (REG_CTRL__ARM_TEST > 0)) motor_raw[i] = (uint32_t)motor_clip[i]; else motor_raw[i] = 0; } set_motors(motor_raw); // Send data to host if ((REG_DEBUG__CASE > 0) && ((sensor_sample_count & REG_DEBUG__MASK) == 0)) { if (REG_DEBUG__CASE == 1) host_send((uint8_t*)&sensor_raw.bytes[1], sizeof(sensor_raw)-1); else if (REG_DEBUG__CASE == 2) host_send((uint8_t*)&sensor, sizeof(sensor)); else if (REG_DEBUG__CASE == 3) host_send((uint8_t*)&angle, sizeof(angle)); else if (REG_DEBUG__CASE == 6) { host_buffer_tx.f[0] = pitch; host_buffer_tx.f[1] = roll; host_buffer_tx.f[2] = yaw; host_send(host_buffer_tx.u8, 3*4); } else if (REG_DEBUG__CASE == 7) host_send((uint8_t*)&motor_raw, sizeof(motor_raw)); } // Toggle LED at rate of sensor flag if ((sensor_sample_count & 0x01FF) == 0) toggle_led_sensor(); } /* VBAT ---------------------------------------------------------------------*/ if (flag_vbat) { flag_vbat = 0; vbat_sample_count++; REG_VBAT += filter_alpha_vbat * get_vbat() - filter_alpha_vbat * REG_VBAT; // Send VBAT to host if ((REG_DEBUG__CASE == 8) && ((vbat_sample_count & REG_DEBUG__MASK) == 0)) host_send((uint8_t*)®_VBAT,4); // Beep if VBAT too low if ((REG_VBAT < REG_VBAT_MIN) && (REG_VBAT > 8.0f)) flag_beep_vbat = 1; else flag_beep_vbat = 0; } /* Host requests ------------------------------------------------------------------*/ if (flag_host) { flag_host = 0; reg_access(&host_buffer_rx); } /* Handle timeout -----------------------------------------------------------------------*/ if (flag_timeout_sensor) { flag_timeout_sensor = 0; for (i=0; i<4; i++) motor_raw[i] = 0; set_motors(motor_raw); flag_beep_sensor = 1; } if (flag_timeout_radio) { flag_timeout_radio = 0; flag_armed = 0; flag_beep_radio = 1; } /*------------------------------------------------------------------*/ // Record processing time t1 = (int32_t)get_timer_process() - t1; if (t1 < 0) t1 += 0xFFFF; if ((REG_CTRL__TIME_MAXHOLD == 0) || (((uint16_t)t1 > time_process) && REG_CTRL__TIME_MAXHOLD)) time_process = (uint16_t)t1; // Wait for interrupts if all flags are processed if (!flag_radio && !flag_sensor && !flag_vbat && !flag_host && !flag_timeout_sensor && !flag_timeout_radio) __wfi(); } }
int main(int argn, char *argv[]) { unsigned int i, ret, readers, writers, tot_count_read = 0; timer exec_time; if(argn < 7) { fprintf(stderr, "Usage: %s: n_writer n_reader end_write end_read busy_write busy_read size\n", argv[0]); exit(EXIT_FAILURE); } writers = atoi(argv[1]); readers = atoi(argv[2]); size = atoi(argv[3]); if(argn == 7){ busy_write = atoi(argv[4]); busy_read = atoi(argv[5]); duration = atoi(argv[6]); } else if (argn == 8){ busy_write = atoi(argv[4]); busy_read = atoi(argv[5]); end_write = atoi(argv[6]); end_read = atoi(argv[7]); } pthread_t p_tid[writers + readers]; reg = reg_init(writers, readers, size); //reg = reg_init(writers, readers, DIM*sizeof(unsigned long long)); if((count_read = calloc(readers, sizeof(unsigned int))) == NULL){ printf("malloc failed\n"); abort(); } for(i = 0; i < writers; i++) { if( (ret = pthread_create(&p_tid[i], NULL, run_write, NULL)) != 0) { fprintf(stderr, "%s\n", strerror(errno)); abort(); } } for(i = 0; i < readers; i++) { if( (ret = pthread_create(&p_tid[writers+i], NULL, run_read, NULL)) != 0) { fprintf(stderr, "%s\n", strerror(errno)); abort(); } } sleep(1); printf("\n\n+-----------------------------------------------------------------------------------+\n"); printf("START TEST on REGISTER(%u,%u) of size %u: +\n", writers, readers, size); printf("\t write operation: %u, %u: +\n", end_write, busy_write); printf("\t read operation: %u, %u: +\n", end_read, busy_read); printf("+-----------------------------------------------------------------------------------+\n\n\n"); timer_start(exec_time); start = true; if(duration > 0){ sleep(duration); end = true; } for(i = 0; i < writers + readers; i++){ pthread_join(p_tid[i], NULL); } printf("\n\n+-----------------------------------------------------------------------------------+\n"); printf("TEST ENDED: %.5f seconds\n", (double)timer_value_seconds(exec_time)); printf("TOTAL WRTE: %u\n", count_write); for(i = 0; i < readers; i++) tot_count_read +=count_read[i]; printf("TOTAL READ: %u\n", tot_count_read); printf("TOTAL OPER: %u\n", tot_count_read+count_write); printf("+-----------------------------------------------------------------------------------+\n\n\n"); reg_free(reg); }
int main(int argc,char **argv) { struct sockaddr_in servaddr; struct sockaddr_in clientaddr; char buff; int n; b_reg.resize(5); cnt=0; ac_time=2; //freopen("test.txt","r",stdin); if( argc != 6) { cout<<endl<<"usage: ./client <s.ip><s.port><w.ip><w.port><id>"<<endl; exit(0); } /******************socket creat********************************/ if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { cout<<"create socket error"<<endl; exit(0); } /********************struct sockaddr_in servaddr ***********************************************/ memset(&servaddr, 0, sizeof(struct sockaddr_in)); servaddr.sin_family = AF_INET; servaddr.sin_port=htons(atoi(argv[2])); if(inet_aton(argv[1],&servaddr.sin_addr)==0) { cout<<"invalid server ip address"<<endl; exit(0); } /***********************struct sockaddr_in clientaddr************************************************************/ memset(&clientaddr,0,sizeof(struct sockaddr_in)); clientaddr.sin_family = AF_INET; clientaddr.sin_port = htons(atoi(argv[4])); if(inet_aton(argv[3],&clientaddr.sin_addr) ==0) { cout<<"invalid client ipaddress"<<endl; exit(0); } /*****************************bind clientaddr and socket*************************************************************/ if( bind(sockfd, (struct sockaddr*)&clientaddr, sizeof(struct sockaddr_in)) <0) { cout<<"bind socket error"<<endl; exit(0); } cout<<"bind ok"<<endl; /********************connect server*****************************************************/ while(connect(sockfd,(struct sockaddr*)&servaddr,sizeof(struct sockaddr))<0); cout<<"connect ok "<<endl; /****************************creat and send reg_msg*****************************************/ reg_init("sky",*(argv+5)); /**********************************************************************************/ while(1) { n = recv(sockfd,&buff, 1, 0); if(n > 0) { if(get_info(buff)==GAMEOVER) break; } } close(sockfd); return 0; }