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