static void check_device_task(struct state_machine_context *state_m) { Ai_player_flag_t player_flag_temp; static uint32_t old_status = 0; static t_cpu_time get_play_time_timer = { .timer_state = CPU_TIMER_STATE_STOPPED }; // By default, the command executed is asynchronous. state_m->async_cmd = true; switch (state_m->state) { // This state id the entry point of the check device function. case STATE_CHECK_DEVICE_ENTRY_POINT: state_m->cmd_status = true; if (usb_device_get_state() != DEVICE_STATE_READY) { state_m->async_cmd = false; state_m->state = STATE_DEVICE_DISCONNECTED; break; } if( cpu_is_timer_stopped(&get_play_time_timer) ) { cpu_set_timeout(cpu_ms_2_cy(ELAPSED_TIME_TIMER_VALUE_MS, FCPU_HZ), &get_play_time_timer); ai_async_audio_ctrl_status(); state_m->state = STATE_CHECK_DEVICE_UPDATE_STATUS; } else { if( cpu_is_timeout(&get_play_time_timer) ) { cpu_stop_timeout(&get_play_time_timer); } state_m->async_cmd = false; player_flag_temp.all = old_status; update_player_status(state_m, (Ai_player_flag_t *) &player_flag_temp); state_m->state = state_m->recorded_state; } break; // This state update the elapsed time of the current track being played. case STATE_CHECK_DEVICE_UPDATE_STATUS: state_m->async_cmd = false; player_flag_temp.all = ai_async_cmd_out_u32(); update_player_status(state_m, (Ai_player_flag_t *) &player_flag_temp); // The transitional states such as "new file played" can not be kept in the saved status. // Otherwise, we will send during 'ELAPSED_TIME_TIMER_VALUE_MS' second(s) a saved status with // the "new_file_played" event, leading do a full redisplay of the metadata information and audio // cracks. In other words, the saved status needs to keep the states (play/pause/...), not the events. player_flag_temp.new_file_played = 0; player_flag_temp.new_directory = 0; old_status = player_flag_temp.all; state_m->state = state_m->recorded_state; break; default: return; } // Error management if (state_m->cmd_status == false) state_m->state = STATE_DEVICE_DISCONNECTED; }
//! //! @brief This function displays the MMI interface and some static informations. //! static void mmi_display( void ) { #if (defined __GNUC__) || ((defined USB_RESYNC_METHOD) && (USB_RESYNC_METHOD == USB_RESYNC_METHOD_SOFT_ADD_DEL_SAMPLES)) char tmp[64]; #endif if( mmi_state!=11 ) { if( mmi_state==0 ) { cpu_set_timeout( cpu_ms_2_cy(TIMER_STARTUP, FCPU_HZ), &timer ); mmi_state++; } else if( cpu_is_timeout(&timer) ) { switch( mmi_state++ ) { case 1: LED_On( LED0 ); cpu_set_timeout( cpu_ms_2_cy(TIMER_STARTUP, FCPU_HZ), &timer ); // Clear the display et024006_DrawFilledRect(0, 0, ET024006_WIDTH, ET024006_HEIGHT, WHITE ); // Display a logo. et024006_PutPixmap(avr32_logo, AVR32_LOGO_WIDTH, 0, 0 ,(ET024006_WIDTH - AVR32_LOGO_WIDTH)/2 ,(ET024006_HEIGHT - AVR32_LOGO_HEIGHT)/2, AVR32_LOGO_WIDTH, AVR32_LOGO_HEIGHT); et024006_PrintString(AUDIO_DEMO_STRING , (const unsigned char *)&FONT8x16, 30, 5, BLACK, -1); #if(defined USB_RESYNC_METHOD) #if (defined USB_RESYNC_METHOD) && (USB_RESYNC_METHOD == USB_RESYNC_METHOD_EXT_CLOCK_SYNTHESIZER) et024006_PrintString("32/44.1/48 KHz, HID, CS2200" , (const unsigned char *)&FONT8x8, 50, START_Y_DEMO_TEXT+0*FONT_HEIGHT, BLUE, -1); #elif (defined USB_RESYNC_METHOD) && (USB_RESYNC_METHOD == USB_RESYNC_METHOD_SOFT_ADAPTIF_SRC) et024006_PrintString("%32/44.1/48 KHz, HID, adaptive SRC", (const unsigned char *)&FONT8x8, 50, START_Y_DEMO_TEXT+0*FONT_HEIGHT, BLUE, -1); #elif (defined USB_RESYNC_METHOD) && (USB_RESYNC_METHOD == USB_RESYNC_METHOD_SOFT_ADD_DEL_SAMPLES) sprintf( tmp, "%d.%d KHz, HID, Add/remove sample", SPEAKER_FREQUENCY/1000, SPEAKER_FREQUENCY%1000); et024006_PrintString(tmp, (const unsigned char *)&FONT8x8, 50, START_Y_DEMO_TEXT+0*FONT_HEIGHT, BLUE, -1); #else #error Unknown synchronization method. #endif #endif // Display bargraph window. mmi_activity_display(true, (uint32_t)NULL); #if (defined __GNUC__) sprintf( tmp, "RAM (DATA): %ld bytes", (uint32_t)&_edata-(uint32_t)&_data); et024006_PrintString(tmp, (const unsigned char *)&FONT8x8, 50, START_Y_DEMO_TEXT+10*FONT_HEIGHT, BLUE, -1); sprintf( tmp, "RAM (BSS): %ld bytes", (uint32_t)&end-(uint32_t)&__bss_start); et024006_PrintString(tmp, (const unsigned char *)&FONT8x8, 50, START_Y_DEMO_TEXT+11*FONT_HEIGHT, BLUE, -1); sprintf( tmp, "RAM (STACK): %ld bytes", (uint32_t)&_estack-(uint32_t)&_stack); et024006_PrintString(tmp, (const unsigned char *)&FONT8x8, 50, START_Y_DEMO_TEXT+12*FONT_HEIGHT, BLUE, -1); #endif #if (defined __GNUC__) et024006_PrintString("RAM (total used HEAP): bytes", (const unsigned char *)&FONT8x8, 50, START_Y_DEMO_TEXT+13*FONT_HEIGHT, BLUE, WHITE); et024006_PrintString("RAM (curr used HEAP): bytes", (const unsigned char *)&FONT8x8, 50, START_Y_DEMO_TEXT+14*FONT_HEIGHT, BLUE, WHITE); #elif (defined __ICCAVR32__) et024006_PrintString("RAM (free HEAP): bytes", (const unsigned char *)&FONT8x8, 50, START_Y_DEMO_TEXT+14*FONT_HEIGHT, BLUE, WHITE); #endif break; case 2: cpu_set_timeout( cpu_ms_2_cy(TIMER_STARTUP, FCPU_HZ), &timer ); LED_On( LED1 ); break; case 3: cpu_set_timeout( cpu_ms_2_cy(TIMER_STARTUP, FCPU_HZ), &timer ); LED_On( LED2 ); break; case 4: cpu_set_timeout( cpu_ms_2_cy(TIMER_STARTUP, FCPU_HZ), &timer ); LED_On( LED3 ); break; case 5: cpu_set_timeout( cpu_ms_2_cy(TIMER_STARTUP, FCPU_HZ), &timer ); LED_Off( LED0 ); break; case 6: cpu_set_timeout( cpu_ms_2_cy(TIMER_STARTUP, FCPU_HZ), &timer ); LED_Off( LED1 ); break; case 7: cpu_set_timeout( cpu_ms_2_cy(TIMER_STARTUP, FCPU_HZ), &timer ); LED_Off( LED2 ); break; case 8: LED_Off( LED3 ); cpu_stop_timeout(&timer); break; default: break; } } } }
/*! \brief Entry point of the audio management interface. * */ void com_task(void) { static struct state_machine_context state_m = { .state = STATE_INITIALIZATION, .async_cmd = false, .view = GUI_UPDATE_VIEW_NONE, .view_elt = GUI_UPDATE_ELT_NONE, .elapsed_time_timer.timer_state = CPU_TIMER_STATE_STOPPED }; // Update the GUI gui_update(state_m.view, &state_m.view_elt, &state_m.display_list, &state_m.info, &state_m.player_status); // Ask the audio interface to execute pending tasks ai_async_cmd_task(); if (state_m.async_cmd) { // If current command is not done if (!is_ai_async_cmd_finished()) { // If it is a new command that is being proceed if (state_m.in_progress_timer.timer_state == CPU_TIMER_STATE_STOPPED) cpu_set_timeout(cpu_ms_2_cy(500, FCPU_HZ), &state_m.in_progress_timer); // If current command is not done and it is taking a long else if (cpu_is_timeout(&state_m.in_progress_timer)) state_m.view_elt |= GUI_UPDATE_ELT_IN_PROGRESS; return; } else { state_m.cmd_status = ai_async_cmd_out_status(); cpu_stop_timeout(&state_m.in_progress_timer); } } // If a device is connected if (state_m.state != STATE_INITIALIZATION && state_m.state != STATE_IDLE_ENTRY_POINT && state_m.state != STATE_IDLE_WAIT_FOR_EVENT) { // If no device is connected, then jump to the disconnection state if (ai_is_none()) { ai_command_abort(); state_m.state = STATE_DEVICE_DISCONNECTED; } } switch (state_m.state) { case STATE_INITIALIZATION: state_m.state = STATE_IDLE_ENTRY_POINT; cpu_stop_timeout(&state_m.in_progress_timer); // Set default volume if specified #if defined(DEFAULT_VOLUME) audio_mixer_dacs_set_volume(DEFAULT_VOLUME); #endif break; case STATE_DEVICE_CONNECTED: controller_init(FCPU_HZ, FHSB_HZ, FPBB_HZ, FPBA_HZ); state_m.state = STATE_NAVIGATION_ENTRY_POINT; state_m.view_elt |= GUI_UPDATE_ELT_CONNECTED; break; case STATE_DEVICE_DISCONNECTED: controller_shutdown(); state_m.state = STATE_IDLE_ENTRY_POINT; state_m.view_elt |= GUI_UPDATE_ELT_DISCONNECTED; break; case STATE_IDLE_ENTRY_POINT: case STATE_IDLE_WAIT_FOR_EVENT: case STATE_IDLE_DRIVE_LOAD: idle_task(&state_m); break; case STATE_NAVIGATION_ENTRY_POINT: case STATE_NAVIGATION_UPDATE_LIST: case STATE_NAVIGATION_UPDATE_LIST_GET_NAME: case STATE_NAVIGATION_UPDATE_LIST_STORE_NAME: case STATE_NAVIGATION_UPDATE_ISDIR: case STATE_NAVIGATION_WAIT_FOR_EVENT: case STATE_NAVIGATION_UPDATE_STATUS: case STATE_NAVIGATION_CD: case STATE_NAVIGATION_GOTOPARENT: case STATE_NAVIGATION_GOTOPARENT_ERROR_HANDLING: case STATE_NAVIGATION_PLAY_SELECTED_FILE: case STATE_NAVIGATION_WAIT_FOR_SELECTION: case STATE_NAVIGATION_UPDATE_METADATA_AND_PLAY: navigation_task(&state_m); break; case STATE_PLAYBACK_ENTRY_POINT: case STATE_PLAYBACK_WAIT_FOR_EVENT: case STATE_PLAYBACK_HANDLE_FAST_MODES: case STATE_PLAYBACK_UPDATE_TIME: case STATE_PLAYBACK_UPDATE_STATUS: playback_task(&state_m); break; case STATE_CONFIG_ENTRY_POINT: case STATE_CONFIG_WAIT_FOR_EVENT: case STATE_CONFIG_UPDATE_STATES: case STATE_CONFIG_READ_REPEAT_STATE: case STATE_CONFIG_READ_SHUFFLE_STATE: config_task(&state_m); break; case STATE_CHECK_DEVICE_ENTRY_POINT: case STATE_CHECK_DEVICE_UPDATE_STATUS: check_device_task(&state_m); break; case STATE_TRACK_CHANGED_ENTRY_POINT: case STATE_TRACK_CHANGED_TOTAL_TIME: case STATE_TRACK_CHANGED_FILE_NAME: case STATE_TRACK_CHANGED_ARTIST: case STATE_TRACK_CHANGED_TITLE: case STATE_TRACK_CHANGED_IMAGE: case STATE_TRACK_CHANGED_RESUME: case STATE_TRACK_CHECK_RESUME: track_changed_task(&state_m); break; case STATE_COMMAND_PLAY_ANY_SONG: command_task(&state_m); break; default: break; } /* // Power sleep mode is managed here if( usb_device_get_state()==DEVICE_STATE_NOT_CONNECTED ) { if( cpu_is_timer_stopped(&sleep_timer) ) { cpu_set_timeout(cpu_ms_2_cy(SLEEP_MODE_MS, FCPU_HZ), &sleep_timer); } else if( cpu_is_timeout(&sleep_timer) ) { gui_enter_idle(); SLEEP(AVR32_PM_SMODE_IDLE); gui_leave_idle(); } } else { cpu_stop_timeout(&sleep_timer); } */ }
/*! \brief Initializes the hardware/software resources required for the task. */ void com_task_init(void) { cpu_stop_timeout(&sleep_timer); gui_init(FCPU_HZ, FHSB_HZ, FPBB_HZ, FPBA_HZ); }
// main function int main(void) { t_cpu_time timeout; t_cpu_time timeout_mpu; float deltat_2; float roll_first, pitch_first; board_init(); hal.init(0,NULL); hal.analogin->init(); sysclk_init(); init_sys_clocks(); float initials[3]; int16_t magnetic[3]; float yaw_first; float soft[3],hard[3]; float desti[2]; float kp = 4.8; float kpp = 0.7; float kd = 0; mpu9150.initMPU9150(FCPU_HZ); mpu9150.initHMC58(); mpu9150.calibrate_mpu9150(initials); int16_t myMagData[3]; hal.uartB->println("NEE ZAFERINDEN BAHSEDIYORSUUN"); float percent = 40; uint8_t c, last_c; uint16_t count = 0; cpu_set_timeout(cpu_ms_2_cy(10, FOSC0), &timeout_mpu); cpu_set_timeout(cpu_ms_2_cy(1000, FOSC0), &timeout); hal.uartB->println("VER COSKUYU"); c = hal.uartB->read(); motor.motors_init(); while(1){ if (usart_test_hit(&AVR32_USART4)) { hal.uartB->println("I am hit"); last_c = c; c = hal.uartB->read(); if(c == '9') { motor.kill_motors(); hal.uartB->println("KIRDIN BENI GOD DAMNIT"); while(1); } if (c == '8') { percent += 1; hal.uartB->print("Percent Increased to: "); hal.uartB->println(percent); } if (c == '2') { percent -= 1; hal.uartB->print("Percent Decreased to: "); hal.uartB->println(percent); } if (c == 'u') { kpp = kpp + 0.1; hal.uartB->print("Kpp is: "); hal.uartB->println(kpp); } if (c == 'j') { kpp = kpp - 0.1; hal.uartB->print("Kpp is: "); hal.uartB->println(kpp); } if (c == 't') { kd = kd + 0.001; hal.uartB->print("Kd is: "); hal.uartB->println(kd); } if (c == 'g') { kd = kd - 0.001; hal.uartB->print("Kd is: "); hal.uartB->println(kd); } if (c == 'y') { kp = kp + 0.1; hal.uartB->print("Kp is: "); hal.uartB->println(kp); } if (c == 'h') { kp = kp - 0.1; hal.uartB->print("Kp is: "); hal.uartB->println(kp); } c = last_c; } if (c == '5') { // if(cpu_is_timeout(&timeout_mpu)) { cpu_stop_timeout(&timeout_mpu); mpu9150.update(); PID_Pitch = Pitch_Controller(pitch,initials[1],kp,kpp,0,kd,0.01f); motor.motor1_update(percent,PID_Pitch,0,0); motor.motor3_update(percent,PID_Pitch,0,0); cpu_set_timeout(cpu_ms_2_cy(10, FOSC0), &timeout_mpu); } // if(cpu_is_timeout(&timeout)) { // cpu_stop_timeout(&timeout); // hal.uartB->println(PID_Pitch); // // cpu_set_timeout(cpu_ms_2_cy(1000, FOSC0), &timeout); // } // float PID_Pitch = Pitch_Controller(pitch,initials[1],kp,kd,0,0,deltat); // motor.motor1_update(percent,PID_Pitch,0,0); // deltat =(float) cpu_cy_2_ms((Get_sys_count()),FOSC0)/1000; // cpu_set_timeout( cpu_ms_2_cy(10000, FOSC0), &timeout); // Set_sys_count(0); } } }