int main ( void ) { utils_init(); debug_init(); pwm_in_init(); pwm_out_init(); _delay_ms(2000); orientation_init(); char out[200]; float dt = 0; uint32_t t = _micros(); uint32_t dt_c = 20000; for ( ; ; ) { t = _micros(); /* Read all data from sensor 1 */ orientation_update( 20.0 ); bzero( out , sizeof ( out ) ); /* Format data */ sprintf( out, "{\"x\":%f,\"y\":%f,\"z\":%f,\"xx\":%f,\"xy\":%f,\"xz\":%f}\n" , angles[PITCH], angles[ROLL], angles[YAW],acc_smooth[PITCH], acc_smooth[ROLL], acc_smooth[YAW]); debug_write( out ); while((_micros() - t) < dt_c); } }
// Open interface static int ven_init (const bt_vendor_callbacks_t * p_cb, unsigned char * local_bdaddr) { logd ("ven_init p_cb: %p local_bdaddr: %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x", p_cb, local_bdaddr [0], local_bdaddr [1], local_bdaddr [2], local_bdaddr [3], local_bdaddr [4], local_bdaddr [5] ); logd ("main start: %s %s", binary_description, manifest_version); // manifest_version automatically set during build logd (copyright); // Copyright utils_init (); if (p_cb == NULL) { loge ("ven_init no user callbacks"); return (BT_HC_STATUS_FAIL); } bt_ven_cbacks = (bt_vendor_callbacks_t *) p_cb; // Store reference to user callbacks if (shim_start () == NULL) { loge ("ven_init shim_start error"); return (BT_HC_STATUS_FAIL); } int ret = -88; if (veno_init) ret = veno_init (p_cb, local_bdaddr); logd ("ven_init ret: %d", ret); if (ret == 0) ret = server_thread_start (); return (ret); }
static int init(const bt_hc_callbacks_t* p_cb, unsigned char *local_bdaddr) { int result; ALOGI("init"); if (p_cb == NULL) { ALOGE("init failed with no user callbacks!"); return BT_HC_STATUS_FAIL; } hc_cb.epilog_timer_created = false; fwcfg_acked = false; has_cleaned_up = false; pthread_mutex_init(&hc_cb.worker_thread_lock, NULL); /* store reference to user callbacks */ bt_hc_cbacks = (bt_hc_callbacks_t *) p_cb; vendor_open(local_bdaddr); utils_init(); #ifdef HCI_USE_MCT extern tHCI_IF hci_mct_func_table; p_hci_if = &hci_mct_func_table; #else extern tHCI_IF hci_h4_func_table; p_hci_if = &hci_h4_func_table; #endif p_hci_if->init(); userial_init(); lpm_init(); utils_queue_init(&tx_q); if (hc_cb.worker_thread) { ALOGW("init has been called repeatedly without calling cleanup ?"); } // Set prio here and let hci worker thread inherit prio // remove once new thread api (thread_set_priority() ?) // can switch prio raise_priority_a2dp(TASK_HIGH_HCI_WORKER); hc_cb.worker_thread = thread_new("bt_hc_worker"); if (!hc_cb.worker_thread) { ALOGE("%s unable to create worker thread.", __func__); return BT_HC_STATUS_FAIL; } return BT_HC_STATUS_SUCCESS; }
int main() { utils_init(); printf("value: %d\n", value); utils_inc(); printf("value: %d\n", value); return 0; }
int main(int argc, char **argv) { atexit(on_client_exit); const char *cargs_file = CARGS_FILE; cargs = MALLOC(client_args); if (read_cargs((const char *)cargs_file, cargs)) { exit(1); } utils_init(); perhaps_init(); vector_init(&interfaces, sizeof(struct ifi_info)); // Initialize the receiving window rwindow_init(&rwin, cargs->sw_size); get_all_interfaces(); // Call print_ifi_info(). print_ifi_info((struct ifi_info*)vector_at(&interfaces, 0)); conn = MALLOC(client_conn); file_name_pkt = MALLOC(packet_t); memset(file_name_pkt, 0, sizeof(packet_t)); file_name_pkt->ack = 0; file_name_pkt->seq = 0; file_name_pkt->flags = FLAG_SYN; file_name_pkt->datalen = strlen(cargs->file_name); strcpy(file_name_pkt->data, cargs->file_name); get_conn(conn); INFO("Server is %s\nIPServer: %s\nIPClient: %s\n", (conn->is_local ? "Local" : "Not Local"), sa_data_str(conn->serv_sa), sa_data_str(conn->cli_sa)); initiate_tx(); return 0; }
int main (int argc, char *argv[]) { int i, j, k; long s1, s2; int nodes, cells, cell_size; if ( argc != 2 ){ // Print usage printf("usage: %s filename \n", argv[0]); printf("The filename must be of the form: /Path/To/Meshes/Folder/meshname_without_extension\n"); exit(0); } utils_init(CORES); /* * Read in 2D mesh informations, coordinates of the vertices and the * map from trinagles to vertices. */ char * node_path = str_cat(argv[1], ".node"); char * cell_path = str_cat(argv[1], ".ele"); double * coords_2D = read_coords_2D(node_path, &nodes); int * map_2D = read_cell_node_map_2D(cell_path, &cells, &cell_size); free(node_path); free(cell_path); /* * 3D coordinate field. */ double * coords_3D = extrude_coords(coords_2D, nodes, LAYERS, LAYER_HEIGHT); free(coords_2D); /* * 3D map from cells to vertices. */ int * map_3D = extrude_map(map_2D, cells, cell_size, LAYERS); int off_3D[6] = {1, 1, 1, 1, 1, 1}; free(map_2D); /* * Helmholtz Assembly * * Assembly of the LHS and RHS of a Helmholtz Equation. */ wrap_init(CORES); /* * Evaluate an expression over the mesh. * */ double *expr1 = (double*)malloc(sizeof(double) * nodes * LAYERS); printf(" Evaluating expression... "); s1 = stamp(); wrap_expression_1(0, cells, expr1, map_3D, coords_3D, map_3D, off_3D, off_3D, LAYERS); s2 = stamp(); printf("%g s\n", (s2 - s1)/1e9); //fprint(expr1, 150, 1); /* * Zero an array */ double *expr2 = (double*)malloc(sizeof(double) * nodes * LAYERS); printf(" Set array to zero... "); s1 = stamp(); wrap_zero_1(0, nodes * LAYERS, expr2, LAYERS); s2 = stamp(); printf("%g s\n", (s2 - s1)/1e9); /* * Interpolation operation. */ printf(" Interpolate expression... "); s1 = stamp(); wrap_rhs_1(0, cells, expr2, map_3D, coords_3D, map_3D, expr1, map_3D, off_3D, off_3D, off_3D, LAYERS); s2 = stamp(); printf("%g s\n", (s2 - s1)/1e9); /* * Another expression kernel */ double *expr3 = (double*)malloc(sizeof(double) * nodes * LAYERS); printf(" Evaluating expression... "); s1 = stamp(); wrap_expression_2(0, nodes * LAYERS, expr2, expr3, LAYERS); s2 = stamp(); printf("%g s\n", (s2 - s1)/1e9); /* * RHS assembly loop */ double *expr4 = (double*)malloc(sizeof(double) * nodes * LAYERS); printf(" Assembling right-hand side... "); s1 = stamp(); wrap_rhs(0, cells, expr4, map_3D, coords_3D, map_3D, expr2, map_3D, expr3, map_3D, off_3D, off_3D, off_3D, off_3D, LAYERS); s2 = stamp(); printf("%g s\n", (s2 - s1)/1e9); /* * Matrix assembly loop */ double *expr5 = (double*)malloc(sizeof(double) * nodes * LAYERS); printf(" Assembling left-hand side... "); s1 = stamp(); wrap_lhs(0, cells, expr5, map_3D, map_3D, coords_3D, map_3D, off_3D, off_3D, off_3D, LAYERS); s2 = stamp(); printf("%g s\n", (s2 - s1)/1e9); /* * RHS and LHS output */ write: s1 = stamp(); printf(" Numerical results written to output files... "); output(FILE_RHS, expr4, nodes * LAYERS, 1); output(FILE_LHS, expr5, nodes * LAYERS, 1); s2 = stamp(); printf("%g s\n", (s2 - s1)/1e9); free(coords_3D); free(map_3D); free(expr1); free(expr2); free(expr3); free(expr4); free(expr5); return 0; }
static int init(const bt_hc_callbacks_t* p_cb, unsigned char *local_bdaddr) { pthread_attr_t thread_attr; struct sched_param param; int policy, result; ALOGI("init"); if (p_cb == NULL) { ALOGE("init failed with no user callbacks!"); return BT_HC_STATUS_FAIL; } hc_cb.epilog_timer_created = 0; fwcfg_acked = FALSE; /* store reference to user callbacks */ bt_hc_cbacks = (bt_hc_callbacks_t *) p_cb; init_vnd_if(local_bdaddr); utils_init(); if(is_bt_transport_smd()) { extern tHCI_IF hci_mct_func_table; extern tUSERIAL_IF userial_mct_func_table; p_hci_if = &hci_mct_func_table; p_userial_if = &userial_mct_func_table; } else { extern tHCI_IF hci_h4_func_table; extern tUSERIAL_IF userial_h4_func_table; p_hci_if = &hci_h4_func_table; p_userial_if = &userial_h4_func_table; } p_hci_if->init(); p_userial_if->init(); lpm_init(); utils_queue_init(&tx_q); if (lib_running) { ALOGW("init has been called repeatedly without calling cleanup ?"); } lib_running = 1; ready_events = 0; pthread_mutex_init(&hc_cb.mutex, NULL); pthread_cond_init(&hc_cb.cond, NULL); pthread_attr_init(&thread_attr); if (pthread_create(&hc_cb.worker_thread, &thread_attr, \ bt_hc_worker_thread, NULL) != 0) { ALOGE("pthread_create failed!"); lib_running = 0; return BT_HC_STATUS_FAIL; } if(pthread_getschedparam(hc_cb.worker_thread, &policy, ¶m)==0) { policy = BTHC_LINUX_BASE_POLICY; #if (BTHC_LINUX_BASE_POLICY!=SCHED_NORMAL) param.sched_priority = BTHC_MAIN_THREAD_PRIORITY; #endif result = pthread_setschedparam(hc_cb.worker_thread, policy, ¶m); if (result != 0) { ALOGW("libbt-hci init: pthread_setschedparam failed (%s)", \ strerror(result)); } } return BT_HC_STATUS_SUCCESS; }