DEFINE_THREAD_ROUTINE(mobile_main, data) { C_RESULT res = C_FAIL; vp_com_wifi_config_t *config = NULL; mobile_main_param_t *param = (mobile_main_param_t *)data; ardroneEngineCallback callback = param->callback; vp_os_memset(drone_address, 0x0, sizeof(drone_address)); // TODO(johnb): Make this autodetect based on network interfaces while(((config = (vp_com_wifi_config_t *)wifi_config()) != NULL) && (strcmp(config->itfName, WIFI_ITFNAME) != 0)) { PRINT("Wait WIFI connection !\n"); vp_os_delay(250); } // Get drone_address vp_os_memcpy(drone_address, config->server, strlen(config->server)); PRINT("Drone address %s\n", drone_address); // Get iphone_mac_address get_iphone_mac_address(config->itfName); PRINT("Iphone MAC Address %s\n", iphone_mac_address); res = ardrone_tool_setup_com( NULL ); if( FAILED(res) ) { PRINT("Wifi initialization failed. It means either:\n"); PRINT("\t* you're not root (it's mandatory because you can set up wifi connection only as root)\n"); PRINT("\t* wifi device is not present (on your pc or on your card)\n"); PRINT("\t* you set the wrong name for wifi interface (for example rausb0 instead of wlan0) \n"); PRINT("\t* ap is not up (reboot card or remove wifi usb dongle)\n"); PRINT("\t* wifi device has no antenna\n"); } else { START_THREAD(video_stage, NULL); res = ardrone_tool_init(drone_address, strlen(drone_address), NULL, param->appName, param->usrName); callback(ARDRONE_ENGINE_INIT_OK); ardrone_tool_set_refresh_time(1000 / kAPS); while( SUCCEED(res) && bContinue == TRUE ) { ardrone_tool_update(); } JOIN_THREAD(video_stage); res = ardrone_tool_shutdown(); } vp_os_free (data); return (THREAD_RET)res; }
DEFINE_THREAD_ROUTINE(mobile_main, data) { C_RESULT res = C_FAIL; char drone_address[64]; unsigned long theAddr; ardroneEngineCallback callback = (ardroneEngineCallback)data; vp_os_memset(drone_address, 0x0, sizeof(drone_address)); while((theAddr = deviceIPAddress(WIFI_ITFNAME, iphone_mac_address)) == LOCALHOST) { PRINT("Wait WIFI connection !\n"); vp_os_delay(250); } struct in_addr drone_addr; drone_addr.s_addr = htonl( ntohl((in_addr_t)theAddr) - 1 ); vp_os_memcpy(drone_address, inet_ntoa(drone_addr), strlen(inet_ntoa(drone_addr))); PRINT("Drone address %s\n", drone_address); PRINT("Iphone MAC Address %s\n", iphone_mac_address); res = ardrone_tool_setup_com( NULL ); if( FAILED(res) ) { PRINT("Wifi initialization failed. It means either:\n"); PRINT("\t* you're not root (it's mandatory because you can set up wifi connection only as root)\n"); PRINT("\t* wifi device is not present (on your pc or on your card)\n"); PRINT("\t* you set the wrong name for wifi interface (for example rausb0 instead of wlan0) \n"); PRINT("\t* ap is not up (reboot card or remove wifi usb dongle)\n"); PRINT("\t* wifi device has no antenna\n"); } else { res = ardrone_tool_init(drone_address, strlen(drone_address), NULL); callback(ARDRONE_ENGINE_INIT_OK); if(SUCCEED(res)) { START_THREAD(video_stage, NULL); res = ardrone_tool_set_refresh_time(1000 / kAPS); while( SUCCEED(res) && bContinue == TRUE ) { res = ardrone_tool_update(); } JOIN_THREAD(video_stage); } res = ardrone_tool_shutdown(); } return (THREAD_RET)0; }
DEFINE_THREAD_ROUTINE(mobile_main, data) { __android_log_print( ANDROID_LOG_INFO, "ARDrone", "Enter in mobile_main thread\n" ); C_RESULT res = C_OK; char drone_address[24]; vp_os_memset(drone_address, 0x0, sizeof(drone_address)); sprintf(drone_address, WIFI_ARDRONE_IP); res = ardrone_tool_setup_com( NULL ); if( FAILED(res) ) { __android_log_print( ANDROID_LOG_INFO, "ARDrone", "Setup com failed\n" ); INFO("Wifi initialization failed. It means either:\n"); INFO("\t* you're not root (it's mandatory because you can set up wifi connection only as root)\n"); INFO("\t* wifi device is not present (on your pc or on your card)\n"); INFO("\t* you set the wrong name for wifi interface (for example rausb0 instead of wlan0) \n"); INFO("\t* ap is not up (reboot card or remove wifi usb dongle)\n"); INFO("\t* wifi device has no antenna\n"); } else { START_THREAD(video_stage, NULL); __android_log_print( ANDROID_LOG_INFO, "ARDrone", "Processing ardrone_tool_init\n" ); res = ardrone_tool_init(drone_address, strlen(drone_address), NULL); control_ack_init(); control_ack_configure_navdata_demo( FALSE ); if(SUCCEED(res)) { res = ardrone_tool_set_refresh_time(25); while( SUCCEED(res) && bContinue == TRUE ) { res = ardrone_tool_update(); } } JOIN_THREAD(video_stage); res = ardrone_tool_shutdown(); } __android_log_print( ANDROID_LOG_INFO, "ARDrone", "Exit mobile_main thread\n" ); return (THREAD_RET)0; }
DEFINE_THREAD_ROUTINE(ihm, data) { C_RESULT res; WSADATA wsaData = {0}; int iResult = 0; /* Initializes Windows socket subsystem */ iResult = WSAStartup(MAKEWORD(2, 2), &wsaData); if (iResult != 0) { wprintf(L"WSAStartup failed: %d\n", iResult); return 1; } /* Initializes communication sockets */ res = test_drone_connection(); // Nick disabled the press enter (wait) if(res!=0) { printf("%s","Could not detect the drone version ... press <Enter> to try connecting anyway.\n"); getchar(); //WSACleanup(); exit(-1); } res = ardrone_tool_setup_com( NULL ); if( FAILED(res) ) { PRINT("Wifi initialization failed.\n"); return -1; } START_THREAD(video_stage, 0); res = ardrone_tool_init(WIFI_ARDRONE_IP, strlen(WIFI_ARDRONE_IP), NULL, ARDRONE_CLIENT_APPNAME, ARDRONE_CLIENT_USRNAME); ardrone_tool_set_refresh_time(20); // 20 ms ardrone_at_reset_com_watchdog(); // config ardrone_control_config.euler_angle_max = 0.20943951f; // 12 degrees ardrone_control_config.video_channel = ZAP_CHANNEL_VERT; ardrone_control_config.video_codec = UVLC_CODEC; //P264_CODEC; ardrone_control_config.navdata_demo = FALSE; ardrone_control_config.altitude_max = 10000; ardrone_control_config.control_vz_max = 1000.0f; ardrone_control_config.outdoor = FALSE; //ardrone_control_config.flight_without_shell = TRUE; ARDRONE_TOOL_CONFIGURATION_ADDEVENT(video_channel, &ardrone_control_config.video_channel, (ardrone_tool_configuration_callback) ardrone_demo_config_callback); //ARDRONE_TOOL_CONFIGURATION_ADDEVENT(video_channel, &ardrone_control_config.video_channel, NULL); //ARDRONE_TOOL_CONFIGURATION_ADDEVENT(video_codec, &ardrone_control_config.video_codec, NULL); ARDRONE_TOOL_CONFIGURATION_ADDEVENT (navdata_demo, &ardrone_control_config.navdata_demo, NULL); ARDRONE_TOOL_CONFIGURATION_ADDEVENT (altitude_max, &ardrone_control_config.altitude_max, NULL); ARDRONE_TOOL_CONFIGURATION_ADDEVENT (control_vz_max, &ardrone_control_config.control_vz_max, NULL); //ARDRONE_TOOL_CONFIGURATION_ADDEVENT (outdoor, &ardrone_control_config.outdoor, NULL); //ARDRONE_TOOL_CONFIGURATION_ADDEVENT (flight_without_shell, &ardrone_control_config.flight_without_shell, NULL); ARDRONE_TOOL_CONFIGURATION_ADDEVENT (euler_angle_max, &ardrone_control_config.euler_angle_max, NULL); // flat trim ardrone_at_set_flat_trim(); //SetEvent(ardrone_ready); //ardrone_demo_redirect_to_interface = 1; while( VP_SUCCEEDED(res) && ardrone_tool_exit() == FALSE ) { res = ardrone_tool_update(); } JOIN_THREAD(video_stage); res = ardrone_tool_shutdown(); WSACleanup(); return (THREAD_RET)res; }
C_RESULT ardrone_tool_init_custom(void) { should_exit = 0; vp_os_mutex_init(&navdata_lock); vp_os_mutex_init(&video_lock); vp_os_mutex_init(&twist_lock); //jdeDriver = new ARDroneDriver(); int _w, _h; if (IS_ARDRONE2) { ardrone_application_default_config.video_codec = H264_360P_CODEC; _w = D2_STREAM_WIDTH; _h = D2_STREAM_HEIGHT; } else if (IS_ARDRONE1) { ardrone_application_default_config.video_codec = UVLC_CODEC; _w = D1_STREAM_WIDTH; _h = D1_STREAM_HEIGHT; } else { printf("Something must be really wrong with the SDK!"); } realtime_navdata=false; realtime_video=false; looprate=LOOPRATE; // SET SOME NON-STANDARD DEFAULT VALUES FOR THE DRIVER // THESE CAN BE OVERWRITTEN BY ROS PARAMETERS (below) ardrone_application_default_config.bitrate_ctrl_mode = VBC_MODE_DISABLED; if (IS_ARDRONE2) { ardrone_application_default_config.max_bitrate = 4000; } ardrone_application_default_config.navdata_options = NAVDATA_OPTION_FULL_MASK; ardrone_application_default_config.video_channel = ZAP_CHANNEL_HORI; ardrone_application_default_config.control_level = (0 << CONTROL_LEVEL_COMBINED_YAW); ardrone_application_default_config.flying_mode = FLYING_MODE_FREE_FLIGHT; jdeDriver->configureDrone((char*)CONFIG_FILE_PATH); cam_state=jdeDriver->getParameter("video_channel",0); char buffer[MULTICONFIG_ID_SIZE+1]; sprintf(buffer,"-%s",usr_id); printf("Deleting Profile %s\n",buffer); ARDRONE_TOOL_CONFIGURATION_ADDEVENT (profile_id, buffer, NULL); sprintf(buffer,"-%s",app_id); printf("Deleting Application %s\n",buffer); ARDRONE_TOOL_CONFIGURATION_ADDEVENT (application_id, buffer, NULL); // Now continue with the rest of the initialization ardrone_tool_input_add(&teleop); uint8_t post_stages_index = 0; //Alloc structs specific_parameters_t * params = (specific_parameters_t *)vp_os_calloc(1,sizeof(specific_parameters_t)); specific_stages_t * driver_pre_stages = (specific_stages_t*)vp_os_calloc(1, sizeof(specific_stages_t)); specific_stages_t * driver_post_stages = (specific_stages_t*)vp_os_calloc(1, sizeof(specific_stages_t)); vp_api_picture_t * in_picture = (vp_api_picture_t*) vp_os_calloc(1, sizeof(vp_api_picture_t)); vp_api_picture_t * out_picture = (vp_api_picture_t*) vp_os_calloc(1, sizeof(vp_api_picture_t)); in_picture->width = _w; in_picture->height = _h; out_picture->framerate = 20; out_picture->format = PIX_FMT_RGB24; out_picture->width = _w; out_picture->height = _h; out_picture->y_buf = (uint8_t*) vp_os_malloc( _w * _h * 3 ); out_picture->cr_buf = NULL; out_picture->cb_buf = NULL; out_picture->y_line_size = _w * 3; out_picture->cb_line_size = 0; out_picture->cr_line_size = 0; //Alloc the lists driver_pre_stages->stages_list = NULL; driver_post_stages->stages_list = (vp_api_io_stage_t*)vp_os_calloc(NB_DRIVER_POST_STAGES,sizeof(vp_api_io_stage_t)); driver_post_stages->stages_list[post_stages_index].name = "ExtractData"; driver_post_stages->stages_list[post_stages_index].type = VP_API_OUTPUT_SDL; driver_post_stages->stages_list[post_stages_index].cfg = NULL; driver_post_stages->stages_list[post_stages_index++].funcs = vp_stages_export_funcs; driver_pre_stages->length = 0; driver_post_stages->length = post_stages_index; params->in_pic = in_picture; params->out_pic = out_picture; params->pre_processing_stages_list = driver_pre_stages; params->post_processing_stages_list = driver_post_stages; params->needSetPriority = 1; params->priority = 31; // Using the provided threaded pipeline implementation from SDK START_THREAD(video_stage, params); video_stage_init(); if (ARDRONE_VERSION() >= 2) { START_THREAD (video_recorder, NULL); video_recorder_init (); video_recorder_resume_thread(); } // Threads do not start automatically video_stage_resume_thread(); ardrone_tool_set_refresh_time(25); //jdeDriver->configure_drone(); jdeDriver->initInterfaces(); START_THREAD(update_jde, jdeDriver); return C_OK; }
DEFINE_THREAD_ROUTINE(app_main, data) { C_RESULT res = C_FAIL; vp_com_wifi_config_t* config = NULL; JNIEnv* env = NULL; if (g_vm) { (*g_vm)->AttachCurrentThread (g_vm, (JNIEnv **) &env, NULL); } bContinue = TRUE; mobile_main_param_t *param = data; video_recorder_thread_param_t video_recorder_param; video_recorder_param.priority = VIDEO_RECORDER_THREAD_PRIORITY; video_recorder_param.finish_callback = param->academy_download_callback_func; vp_os_memset(&ardrone_info, 0x0, sizeof(ardrone_info_t)); while ((config = (vp_com_wifi_config_t *)wifi_config()) != NULL && strlen(config->itfName) == 0) { //Waiting for wifi initialization vp_os_delay(250); if (ardrone_tool_exit() == TRUE) { if (param != NULL && param->callback != NULL) { param->callback(env, param->obj, ARDRONE_MESSAGE_DISCONNECTED); } return 0; } } vp_os_memcpy(&ardrone_info.drone_address[0], config->server, strlen(config->server)); while (-1 == getDroneVersion (param->root_dir, &ardrone_info.drone_address[0], &ardroneVersion)) { LOGD (TAG, "Getting AR.Drone version"); vp_os_delay (250); } sprintf(&ardrone_info.drone_version[0], "%u.%u.%u", ardroneVersion.majorVersion, ardroneVersion.minorVersion, ardroneVersion.revision); LOGD (TAG, "ARDrone Version : %s\n", &ardrone_info.drone_version[0]); LOGI(TAG, "Drone Family: %d", ARDRONE_VERSION()); res = ardrone_tool_setup_com( NULL ); if( FAILED(res) ) { LOGII("Setup com failed"); LOGW(TAG, "Wifi initialization failed. It means either:"); LOGW(TAG, "\t* you're not root (it's mandatory because you can set up wifi connection only as root)\n"); LOGW(TAG, "\t* wifi device is not present (on your pc or on your card)\n"); LOGW(TAG, "\t* you set the wrong name for wifi interface (for example rausb0 instead of wlan0) \n"); LOGW(TAG, "\t* ap is not up (reboot card or remove wifi usb dongle)\n"); LOGW(TAG, "\t* wifi device has no antenna\n"); if (param != NULL && param->callback != NULL) { param->callback(env, param->obj, ARDRONE_MESSAGE_ERR_NO_WIFI); } } else { LOGII("ardrone_tool_setup_com [OK]"); #define NB_IPHONE_PRE_STAGES 0 #define NB_IPHONE_POST_STAGES 2 //Alloc structs specific_parameters_t * params = (specific_parameters_t *)vp_os_calloc(1, sizeof(specific_parameters_t)); specific_stages_t * iphone_pre_stages = (specific_stages_t*)vp_os_calloc(1, sizeof(specific_stages_t)); specific_stages_t * iphone_post_stages = (specific_stages_t*)vp_os_calloc(1, sizeof(specific_stages_t)); vp_api_picture_t * in_picture = (vp_api_picture_t*) vp_os_calloc(1, sizeof(vp_api_picture_t)); vp_api_picture_t * out_picture = (vp_api_picture_t*) vp_os_calloc(1, sizeof(vp_api_picture_t)); in_picture->width = STREAM_WIDTH; in_picture->height = STREAM_HEIGHT; out_picture->framerate = 20; out_picture->format = PIX_FMT_RGB565; out_picture->width = STREAM_WIDTH; out_picture->height = STREAM_HEIGHT; out_picture->y_buf = vp_os_malloc( STREAM_WIDTH * STREAM_HEIGHT * 2 ); out_picture->cr_buf = NULL; out_picture->cb_buf = NULL; out_picture->y_line_size = STREAM_WIDTH * 2; out_picture->cb_line_size = 0; out_picture->cr_line_size = 0; //Define the list of stages size iphone_pre_stages->length = NB_IPHONE_PRE_STAGES; iphone_post_stages->length = NB_IPHONE_POST_STAGES; //Alloc the lists iphone_pre_stages->stages_list = NULL; iphone_post_stages->stages_list = (vp_api_io_stage_t*)vp_os_calloc(iphone_post_stages->length,sizeof(vp_api_io_stage_t)); //Fill the POST-stages------------------------------------------------------ int postStageNumber = 0; vp_os_memset (&vlat, 0x0, sizeof (vlat)); vlat.state = 0; vlat.last_decoded_frame_info= (void *)&vec; iphone_post_stages->stages_list[postStageNumber].type = VP_API_FILTER_DECODER; iphone_post_stages->stages_list[postStageNumber].cfg = (void *)&vlat; iphone_post_stages->stages_list[postStageNumber++].funcs = vp_stages_latency_estimation_funcs; vp_os_memset (&ovsc, 0x0, sizeof (ovsc)); ovsc.video_decoder = &vec; iphone_post_stages->stages_list[postStageNumber].type = VP_API_OUTPUT_LCD; iphone_post_stages->stages_list[postStageNumber].cfg = (void *)&ovsc; iphone_post_stages->stages_list[postStageNumber++].funcs = opengl_video_stage_funcs; params->in_pic = in_picture; params->out_pic = out_picture; params->pre_processing_stages_list = iphone_pre_stages; params->post_processing_stages_list = iphone_post_stages; #if USE_THREAD_PRIORITIES params->needSetPriority = 1; params->priority = VIDEO_THREAD_PRIORITY; #else params->needSetPriority = 0; params->priority = 0; #endif START_THREAD(video_stage, params); if (IS_LEAST_ARDRONE2) { START_THREAD (video_recorder, (void *)&video_recorder_param); LOGD(TAG, "Video recorder thread start [OK]"); } res = ardrone_tool_init(&ardrone_info.drone_address[0], strlen(&ardrone_info.drone_address[0]), NULL, param->app_name, param->user_name, param->root_dir, param->flight_dir, param->flight_storing_size, param->academy_download_callback_func); if(SUCCEED(res)) { ardrone_tool_input_add(&virtual_gamepad); if (param != NULL && param->callback != NULL) { param->callback(env, param->obj, ARDRONE_MESSAGE_CONNECTED_OK); } } else { if (param != NULL && param->callback != NULL) { param->callback(env, param->obj, ARDRONE_MESSAGE_UNKNOWN_ERR); } bContinue = FALSE; } res = ardrone_tool_set_refresh_time(1000 / kAPS); #if USE_THREAD_PRIORITIES CHANGE_THREAD_PRIO (app_main, AT_THREAD_PRIORITY); CHANGE_THREAD_PRIO (navdata_update, NAVDATA_THREAD_PRIORITY); CHANGE_THREAD_PRIO (ardrone_control, NAVDATA_THREAD_PRIORITY); #endif while( SUCCEED(res) && bContinue == TRUE ) { ardrone_tool_update(); } JOIN_THREAD(video_stage); if (IS_LEAST_ARDRONE2) { JOIN_THREAD (video_recorder); } /* Unregistering for the current device */ ardrone_tool_input_remove( &virtual_gamepad ); res = ardrone_tool_shutdown(); LOGD(TAG, "AR.Drone tool shutdown [OK]"); if (param != NULL && param->callback != NULL) { param->callback(env, param->obj, ARDRONE_MESSAGE_DISCONNECTED); } } vp_os_free (data); data = NULL; (*env)->DeleteGlobalRef(env, param->obj); if (g_vm) { (*g_vm)->DetachCurrentThread (g_vm); } LOGI(TAG, "app_main thread has been stopped."); return (THREAD_RET) res; }