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; }
bool controller_key_back(void) { static bool start = false; static t_cpu_time tempo; if (!IS_JOYSTICK_KEY_PRESSED()) { gpio_set_gpio_pin(LED0_GPIO); start = false; return false; } if (!start) { cpu_set_timeout(cpu_ms_2_cy(1000, static_fcpu_hz), &tempo); start = true; } if (cpu_is_timeout(&tempo)) { gpio_clr_gpio_pin(LED0_GPIO); no_store = true; start = false; return true; } gpio_set_gpio_pin(LED0_GPIO); return false; }
/** * \brief Fractal Algorithm with FPU optimization. */ static int draw_mandel_with_fpu(void) { t_cpu_time timer; while (i_wfpu<HEIGHT/2+1) { cpu_set_timeout( cpu_us_2_cy(DELAY_US,pcl_freq_param.cpu_f), &timer ); while(j_wfpu<WIDTH) { z_wfpu = 0; zi_wfpu = 0; inset_wfpu = 1; while (k_wfpu<iter_wfpu) { /* z^2 = (a+bi)(a+bi) = a^2 + 2abi - b^2 */ newz_wfpu = (z_wfpu*z_wfpu)-(zi_wfpu*zi_wfpu) + x_wfpu; newzi_wfpu = 2*z_wfpu*zi_wfpu + y_wfpu; z_wfpu = newz_wfpu; zi_wfpu = newzi_wfpu; if(((z_wfpu*z_wfpu)+(zi_wfpu*zi_wfpu)) > 4) { inset_wfpu = 0; colour_wfpu = k_wfpu; k_wfpu = iter_wfpu; } k_wfpu++; }; k_wfpu = 0; // Draw Mandelbrot set if (inset_wfpu) { et024006_DrawPixel(j_wfpu,i_wfpu+OFFSET_DISPLAY,BLACK); et024006_DrawPixel(j_wfpu,HEIGHT-i_wfpu+OFFSET_DISPLAY,BLACK); } else { et024006_DrawPixel(j_wfpu, i_wfpu+OFFSET_DISPLAY, BLUE_LEV((colour_wfpu*255) / iter_wfpu )+ GREEN_LEV((colour_wfpu*127) / iter_wfpu )+ RED_LEV((colour_wfpu*127) / iter_wfpu )); et024006_DrawPixel(j_wfpu, HEIGHT-i_wfpu+OFFSET_DISPLAY, BLUE_LEV((colour_wfpu*255) / iter_wfpu )+ GREEN_LEV((colour_wfpu*127) / iter_wfpu )+ RED_LEV((colour_wfpu*127) / iter_wfpu )); } x_wfpu += xstep_wfpu; j_wfpu++; }; j_wfpu = 0; y_wfpu += ystep_wfpu; x_wfpu = xstart_wfpu; i_wfpu++; if( cpu_is_timeout(&timer) ) { return 0; } }; return 1; }
static bool is_joystick_released_pressed(void) { if (IS_JOYSTICK_RELEASED_KEY_PRESSED() && cpu_is_timeout(&joystick_key_sensibility_timer)) { cpu_set_timeout(cpu_ms_2_cy(JOYSTICK_KEY_DEBOUNCE_MS, static_fcpu_hz), &joystick_key_sensibility_timer); return true; } return false; }
static bool is_joystick_left(void) { if (IS_JOYSTICK_KEY_LEFT() && cpu_is_timeout(&joystick_key_sensibility_timer)) { cpu_set_timeout(cpu_ms_2_cy(JOYSTICK_KEY_DEBOUNCE_MS, static_fcpu_hz), &joystick_key_sensibility_timer); return true; } return false; }
static bool is_joystick_released_right(void) { if (IS_JOYSTICK_ONLY_RELEASED_KEY_RIGHT() && cpu_is_timeout(&joystick_key_sensibility_timer)) { CLEAR_JOYSTICK_RELEASED_KEY_RIGHT(); cpu_set_timeout(cpu_ms_2_cy(JOYSTICK_KEY_DEBOUNCE_MS, static_fcpu_hz), &joystick_key_sensibility_timer); return true; } return false; }
bool controller_playback_next_track(void) { bool status = false; if (IS_JOYSTICK_KEY_PRESSED() || (fast_mode && cpu_is_timeout(&joystick_key_sensibility_timer))) return false; if (IS_JOYSTICK_RELEASED_KEY_RIGHT()) status = true; CLEAR_JOYSTICK_RELEASED_KEY_RIGHT(); return status; }
__interrupt #endif void touch_button_isr(void) { manage_button_isr(QT1081_TOUCH_SENSOR_UP, JOYSTICK_STATUS_UP, JOYSTICK_STATUS_RELEASED_UP); manage_button_isr(QT1081_TOUCH_SENSOR_DOWN, JOYSTICK_STATUS_DOWN, JOYSTICK_STATUS_RELEASED_DOWN); manage_button_isr(QT1081_TOUCH_SENSOR_RIGHT, JOYSTICK_STATUS_RIGHT, JOYSTICK_STATUS_RELEASED_RIGHT); manage_button_isr(QT1081_TOUCH_SENSOR_LEFT, JOYSTICK_STATUS_LEFT, JOYSTICK_STATUS_RELEASED_LEFT); manage_button_isr(QT1081_TOUCH_SENSOR_ENTER, JOYSTICK_STATUS_PRESSED, JOYSTICK_STATUS_RELEASED_PRESSED); // Handle left slide if (IS_JOYSTICK_RELEASED_KEY_PRESSED() && IS_JOYSTICK_KEY_LEFT()) { CLEAR_JOYSTICK_RELEASED_KEY_PRESSED(); CLEAR_JOYSTICK_KEY_LEFT(); joystick_status |= JOYSTICK_STATUS_SLIDING_LEFT; } if (IS_JOYSTICK_KEY_SLIDING_LEFT() && IS_JOYSTICK_RELEASED_KEY_LEFT()) { CLEAR_JOYSTICK_KEY_SLIDING_LEFT(); CLEAR_JOYSTICK_RELEASED_KEY_LEFT(); joystick_status |= JOYSTICK_STATUS_SLIDE_LEFT; } // Handle right slide if (IS_JOYSTICK_RELEASED_KEY_PRESSED() && IS_JOYSTICK_KEY_RIGHT()) { CLEAR_JOYSTICK_RELEASED_KEY_PRESSED(); CLEAR_JOYSTICK_KEY_RIGHT(); joystick_status |= JOYSTICK_STATUS_SLIDING_RIGHT; } if (IS_JOYSTICK_KEY_SLIDING_RIGHT() && IS_JOYSTICK_RELEASED_KEY_RIGHT()) { CLEAR_JOYSTICK_KEY_SLIDING_RIGHT(); CLEAR_JOYSTICK_RELEASED_KEY_RIGHT(); joystick_status |= JOYSTICK_STATUS_SLIDE_RIGHT; } if (fast_mode && cpu_is_timeout(&joystick_key_sensibility_timer)) { CLEAR_JOYSTICK_RELEASED_KEY_RIGHT(); CLEAR_JOYSTICK_RELEASED_KEY_LEFT(); } if (!IS_JOYSTICK_KEY_LEFT() && !IS_JOYSTICK_KEY_RIGHT()) fast_mode = false; gpio_tgl_gpio_pin(LED0_GPIO); }
bool controller_playback_frw(bool new_track) { if (IS_JOYSTICK_KEY_LEFT()) { if (new_track) cpu_set_timeout(cpu_ms_2_cy(2000, static_fcpu_hz), &joystick_key_sensibility_timer); if (!fast_mode) { cpu_set_timeout(cpu_ms_2_cy(1000, static_fcpu_hz), &joystick_key_sensibility_timer); fast_mode = true; } else if (cpu_is_timeout(&joystick_key_sensibility_timer)) return true; return false; } return false; }
//! //! @brief This function ensures that no underflow/underflow will never occur //! by adjusting the SSC/ABDAC frequencies. void usb_stream_resync(void) { if (!usb_stream_context->synchronized) return; if( !cpu_is_timeout(&usb_resync_timer) ) return; if( twi_is_busy() ) return; // time-out occur. Let's check frequency deviation. int nb_full_buffers = usb_stream_fifo_get_used_room(); // Frequency control if( nb_full_buffers>USB_STREAM_BUFFER_NUMBER/2 ) { // Need to increase the frequency if( nb_full_buffers >= usb_stream_resync_last_room ) { usb_stream_resync_freq_ofst += usb_stream_resync_step; usb_stream_resync_ppm_ofst += USB_STREAM_RESYNC_PPM_STEPS; usb_stream_resync_last_room = nb_full_buffers; cs2200_freq_clk_adjust((uint16_t)_32_BITS_RATIO(usb_stream_resync_freq_ofst, CS2200_FREF)); cpu_set_timeout( cpu_ms_2_cy(TIMER_USB_RESYNC_CORRECTION, FCPU_HZ), &usb_resync_timer ); } } else if (nb_full_buffers<USB_STREAM_BUFFER_NUMBER/2 ) { // Need to slow down the frequency if( nb_full_buffers <= usb_stream_resync_last_room ) { usb_stream_resync_freq_ofst -= usb_stream_resync_step; usb_stream_resync_ppm_ofst -= USB_STREAM_RESYNC_PPM_STEPS; usb_stream_resync_last_room = nb_full_buffers; cs2200_freq_clk_adjust((uint16_t)_32_BITS_RATIO(usb_stream_resync_freq_ofst, CS2200_FREF)); cpu_set_timeout( cpu_ms_2_cy(TIMER_USB_RESYNC_CORRECTION, FCPU_HZ), &usb_resync_timer ); } } }
/*! \brief Main function. Execution starts here. */ int main(void) { U32 n_sector = 0; U32 card_size; // Unit is in sector. U32 bench_start_sector; U16 i = 0; U16 j = 0; t_cpu_time timer; Ctrl_status status; // Set CPU and PBA clock if( PM_FREQ_STATUS_FAIL==pm_configure_clocks(&pm_freq_param) ) return 42; // Initialize HMatrix init_hmatrix(); // Initialize debug RS232 with PBA clock init_dbg_rs232(pm_freq_param.pba_f); // Start test print_dbg("\r\nInitialize SD/MMC driver"); // Initialize SD/MMC driver resources: GPIO, SDIO and SD/MMC. sd_mmc_mci_resources_init(); // Wait for a card to be inserted #if (BOARD == EVK1104) #if EXAMPLE_SD_SLOT == SD_SLOT_8BITS print_dbg("\r\nInsert a MMC/SD card into the SD/MMC 8bits slot..."); #elif EXAMPLE_SD_SLOT == SD_SLOT_4BITS print_dbg("\r\nInsert a MMC/SD card into the SD/MMC 4bits slot..."); #else # error SD_SLOT not supported #endif while (!sd_mmc_mci_mem_check(EXAMPLE_SD_SLOT)); #else # error Board not supported #endif print_dbg("Card detected!\r\n"); // Read Card capacity sd_mmc_mci_read_capacity(EXAMPLE_SD_SLOT, &card_size); print_dbg("\r\nCapacity = "); print_dbg_ulong(card_size*512); print_dbg(" Bytes\r\n"); // Read the first sector number 0 of the card status = sd_mmc_mci_mem_2_ram(EXAMPLE_SD_SLOT, 0, buffer_in); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } // Display the ram_buffer content print_dbg("\r\nFirst sector of the card:\r\n"); for (i=0;i<(512);i++) { print_dbg_char_hex(buffer_in[i]); j++; if (j%32==0) print_dbg("\r\n"), j=0; else if (j%4==0) print_dbg(" "); } // Write some patterns in the first sector number 0 of the card print_dbg("Testing write.\r\n"); if( !test_sd_mmc_write(0) ) return -1; if( !test_sd_mmc_write(1) ) return -1; if( !test_sd_mmc_write(2) ) return -1; if( !test_sd_mmc_write(3) ) return -1; // Bench single-block read operations without DMA // print_dbg("Benching single-block read (without DMA). Please wait..."); n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_mem_2_ram(EXAMPLE_SD_SLOT, n_sector, buffer_in); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector+=1; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench single-block read operations with DMA // print_dbg("Benching single-block read (with DMA). Please wait..."); n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_dma_mem_2_ram(EXAMPLE_SD_SLOT, n_sector, buffer_in); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector+=1; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench multi-block read operations without DMA // print_dbg("Benching multi-block read (without DMA). Please wait..."); n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_multiple_mem_2_ram(EXAMPLE_SD_SLOT, n_sector, buffer_in, ALLOCATED_SECTORS); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector+=ALLOCATED_SECTORS; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench multi-block read operations with DMA // print_dbg("Benching multi-block read (with DMA). Please wait..."); n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_dma_multiple_mem_2_ram(EXAMPLE_SD_SLOT, n_sector, buffer_in, ALLOCATED_SECTORS); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector+=ALLOCATED_SECTORS; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench single-block write operations without DMA // print_dbg("Benching single-block write (without DMA). Please wait..."); status = sd_mmc_mci_mem_2_ram(EXAMPLE_SD_SLOT, 0, buffer_in); // Backup the first sector number 0 of the card if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_ram_2_mem(EXAMPLE_SD_SLOT, n_sector, buffer_in); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not write device.\r\n"); return -1; } n_sector+=1; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench single-block write operations with DMA // print_dbg("Benching single-block write (with DMA). Please wait..."); status = sd_mmc_mci_mem_2_ram(EXAMPLE_SD_SLOT, 0, buffer_in); // Backup the first sector number 0 of the card if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_dma_ram_2_mem(EXAMPLE_SD_SLOT, n_sector, buffer_in); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not write device.\r\n"); return -1; } n_sector+=1; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench multi-block write operations without DMA // print_dbg("Benching multi-block write (without DMA). Please wait..."); status = sd_mmc_mci_mem_2_ram(EXAMPLE_SD_SLOT, 0, buffer_in); // Backup the first sector number 0 of the card if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_multiple_ram_2_mem(EXAMPLE_SD_SLOT, n_sector, buffer_in, ALLOCATED_SECTORS); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not write device.\r\n"); return -1; } n_sector+=ALLOCATED_SECTORS; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench multi-block write operations with DMA // print_dbg("Benching multi-block write (with DMA). Please wait..."); status = sd_mmc_mci_mem_2_ram(EXAMPLE_SD_SLOT, 0, buffer_in); // Backup the first sector number 0 of the card if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_dma_multiple_ram_2_mem(EXAMPLE_SD_SLOT, n_sector, buffer_in, ALLOCATED_SECTORS); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not write device.\r\n"); return -1; } n_sector+=ALLOCATED_SECTORS; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); return 0; }
//! //! @brief This function displays the a bargraph indicating the state of the audio buffers and //! the PPM deviation between the incoming USB audio sampling frequency and the output DAC sampling frequency. //! static void mmi_activity_display( bool init, uint32_t fifo_cnt ) { static char tmp[20]; static int32_t ppm; #define TIMER_MMI 1000 // Unit is in ms. static t_cpu_time mmi_timer; static uint32_t old_fcpu_hz = 0; static uint32_t mmi_activity_state=0; static uint32_t i; if( init ) { // Display PPM window et024006_PrintString("PPM", (const unsigned char *)&FONT8x8, 22, 70+4, BLUE, -1); display_box(50, 70, 40, 16, WHITE, BLACK); et024006_PrintString("HID", (const unsigned char *)&FONT8x8, 122, 70+4, BLUE, -1); display_box(150, 70, 40, 16, WHITE, BLACK); et024006_PrintString("CPU", (const unsigned char *)&FONT8x8, 222, 70+4, BLUE, -1); display_box(250, 70, 40, 16, WHITE, BLACK); et024006_PrintString("Buffers", (const unsigned char *)&FONT8x8, 0, 50+4, BLUE, -1); display_box(50, 50, 195, 16, WHITE, BLACK); cpu_set_timeout( cpu_ms_2_cy(TIMER_MMI, FCPU_HZ), &mmi_timer ); goto mmi_end; } if( !cpu_is_timeout(&mmi_timer) ) goto mmi_end; switch( mmi_activity_state ) { case 0: i = 0; mmi_activity_state = 1; // no break here case 1: if( i>=USB_STREAM_BUFFER_NUMBER ) { mmi_activity_state = 10; break; } if( i<fifo_cnt ) et024006_DrawFilledRect(50+3 + i*(10+2), 50+3, 10, 10, BLUE_LEV(15) ); else et024006_DrawFilledRect(50+3 + i*(10+2), 50+3, 10, 10, WHITE ); i++; break; case 10: ppm = usb_stream_ppm_get(); sprintf( tmp, "%4ld", ppm ); et024006_PrintString(tmp, (const unsigned char *)&FONT8x8, 50+4, 70+4, BLUE, WHITE); mmi_activity_state = 20; break; case 20: if( old_fcpu_hz==FCPU_HZ ) { mmi_activity_state = 30; break; } else mmi_activity_state = 21; // No break here case 21: old_fcpu_hz=FCPU_HZ; sprintf( tmp, "%ld", (uint32_t)FCPU_HZ/1000000); et024006_PrintString(tmp, (const unsigned char *)&FONT8x8, 250+4, 70+4, BLUE, WHITE); mmi_activity_state = 30; break; #if (defined __GNUC__) case 30: sprintf( tmp, "%ld", get_heap_total_used_size() ); et024006_PrintString(tmp, (const unsigned char *)&FONT8x8, 230, START_Y_DEMO_TEXT+13*FONT_HEIGHT, BLUE, WHITE); mmi_activity_state = 31; break; case 31: sprintf( tmp, "%ld", get_heap_curr_used_size() ); et024006_PrintString(tmp, (const unsigned char *)&FONT8x8, 230, START_Y_DEMO_TEXT+14*FONT_HEIGHT, BLUE, WHITE); // No break here #elif (defined __ICCAVR32__) case 30: sprintf( tmp, "%ld", get_heap_free_size() ); et024006_PrintString(tmp, (const unsigned char *)&FONT8x8, 230, START_Y_DEMO_TEXT+14*FONT_HEIGHT, BLUE, WHITE); // No break here #endif default: // Rearm timer cpu_set_timeout( cpu_ms_2_cy(TIMER_MMI, FCPU_HZ), &mmi_timer ); mmi_activity_state = 0; break; } mmi_end: return; }
//! //! @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 This function takes the stream coming from the selected USB pipe and sends //! it to the DAC driver. Moreover, it ensures that both input and output stream //! keep synchronized by adding or deleting samples. //! //! @param side USB_STREAM_HOST for USB host, USB_STREAM_DEVICE for device. //! @param pipe_in Number of the addressed pipe/endpoint //! @param pFifoCount (return parameter) NULL or pointer to the number of used buffers at this time //! //! @return status: (USB_STREAM_STATUS_OK, USB_STREAM_STATUS_NOT_SYNCHRONIZED, //! USB_STREAM_STATUS_SPEED_UP, USB_STREAM_STATUS_SLOW_DOWN, USB_STREAM_STATUS_BUFFER_OVERFLOW) //! int usb_stream_input(usb_stream_side_t side, uint8_t pipe_in, uint32_t* pFifoCount) { uint16_t fifo_used_cnt; uint16_t byte_count=0; uint32_t i; UnionPtr pswap; UnionPtr buffer; // We comes here since we have received something. Let's increase the internal // activity counter. usb_stream_cnt++; fifo_used_cnt=usb_stream_fifo_get_used_room(); if (pFifoCount) *pFifoCount = fifo_used_cnt; // usb_stream_fifo_get_free_room() if( USB_STREAM_BUFFER_NUMBER-fifo_used_cnt==0 ) { // Fatal error: even with the synchro mechanism acting, we are in a case in which the // buffers are full. usb_stream_context->synchronized = false; usb_stream_context->status = USB_STREAM_ERROR_NOT_SYNCHRONIZED; return usb_stream_context->status; } pswap.s8ptr = buffer.s8ptr = usb_stream_fifo_get_buffer(usb_stream_context->wr_id); #if USB_HOST_FEATURE == true if( side==USB_STREAM_HOST ) { byte_count=Host_byte_count(pipe_in); } #endif #if USB_DEVICE_FEATURE == true if( side==USB_STREAM_DEVICE ) { byte_count=Usb_byte_count(pipe_in); } #endif if( byte_count==0 ) { if( cpu_is_timeout(&broken_stream_timer) ) { usb_stream_context->status = USB_STREAM_ERROR_BROKEN_STREAM; } else { usb_stream_context->status = USB_STREAM_ERROR_NO_DATA; } return usb_stream_context->status; } else { // reset time out detection cpu_set_timeout(cpu_ms_2_cy(BROKEN_STREAM_TIMER, FCPU_HZ), &broken_stream_timer); } #if USB_HOST_FEATURE == true if( side==USB_STREAM_HOST ) { Host_reset_pipe_fifo_access(pipe_in); host_read_p_rxpacket(pipe_in, (void*)buffer.s8ptr, byte_count, NULL); } #endif #if USB_DEVICE_FEATURE == true if( side==USB_STREAM_DEVICE ) { Usb_reset_endpoint_fifo_access(pipe_in); usb_read_ep_rxpacket(pipe_in, (void*)buffer.s8ptr, byte_count, NULL); } #endif usb_stream_context->status = USB_STREAM_ERROR_NONE; if( byte_count > USB_STREAM_REAL_BUFFER_SIZE ) { byte_count = USB_STREAM_REAL_BUFFER_SIZE; usb_stream_context->status = USB_STREAM_ERROR_OVERFLOW; } // Swap samples since they are coming from the USB world. if( usb_stream_context->bits_per_sample==16 ) for( i=0 ; i<byte_count/(16/8) ; i++ ) pswap.s16ptr[i] = swap16(pswap.s16ptr[i]); else if( usb_stream_context->bits_per_sample==32 ) for( i=0 ; i<byte_count/(32/8) ; i++ ) pswap.s32ptr[i] = swap32(pswap.s32ptr[i]); //for( i=0 ; i<byte_count/2 ; i++ ) // printf("0x%04hx ", pswap[i]); //printf("\r\n"); usb_stream_fifo_push(byte_count); fifo_used_cnt++; if( !usb_stream_context->synchronized ) { usb_stream_context->status = USB_STREAM_ERROR_NOT_SYNCHRONIZED; if( fifo_used_cnt>=(USB_STREAM_BUFFER_NUMBER/2) ) { // We have enough buffers to start the playback. void* buffer; uint16_t size; // CS2200 cs2200_freq_clk_out(_32_BITS_RATIO(usb_stream_resync_frequency, CS2200_FREF)); usb_stream_resync_step = PPM(usb_stream_resync_frequency, USB_STREAM_RESYNC_PPM_STEPS); usb_stream_resync_freq_ofst = usb_stream_resync_frequency; usb_stream_resync_ppm_ofst = 0; usb_stream_resync_last_room = fifo_used_cnt; #define TIMER_USB_RESYNC_CORRECTION 320 cpu_set_timeout( cpu_ms_2_cy(TIMER_USB_RESYNC_CORRECTION, FCPU_HZ), &usb_resync_timer ); usb_stream_context->synchronized=true; usb_stream_fifo_get(&buffer, &size); audio_mixer_dacs_output_direct(buffer, size/(usb_stream_context->channel_count*usb_stream_context->bits_per_sample/8)); // Fill also the reload stage of the PDCA. usb_stream_fifo_pull(); usb_stream_fifo_get(&buffer, &size); audio_mixer_dacs_output_direct(buffer, size/(usb_stream_context->channel_count*usb_stream_context->bits_per_sample/8)); } } return usb_stream_context->status; }
void usb_host_task(void) #endif { #define DEVICE_DEFAULT_MAX_ERROR_COUNT 2 static uint8_t device_default_error_count; #ifdef HOST_VBUS_LOW_TIMEOUT extern t_cpu_time timer_vbus_low; #endif static bool sav_int_sof_enable; uint8_t pipe; #ifdef FREERTOS_USED portTickType xLastWakeTime; xLastWakeTime = xTaskGetTickCount(); while (true) { vTaskDelayUntil(&xLastWakeTime, configTSK_USB_HST_PERIOD); #endif // FREERTOS_USED switch (device_state) { #ifdef HOST_VBUS_LOW_TIMEOUT case DEVICE_VBUS_LOW: Usb_disable_vbus(); if (cpu_is_timeout(&timer_vbus_low)) usb_host_task_init(); break; #endif //------------------------------------------------------ // DEVICE_UNATTACHED state // // - Default init state // - Try to give device power supply // case DEVICE_UNATTACHED: device_default_error_count = 0; nb_interface_supported = 0; Host_clear_device_status(); // Reset device status Usb_clear_all_event(); // Clear all software events Host_disable_sof(); host_disable_all_pipes(); Usb_enable_vbus(); // Give at least device power supply! // If VBus OK, wait for device connection if (Is_usb_vbus_high()) device_state = DEVICE_ATTACHED; break; //------------------------------------------------------ // DEVICE_ATTACHED state // // - VBus is on // - Try to detect device connection // case DEVICE_ATTACHED: if (Is_host_device_connection() || Is_usb_event(EVT_HOST_CONNECTION) ) // Device pull-up detected { device_attached_retry: if( Is_usb_event(EVT_HOST_CONNECTION) ) { Usb_ack_event(EVT_HOST_CONNECTION); } Usb_ack_bconnection_error_interrupt(); Usb_ack_vbus_error_interrupt(); Host_ack_device_connection(); Host_clear_device_status(); // Reset device status cpu_irq_disable(); Host_disable_device_disconnection_interrupt(); Host_send_reset(); // First USB reset (void)Is_host_sending_reset(); cpu_irq_enable(); Usb_ack_event(EVT_HOST_SOF); // Active wait for end of reset send while (Is_host_sending_reset()) { // The USB macro does not signal the end of reset when a disconnection occurs if (Is_host_device_disconnection()) { // Stop sending USB reset Host_stop_sending_reset(); } } Host_ack_reset_sent(); Host_enable_sof(); // Start SOF generation Host_enable_sof_interrupt(); // SOF will be detected under interrupt if (!Is_host_device_disconnection()) { // Workaround for some buggy devices with powerless pull-up // usually low-speed where data line rises slowly and can be interpreted as disconnection for (sof_cnt = 0; sof_cnt < 0xFFFF; sof_cnt++) // Basic time-out counter { // If we detect SOF, device is still alive and connected, just clear false disconnect flag if (Is_usb_event(EVT_HOST_SOF) && Is_host_device_disconnection()) { Host_ack_device_connection(); Host_ack_device_disconnection(); break; } } } Host_enable_device_disconnection_interrupt(); sof_cnt = 0; while (sof_cnt < 100) // Wait 100 ms after USB reset { if (Is_usb_event(EVT_HOST_SOF)) Usb_ack_event(EVT_HOST_SOF), sof_cnt++; // Count SOFs if (Is_host_emergency_exit() || Is_usb_bconnection_error_interrupt()) goto device_attached_error; } device_state = DEVICE_POWERED; LOG_STR(log_device_connected); Host_device_connection_action(); sof_cnt = 0; } device_attached_error: // Device connection error, or VBus pb -> Retry the connection process from the beginning if (Is_usb_bconnection_error_interrupt() || Is_usb_vbus_error_interrupt() || Is_usb_vbus_low()) { if (device_state != DEVICE_VBUS_LOW) device_state = DEVICE_UNATTACHED; Usb_ack_bconnection_error_interrupt(); Usb_ack_vbus_error_interrupt(); Host_disable_sof(); } break; //------------------------------------------------------ // DEVICE_POWERED state // // - Device connection (attach) has been detected, // - Wait 100 ms and configure default control pipe // case DEVICE_POWERED: if (Is_usb_event(EVT_HOST_SOF)) { Usb_ack_event(EVT_HOST_SOF); if (sof_cnt++ >= 100) // Wait 100 ms { Host_enable_pipe(P_CONTROL); (void)Host_configure_pipe(P_CONTROL, 0, EP_CONTROL, TYPE_CONTROL, TOKEN_SETUP, 8, SINGLE_BANK); device_state = DEVICE_DEFAULT; } } break; //------------------------------------------------------ // DEVICE_DEFAULT state // // - Get device descriptor // - Reconfigure control pipe according to device control endpoint // - Assign device address // case DEVICE_DEFAULT: // Get first device descriptor if (host_get_device_descriptor_incomplete() == CONTROL_GOOD) { sof_cnt = 0; while (sof_cnt < 20) // Wait 20 ms before USB reset (special buggy devices...) { if (Is_usb_event(EVT_HOST_SOF)) Usb_ack_event(EVT_HOST_SOF), sof_cnt++; if (Is_host_emergency_exit() || Is_usb_bconnection_error_interrupt()) break; } cpu_irq_disable(); Host_disable_device_disconnection_interrupt(); Host_send_reset(); // First USB reset (void)Is_host_sending_reset(); cpu_irq_enable(); Usb_ack_event(EVT_HOST_SOF); // Active wait for end of reset send while (Is_host_sending_reset()) { // The USB macro does not signal the end of reset when a disconnection occurs if (Is_host_device_disconnection()) { // Stop sending USB reset Host_stop_sending_reset(); } } Host_ack_reset_sent(); if (!Is_host_device_disconnection()) { // Workaround for some buggy devices with powerless pull-up // usually low-speed where data line rises slowly and can be interpreted as disconnection for (sof_cnt = 0; sof_cnt < 0xFFFF; sof_cnt++) // Basic time-out counter { // If we detect SOF, device is still alive and connected, just clear false disconnect flag if (Is_usb_event(EVT_HOST_SOF) && Is_host_device_disconnection()) { Host_ack_device_connection(); Host_ack_device_disconnection(); break; } } } Host_enable_device_disconnection_interrupt(); sof_cnt = 0; while (sof_cnt < 200) // Wait 200 ms after USB reset { if (Is_usb_event(EVT_HOST_SOF)) Usb_ack_event(EVT_HOST_SOF), sof_cnt++; if (Is_host_emergency_exit() || Is_usb_bconnection_error_interrupt()) break; } Host_disable_pipe(P_CONTROL); Host_unallocate_memory(P_CONTROL); Host_enable_pipe(P_CONTROL); // Reconfigure the control pipe according to the device control endpoint (void)Host_configure_pipe(P_CONTROL, 0, EP_CONTROL, TYPE_CONTROL, TOKEN_SETUP, data_stage[OFFSET_FIELD_MAXPACKETSIZE], SINGLE_BANK); // Give an absolute device address if (host_set_address(DEVICE_ADDRESS) == CONTROL_GOOD) { for (pipe = 0; pipe < MAX_PEP_NB; pipe++) Host_configure_address(pipe, DEVICE_ADDRESS); device_state = DEVICE_ADDRESSED; } else if (device_state != DEVICE_VBUS_LOW) device_state = DEVICE_ERROR; } else { if (device_state != DEVICE_VBUS_LOW) { if (++device_default_error_count > DEVICE_DEFAULT_MAX_ERROR_COUNT) device_state = DEVICE_ERROR; else { Host_disable_sof(); Host_disable_pipe(P_CONTROL); Host_unallocate_memory(P_CONTROL); device_state = DEVICE_ATTACHED; goto device_attached_retry; } } Usb_ack_bconnection_error_interrupt(); Usb_ack_vbus_error_interrupt(); Host_disable_sof(); } break; //------------------------------------------------------ // DEVICE_ADDRESSED state // // - Check if VID PID is in supported list // case DEVICE_ADDRESSED: if (host_get_device_descriptor() == CONTROL_GOOD) { // Detect if the device connected belongs to the supported devices table if (host_check_VID_PID()) { Host_set_device_supported(); Host_device_supported_action(); device_state = DEVICE_CONFIGURED; } else { #if HOST_STRICT_VID_PID_TABLE == ENABLE device_state = DEVICE_ERROR; LOG_STR(log_unsupported_device); #else device_state = DEVICE_CONFIGURED; #endif Host_device_not_supported_action(); } } else if (device_state != DEVICE_VBUS_LOW) device_state = DEVICE_ERROR; // Can not get device descriptor break; //------------------------------------------------------ // DEVICE_CONFIGURED state // // - Configure pipes for the supported interface // - Send Set_configuration() request // - Go to full operating mode (device ready) // case DEVICE_CONFIGURED: { uint8_t configuration_index = 0; if (host_get_configuration_descriptor(configuration_index) == CONTROL_GOOD) { if (host_check_class()) // Class support OK? { #if HOST_AUTO_CFG_ENDPOINT == DISABLE User_configure_endpoint(); // User call here instead of autoconfig Host_set_configured(); // Assumes config is OK with user config #endif if (Is_host_configured()) { if (host_set_configuration(data_stage[OFFSET_FIELD_CONFIGURATION_NB]) == CONTROL_GOOD) // Send Set_configuration { // Device and host are now fully configured // go to DEVICE_READY normal operation device_state = DEVICE_READY; // Monitor device disconnection under interrupt Host_enable_device_disconnection_interrupt(); // If user host application requires SOF interrupt event // Keep SOF interrupt enabled, otherwise disable this interrupt #if HOST_CONTINUOUS_SOF_INTERRUPT == DISABLE cpu_irq_disable(); Host_disable_sof_interrupt(); (void)Is_host_sof_interrupt_enabled(); cpu_irq_enable(); #endif Host_new_device_connection_action(); cpu_irq_enable(); LOG_STR(log_device_enumerated); } else if (device_state != DEVICE_VBUS_LOW) device_state = DEVICE_ERROR; // Problem during Set_configuration request... } } else // Device class not supported... { device_state = DEVICE_UNSUPPORTED; LOG_STR(log_unsupported_device); Host_device_class_not_supported_action(); } } else if (device_state != DEVICE_VBUS_LOW) device_state = DEVICE_ERROR; // Can not get configuration descriptors... } break; //------------------------------------------------------ // DEVICE_READY state // // - Full standard operating mode // - Nothing to do... // case DEVICE_READY: // Host full standard operating mode! break; //------------------------------------------------------ // DEVICE_UNSUPPORTED state // case DEVICE_UNSUPPORTED: break; //------------------------------------------------------ // DEVICE_ERROR state // // - Error state // - Do custom action call (probably go to default mode...) // case DEVICE_ERROR: //! @todo #if HOST_ERROR_RESTART == ENABLE device_state = DEVICE_UNATTACHED; #endif Host_device_error_action(); break; //------------------------------------------------------ // DEVICE_SUSPENDED state // // - Host application request to suspend the device activity // - State machine comes here thanks to Host_request_suspend() // case DEVICE_SUSPENDED: if (Is_device_supports_remote_wakeup()) // If the connected device supports remote wake-up { host_set_feature_remote_wakeup(); // Enable this feature... } LOG_STR(log_usb_suspended); sav_int_sof_enable = Is_host_sof_interrupt_enabled(); //Save current SOF interrupt enable state cpu_irq_disable(); Host_disable_sof_interrupt(); (void)Is_host_sof_interrupt_enabled(); cpu_irq_enable(); Host_ack_sof(); Host_disable_sof(); // Stop SOF generation, this generates the suspend state Host_ack_hwup(); Host_enable_hwup_interrupt(); // Enable host wake-up interrupt // (this is the unique USB interrupt able to wake up the CPU core from power-down mode) (void)Is_host_hwup_interrupt_enabled(); // Make sure host wake-up interrupt is enabled Usb_freeze_clock(); //! @todo Implement this on the silicon version //Stop_pll(); Host_suspend_action(); // Custom action here! (e.g. go to power-save mode...) device_state = DEVICE_WAIT_RESUME; // Wait for device resume event break; //------------------------------------------------------ // DEVICE_WAIT_RESUME state // // Wait in this state till: // - the host receives an upstream resume from the device // - or the host software request the device to resume // case DEVICE_WAIT_RESUME: if (Is_usb_event(EVT_HOST_HWUP) || Is_host_request_resume()) // Remote wake-up has been detected // or local resume request has been received { if (Is_host_request_resume()) // Not a remote wake-up, but a host application request { // CAUTION: HWUP can be cleared only when USB clock is active //! @todo Implement this on the silicon version //Pll_start_auto(); // First Restart the PLL for USB operation //Wait_pll_ready(); // Make sure PLL is locked Usb_unfreeze_clock(); // Enable clock on USB interface (void)Is_usb_clock_frozen(); // Make sure USB interface clock is enabled cpu_irq_disable(); Host_disable_hwup_interrupt(); // Wake-up interrupt should be disabled as host is now awoken! (void)Is_host_hwup_interrupt_enabled(); cpu_irq_enable(); Host_ack_hwup(); // Clear HWUP interrupt flag } Host_enable_sof(); Host_send_resume(); // Send downstream resume while (!Is_host_down_stream_resume()); // Wait for downstream resume sent Host_ack_remote_wakeup(); // Ack remote wake-up reception Host_ack_request_resume(); // Ack software request Host_ack_down_stream_resume(); // Ack downstream resume sent Usb_ack_event(EVT_HOST_HWUP); // Ack software event if (sav_int_sof_enable) Host_enable_sof_interrupt(); // Restore SOF interrupt enable state before suspend device_state = DEVICE_READY; // Come back to full operating mode LOG_STR(log_usb_resumed); } break; //------------------------------------------------------ // default state // // - Default case: ERROR // - Go to DEVICE_UNATTACHED state // default: device_state = DEVICE_UNATTACHED; break; } #ifdef FREERTOS_USED } #endif }
static void update_controller_state(void) { // Long pressing for BACK key handler if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_0] == TOUCH_RELEASE) controller_state &= ~STATE_BACK_PRESSING; if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_0] == TOUCH_PRESS) { if (!(controller_state & STATE_BACK_PRESSING)) { controller_state |= STATE_BACK_PRESSING; cpu_set_timeout(cpu_ms_2_cy(CONTROLLER_LONG_PRESS_TIME_MS, controller_cpu_hz), &long_press_timer); } if (cpu_is_timeout(&long_press_timer)) controller_state |= STATE_BACK_LONG_PRESS; } // Back key if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_0] == TOUCH_PRESS) SET_PRESSED_STATE(BACK); else if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_0] == TOUCH_RELEASE) SET_RELEASED_STATE(BACK); // Function 1 key if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_1] == TOUCH_PRESS) SET_PRESSED_STATE(FCT1); else if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_1] == TOUCH_RELEASE) SET_RELEASED_STATE(FCT1); // Function 2 key if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_2] == TOUCH_PRESS) SET_PRESSED_STATE(FCT2); else if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_2] == TOUCH_RELEASE) SET_RELEASED_STATE(FCT2); // Function 3 key if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_3] == TOUCH_PRESS) SET_PRESSED_STATE(FCT3); else if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_3] == TOUCH_RELEASE) SET_RELEASED_STATE(FCT3); // Wheel right if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_0] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_1] == TOUCH_PRESS) set_wheel_right(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_1] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_2] == TOUCH_PRESS) set_wheel_right(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_2] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_3] == TOUCH_PRESS) set_wheel_right(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_3] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_4] == TOUCH_PRESS) set_wheel_right(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_4] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_5] == TOUCH_PRESS) set_wheel_right(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_5] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_6] == TOUCH_PRESS) set_wheel_right(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_6] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_7] == TOUCH_PRESS) set_wheel_right(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_7] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_8] == TOUCH_PRESS) set_wheel_right(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_8] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_9] == TOUCH_PRESS) set_wheel_right(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_9] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_10] == TOUCH_PRESS) set_wheel_right(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_10] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_11] == TOUCH_PRESS) set_wheel_right(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_11] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_0] == TOUCH_PRESS) set_wheel_right(); // Wheel left if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_11] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_0] == TOUCH_RELEASE) set_wheel_left(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_10] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_11] == TOUCH_RELEASE) set_wheel_left(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_9] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_10] == TOUCH_RELEASE) set_wheel_left(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_8] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_9] == TOUCH_RELEASE) set_wheel_left(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_7] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_8] == TOUCH_RELEASE) set_wheel_left(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_6] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_7] == TOUCH_RELEASE) set_wheel_left(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_5] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_6] == TOUCH_RELEASE) set_wheel_left(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_4] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_5] == TOUCH_RELEASE) set_wheel_left(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_3] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_4] == TOUCH_RELEASE) set_wheel_left(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_2] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_3] == TOUCH_RELEASE) set_wheel_left(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_1] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_2] == TOUCH_RELEASE) set_wheel_left(); if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_0] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_1] == TOUCH_RELEASE) set_wheel_left(); }
static void update_controller_state(void) { // Back key if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_0] == TOUCH_PRESS) SET_PRESSED_STATE(CS1); else if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_0] == TOUCH_RELEASE) SET_RELEASED_STATE(CS1); // Function 1 key if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_1] == TOUCH_PRESS) SET_PRESSED_STATE(CS2); else if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_1] == TOUCH_RELEASE) SET_RELEASED_STATE(CS2); // Function 2 key if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_2] == TOUCH_PRESS) SET_PRESSED_STATE(CS3); else if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_2] == TOUCH_RELEASE) SET_RELEASED_STATE(CS3); // Function 3 key if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_3] == TOUCH_PRESS) SET_PRESSED_STATE(CS4); else if (touch_states[QT60168_TOUCH_SENSOR_BUTTON_3] == TOUCH_RELEASE) SET_RELEASED_STATE(CS4); // Wheel right if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_0] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_1] == TOUCH_PRESS) set_wheel_right(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_1] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_2] == TOUCH_PRESS) set_wheel_right(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_2] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_3] == TOUCH_PRESS) set_wheel_right(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_3] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_4] == TOUCH_PRESS) set_wheel_right(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_4] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_5] == TOUCH_PRESS) set_wheel_right(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_5] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_6] == TOUCH_PRESS) set_wheel_right(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_6] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_7] == TOUCH_PRESS) set_wheel_right(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_7] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_8] == TOUCH_PRESS) set_wheel_right(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_8] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_9] == TOUCH_PRESS) set_wheel_right(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_9] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_10] == TOUCH_PRESS) set_wheel_right(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_10] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_11] == TOUCH_PRESS) set_wheel_right(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_11] == TOUCH_RELEASE && touch_states[QT60168_TOUCH_SENSOR_WHEEL_0] == TOUCH_PRESS) set_wheel_right(); // Wheel left else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_11] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_0] == TOUCH_RELEASE) set_wheel_left(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_10] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_11] == TOUCH_RELEASE) set_wheel_left(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_9] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_10] == TOUCH_RELEASE) set_wheel_left(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_8] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_9] == TOUCH_RELEASE) set_wheel_left(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_7] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_8] == TOUCH_RELEASE) set_wheel_left(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_6] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_7] == TOUCH_RELEASE) set_wheel_left(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_5] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_6] == TOUCH_RELEASE) set_wheel_left(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_4] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_5] == TOUCH_RELEASE) set_wheel_left(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_3] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_4] == TOUCH_RELEASE) set_wheel_left(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_2] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_3] == TOUCH_RELEASE) set_wheel_left(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_1] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_2] == TOUCH_RELEASE) set_wheel_left(); else if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_0] == TOUCH_PRESS && touch_states[QT60168_TOUCH_SENSOR_WHEEL_1] == TOUCH_RELEASE) set_wheel_left(); else if (!(controller_state & STATE_WHEEL_LEFT) && !(controller_state & STATE_WHEEL_RIGHT)) { // Can be holding a key if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_9] == TOUCH_RELEASE) controller_state |= STATE_WHEEL_LEFT_RELEASED; if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_6] == TOUCH_RELEASE) controller_state |= STATE_WHEEL_DOWN_RELEASED; if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_3] == TOUCH_RELEASE) controller_state |= STATE_WHEEL_RIGHT_RELEASED; if (touch_states[QT60168_TOUCH_SENSOR_WHEEL_0] == TOUCH_RELEASE) controller_state |= STATE_WHEEL_UP_RELEASED; } // Clear the wheel state after 500 ms if ((controller_state & STATE_WHEEL_LEFT || controller_state & STATE_WHEEL_RIGHT) && wheel_step_counter) cpu_set_timeout(cpu_ms_2_cy(500, FCPU_HZ), &cpu_time_clear_wheel); // Clear the wheel state after 500 ms if ((controller_state & STATE_WHEEL_LEFT || controller_state & STATE_WHEEL_RIGHT) && !wheel_step_counter && cpu_is_timeout(&cpu_time_clear_wheel)) { controller_state &= ~STATE_WHEEL_LEFT; controller_state &= ~STATE_WHEEL_RIGHT; } }
//! //! @brief Entry point of the MMI task management //! void mmi_task(void) { uint32_t i; switch( mmi_state ) { case MMI_TOP_MENU_START: // Draw the background AVR32 logo. et024006_PutPixmap(avr32_logo, 320, 0, 0, 0, 0, 320, 240); // Display welcome string. et024006_PrintString("EVK1104 Demo", (const unsigned char *)&FONT8x8, 110, 220, BLACK, -1); mmi_state = MMI_TOP_MENU; break; case MMI_TOP_MENU: if( Is_usb_vbus_high() ) { mmi_state = MMI_MASS_STORAGE_START; } break; case MMI_MASS_STORAGE_START: // Draw the background AVR32 logo. et024006_PutPixmap(avr32_logo, 320, 0, 0, 0, 0, 320, 240); // Display USB key logo. et024006_DrawFilledRect(220-1, 20-1, 80+2, 42+2, BLACK ); et024006_PutPixmap(ms_key_logo, 80, 0, 0, 220, 20, 80, 42); // Display title. et024006_PrintString("U-Disk", (const unsigned char *)&FONT6x8, 240, 65, BLACK, -1); // Display Activity window. display_box(80, 180, 156, 16, WHITE, BLACK); // Display performances box. display_perf(120, 201, true, 0, 0); ms_old_cnt_read = ms_cnt_read =0; ms_old_cnt_write = ms_cnt_write =0; mmi_state = MMI_MASS_STORAGE; ms_cnt_screen = 0; for( i=0 ; i<MS_N_PROGRESS_BAR ; i++ ) { ms_progress_bar_level[i] = 1; ms_progress_bar_type[i] = BLACK; } mmi_ms_display(); cpu_set_timeout( cpu_ms_2_cy(TIMER_MS_PROGRESS_BAR_UPDATE, pm_freq_param.cpu_f), &ms_activity_timer); cpu_set_timeout( cpu_ms_2_cy(TIMER_MS_PROGRESS_BAR_CLEAR, pm_freq_param.cpu_f), &ms_clear_timer); break; case MMI_MASS_STORAGE: // Manage progress-bar shading. // if( cpu_is_timeout(&ms_clear_timer) ) { cpu_set_timeout( cpu_ms_2_cy(TIMER_MS_PROGRESS_BAR_CLEAR, pm_freq_param.cpu_f), &ms_clear_timer); mmi_ms_display(); } // Manage progress-bar box moving. // if( cpu_is_timeout(&ms_activity_timer) ) { cpu_set_timeout( cpu_ms_2_cy(TIMER_MS_PROGRESS_BAR_UPDATE, pm_freq_param.cpu_f), &ms_activity_timer); if( ms_old_cnt_write != ms_cnt_write ) { ms_cnt_screen = (unsigned char)(ms_cnt_screen-1)%MS_N_PROGRESS_BAR; ms_progress_bar_type[ms_cnt_screen] = RED; // Compute performances // perf_write = (U64)(ms_cnt_write - ms_old_cnt_write)*SD_MMC_SECTOR_SIZE/TIMER_MS_PROGRESS_BAR_UPDATE; display_perf(120, 201, false, perf_write, RED); ms_old_cnt_write = ms_cnt_write; ms_progress_bar_level[ms_cnt_screen] = (perf_write>10000) ? 31 : (perf_write> 7500) ? 29 : (perf_write> 5000) ? 27 : 25 ; } else if( ms_old_cnt_read != ms_cnt_read ) { ms_cnt_screen = (unsigned char)(ms_cnt_screen+1)%MS_N_PROGRESS_BAR; ms_progress_bar_type[ms_cnt_screen] = BLUE; // Compute performances // perf_read = (U64)(ms_cnt_read - ms_old_cnt_read)*SD_MMC_SECTOR_SIZE/TIMER_MS_PROGRESS_BAR_UPDATE; display_perf(120, 201, false, perf_read, BLUE); ms_old_cnt_read = ms_cnt_read; ms_progress_bar_level[ms_cnt_screen] = (perf_read>10000) ? 31 : (perf_read> 7500) ? 29 : (perf_read> 5000) ? 27 : 25 ; } else { display_perf(120, 201, true, 0, 0); } } // Detect USB unplug. // if( Is_usb_vbus_low() ) { mmi_state = MMI_TOP_MENU_START; } 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); } */ }
static void playback_task(struct state_machine_context *state_m) { static enum { PLAYER_STATUS_NOT_DEFINED, PLAYER_STATUS_PLAY, PLAYER_STATUS_PAUSE, PLAYER_STATUS_STOP, PLAYER_STATUS_FFW, PLAYER_STATUS_FRW } current_view_player_status; static bool fast_mode = false; // By default, the command executed is asynchronous. state_m->async_cmd = true; state_m->view = GUI_UPDATE_VIEW_PLAYBACK; switch (state_m->state) { // This state id the entry point of the navigation view. // It must be call on every access to this view. case STATE_PLAYBACK_ENTRY_POINT: state_m->view_elt = GUI_UPDATE_ELT_NONE; state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_ELAPSED_TIME; state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_VOLUME; state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_ARTIST; state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_TITLE; state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_FILE_NAME; state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_TOTAL_TIME; state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_COVER_ART; state_m->cmd_status = true; state_m->async_cmd = false; state_m->info.volume = audio_mixer_dacs_get_volume(); current_view_player_status = PLAYER_STATUS_NOT_DEFINED; cpu_set_timeout(cpu_ms_2_cy(ELAPSED_TIME_TIMER_VALUE_MS, FCPU_HZ), &state_m->elapsed_time_timer); state_m->state = STATE_PLAYBACK_WAIT_FOR_EVENT; break; // This state is the "idle" state of this view. case STATE_PLAYBACK_WAIT_FOR_EVENT: // Catch new track event if (state_m->player_status.flags.new_file_played) { // Notify the controller a new track is being played controller_playback_ffw(true); controller_playback_frw(true); state_m->async_cmd = false; state_m->player_status.flags.new_file_played = 0; state_m->recorded_state = STATE_PLAYBACK_ENTRY_POINT; state_m->state = STATE_TRACK_CHANGED_ENTRY_POINT; break; } // Switch to navigation view else if (controller_switch_to_navigation_view(GUI_UPDATE_VIEW_PLAYBACK)) { controller_clear(); state_m->async_cmd = false; state_m->state = STATE_NAVIGATION_ENTRY_POINT; break; } // Switch to configuration view else if (controller_switch_to_config_view(GUI_UPDATE_VIEW_PLAYBACK)) { controller_clear(); state_m->async_cmd = false; state_m->state = STATE_CONFIG_ENTRY_POINT; break; } // Increase volume else if (controller_playback_increase_volume()) { state_m->async_cmd = false; audio_mixer_dacs_increase_volume(); audio_mixer_dacs_increase_volume(); state_m->info.volume = audio_mixer_dacs_get_volume(); state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_VOLUME; break; } // Decrease volume else if (controller_playback_decrease_volume()) { state_m->async_cmd = false; audio_mixer_dacs_decrease_volume(); audio_mixer_dacs_decrease_volume(); state_m->info.volume = audio_mixer_dacs_get_volume(); state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_VOLUME; break; } else if (controller_playback_ffw(false)) { ai_async_audio_ctrl_start_ffw(); state_m->state = STATE_CHECK_DEVICE_ENTRY_POINT; state_m->recorded_state = STATE_PLAYBACK_HANDLE_FAST_MODES; fast_mode = true; break; } else if (controller_playback_frw(false)) { ai_async_audio_ctrl_start_frw(); state_m->state = STATE_CHECK_DEVICE_ENTRY_POINT; state_m->recorded_state = STATE_PLAYBACK_HANDLE_FAST_MODES; fast_mode = true; break; } else if (fast_mode) { ai_async_audio_ctrl_stop_ffw_frw(); state_m->state = STATE_CHECK_DEVICE_ENTRY_POINT; state_m->recorded_state = STATE_PLAYBACK_HANDLE_FAST_MODES; fast_mode = false; break; } // Previous track else if (controller_playback_previous_track()) { ai_async_audio_nav_previous(); break; } // Next track else if (controller_playback_next_track()) { ai_async_audio_nav_next(); break; } // Toggle play/pause else if (controller_playback_toggle_play_pause()) { switch (state_m->player_status.flags.status) { case PLAYER_FLAG_PLAY: ai_async_audio_ctrl_pause(); state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_PAUSE; break; case PLAYER_FLAG_PAUSE: ai_async_audio_ctrl_resume(); state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_PLAY; break; case PLAYER_FLAG_STOP: ai_async_audio_nav_playfile(); state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_PLAY; break; } break; } else if (cpu_is_timeout(&state_m->elapsed_time_timer)) { cpu_set_timeout(cpu_ms_2_cy(ELAPSED_TIME_TIMER_VALUE_MS, FCPU_HZ), &state_m->elapsed_time_timer); ai_async_audio_ctrl_time(); state_m->state = STATE_PLAYBACK_UPDATE_TIME; break; } state_m->async_cmd = false; state_m->state = STATE_CHECK_DEVICE_ENTRY_POINT; state_m->recorded_state = STATE_PLAYBACK_UPDATE_STATUS; break; // This state is called after fats forward or fast rewind commands to handle return states. case STATE_PLAYBACK_HANDLE_FAST_MODES: cpu_set_timeout(cpu_ms_2_cy(ELAPSED_TIME_TIMER_VALUE_MS, FCPU_HZ), &state_m->elapsed_time_timer); ai_async_audio_ctrl_time(); state_m->state = STATE_PLAYBACK_UPDATE_TIME; break; // This state update the elapsed time of the current track being played. case STATE_PLAYBACK_UPDATE_TIME: state_m->async_cmd = false; state_m->info.elapsed_time = ai_async_cmd_out_u32(); state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_ELAPSED_TIME; state_m->state = STATE_PLAYBACK_WAIT_FOR_EVENT; break; // This state update the elapsed time of the current track being played. case STATE_PLAYBACK_UPDATE_STATUS: state_m->async_cmd = false; // Update control GUI if (state_m->player_status.flags.status_fast == PLAYER_FLAG_FFW && current_view_player_status != PLAYER_STATUS_FFW) state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_FFW; else if (state_m->player_status.flags.status_fast == PLAYER_FLAG_FRW && current_view_player_status != PLAYER_STATUS_FRW) state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_FRW; else if (state_m->player_status.flags.status == PLAYER_FLAG_PLAY && current_view_player_status != PLAYER_STATUS_PLAY) state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_PLAY; else if (state_m->player_status.flags.status == PLAYER_FLAG_PAUSE && current_view_player_status != PLAYER_STATUS_PAUSE) state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_PAUSE; else if (state_m->player_status.flags.status == PLAYER_FLAG_STOP && current_view_player_status != PLAYER_STATUS_STOP) state_m->view_elt |= GUI_UPDATE_ELT_PLAYBACK_STOP; state_m->state = STATE_PLAYBACK_WAIT_FOR_EVENT; break; default: return; } // Error management if (state_m->cmd_status == false) state_m->state = STATE_PLAYBACK_WAIT_FOR_EVENT; }
int main( void ) { int keysize; unsigned long i, j, tsc; unsigned char tmp[64]; t_cpu_time timer; /* Keep compiler happy */ UNUSED(keysize); UNUSED(i); UNUSED(j); UNUSED(tsc); UNUSED(tmp[0]); UNUSED(timer); // USART options. static usart_serial_options_t USART_SERIAL_OPTIONS = { .baudrate = USART_SERIAL_EXAMPLE_BAUDRATE, .charlength = USART_SERIAL_CHAR_LENGTH, .paritytype = USART_SERIAL_PARITY, .stopbits = USART_SERIAL_STOP_BIT }; sysclk_init(); // Initialize the board. // The board-specific conf_board.h file contains the configuration of the board // initialization. board_init(); // Initialize Serial Interface using Stdio Library stdio_serial_init(USART_SERIAL_EXAMPLE,&USART_SERIAL_OPTIONS); printf( "Start Benchmark\n"); #if defined(POLARSSL_ARC4_C) arc4_context arc4; #endif #if defined(POLARSSL_DES_C) des3_context des3; des_context des; #endif #if defined(POLARSSL_AES_C) aes_context aes; #endif #if defined(POLARSSL_CAMELLIA_C) camellia_context camellia; #endif #if defined(POLARSSL_RSA_C) rsa_context rsa; #endif memset( buf, 0xAA, sizeof( buf ) ); printf( "\n" ); #if defined(POLARSSL_MD4_C) printf( " MD4 : " ); fflush( stdout ); cpu_set_timeout(cpu_ms_2_cy(1000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) md4( buf, BUFSIZE, tmp ); tsc = hardclock(); for( j = 0; j < 1024; j++ ) md4( buf, BUFSIZE, tmp ); printf( "%9lu Kb/s, %9lu cycles/byte\n", i * BUFSIZE / 1024, ( hardclock() - tsc ) / ( j * BUFSIZE ) ); #endif #if defined(POLARSSL_MD5_C) printf( " MD5 : " ); fflush( stdout ); cpu_set_timeout(cpu_ms_2_cy(1000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) md5( buf, BUFSIZE, tmp ); tsc = hardclock(); for( j = 0; j < 1024; j++ ) md5( buf, BUFSIZE, tmp ); printf( "%9lu Kb/s, %9lu cycles/byte\n", i * BUFSIZE / 1024, ( hardclock() - tsc ) / ( j * BUFSIZE ) ); #endif #if defined(POLARSSL_SHA1_C) printf( " SHA-1 : " ); fflush( stdout ); cpu_set_timeout(cpu_ms_2_cy(1000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) sha1( buf, BUFSIZE, tmp ); tsc = hardclock(); for( j = 0; j < 1024; j++ ) sha1( buf, BUFSIZE, tmp ); printf( "%9lu Kb/s, %9lu cycles/byte\n", i * BUFSIZE / 1024, ( hardclock() - tsc ) / ( j * BUFSIZE ) ); #endif #if defined(POLARSSL_SHA2_C) printf( " SHA-256 : " ); fflush( stdout ); cpu_set_timeout(cpu_ms_2_cy(1000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) sha2( buf, BUFSIZE, tmp, 0 ); tsc = hardclock(); for( j = 0; j < 1024; j++ ) sha2( buf, BUFSIZE, tmp, 0 ); printf( "%9lu Kb/s, %9lu cycles/byte\n", i * BUFSIZE / 1024, ( hardclock() - tsc ) / ( j * BUFSIZE ) ); #endif #if defined(POLARSSL_SHA4_C) printf( " SHA-512 : " ); fflush( stdout ); cpu_set_timeout(cpu_ms_2_cy(1000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) sha4( buf, BUFSIZE, tmp, 0 ); tsc = hardclock(); for( j = 0; j < 1024; j++ ) sha4( buf, BUFSIZE, tmp, 0 ); printf( "%9lu Kb/s, %9lu cycles/byte\n", i * BUFSIZE / 1024, ( hardclock() - tsc ) / ( j * BUFSIZE ) ); #endif #if defined(POLARSSL_ARC4_C) printf( " ARC4 : " ); fflush( stdout ); arc4_setup( &arc4, tmp, 32 ); cpu_set_timeout(cpu_ms_2_cy(1000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) arc4_crypt( &arc4, BUFSIZE, buf, buf ); tsc = hardclock(); for( j = 0; j < 1024; j++ ) arc4_crypt( &arc4, BUFSIZE, buf, buf ); printf( "%9lu Kb/s, %9lu cycles/byte\n", i * BUFSIZE / 1024, ( hardclock() - tsc ) / ( j * BUFSIZE ) ); #endif #if defined(POLARSSL_DES_C) printf( " 3DES : " ); fflush( stdout ); des3_set3key_enc( &des3, tmp ); cpu_set_timeout(cpu_ms_2_cy(1000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) des3_crypt_cbc( &des3, DES_ENCRYPT, BUFSIZE, tmp, buf, buf ); tsc = hardclock(); for( j = 0; j < 1024; j++ ) des3_crypt_cbc( &des3, DES_ENCRYPT, BUFSIZE, tmp, buf, buf ); printf( "%9lu Kb/s, %9lu cycles/byte\n", i * BUFSIZE / 1024, ( hardclock() - tsc ) / ( j * BUFSIZE ) ); printf( " DES : " ); fflush( stdout ); des_setkey_enc( &des, tmp ); cpu_set_timeout(cpu_ms_2_cy(1000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) des_crypt_cbc( &des, DES_ENCRYPT, BUFSIZE, tmp, buf, buf ); tsc = hardclock(); for( j = 0; j < 1024; j++ ) des_crypt_cbc( &des, DES_ENCRYPT, BUFSIZE, tmp, buf, buf ); printf( "%9lu Kb/s, %9lu cycles/byte\n", i * BUFSIZE / 1024, ( hardclock() - tsc ) / ( j * BUFSIZE ) ); #endif #if defined(POLARSSL_AES_C) for( keysize = 128; keysize <= 256; keysize += 64 ) { printf( " AES-%d : ", keysize ); fflush( stdout ); memset( buf, 0, sizeof( buf ) ); memset( tmp, 0, sizeof( tmp ) ); aes_setkey_enc( &aes, tmp, keysize ); cpu_set_timeout(cpu_ms_2_cy(1000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) aes_crypt_cbc( &aes, AES_ENCRYPT, BUFSIZE, tmp, buf, buf ); tsc = hardclock(); for( j = 0; j < 4096; j++ ) aes_crypt_cbc( &aes, AES_ENCRYPT, BUFSIZE, tmp, buf, buf ); printf( "%9lu Kb/s, %9lu cycles/byte\n", i * BUFSIZE / 1024, ( hardclock() - tsc ) / ( j * BUFSIZE ) ); } #endif #if defined(POLARSSL_CAMELLIA_C) for( keysize = 128; keysize <= 256; keysize += 64 ) { printf( " CAMELLIA-%d : ", keysize ); fflush( stdout ); memset( buf, 0, sizeof( buf ) ); memset( tmp, 0, sizeof( tmp ) ); camellia_setkey_enc( &camellia, tmp, keysize ); cpu_set_timeout(cpu_ms_2_cy(1000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) camellia_crypt_cbc( &camellia, CAMELLIA_ENCRYPT, BUFSIZE, tmp, buf, buf ); tsc = hardclock(); for( j = 0; j < 4096; j++ ) camellia_crypt_cbc( &camellia, CAMELLIA_ENCRYPT, BUFSIZE, tmp, buf, buf ); printf( "%9lu Kb/s, %9lu cycles/byte\n", i * BUFSIZE / 1024, ( hardclock() - tsc ) / ( j * BUFSIZE ) ); } #endif #if defined(POLARSSL_RSA_C) rsa_init( &rsa, RSA_PKCS_V15, 0 ); rsa_gen_key( &rsa, myrand, NULL, 1024, 65537 ); printf( " RSA-1024 : " ); fflush( stdout ); cpu_set_timeout(cpu_ms_2_cy(3000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) { buf[0] = 0; rsa_public( &rsa, buf, buf ); } printf( "%9lu public/s\n", i / 3 ); printf( " RSA-1024 : " ); fflush( stdout ); cpu_set_timeout(cpu_ms_2_cy(3000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) { buf[0] = 0; rsa_private( &rsa, buf, buf ); } printf( "%9lu private/s\n", i / 3 ); rsa_free( &rsa ); rsa_init( &rsa, RSA_PKCS_V15, 0 ); rsa_gen_key( &rsa, myrand, NULL, 2048, 65537 ); printf( " RSA-2048 : " ); fflush( stdout ); cpu_set_timeout(cpu_ms_2_cy(3000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) { buf[0] = 0; rsa_public( &rsa, buf, buf ); } printf( "%9lu public/s\n", i / 3 ); printf( " RSA-2048 : " ); fflush( stdout ); cpu_set_timeout(cpu_ms_2_cy(3000, CPU_HZ),&timer); for( i = 1; ! cpu_is_timeout(&timer); i++ ) { buf[0] = 0; rsa_private( &rsa, buf, buf ); } printf( "%9lu private/s\n", i / 3 ); rsa_free( &rsa ); rsa_init( &rsa, RSA_PKCS_V15, 0 ); rsa_gen_key( &rsa, myrand, NULL, 4096, 65537 ); printf( " RSA-4096 : " ); fflush( stdout ); cpu_set_timeout(cpu_ms_2_cy(3000, CPU_HZ),&timer); for( i = 1; !cpu_is_timeout(&timer); i++ ) { buf[0] = 0; rsa_public( &rsa, buf, buf ); } printf( "%9lu public/s\n", i / 3 ); printf( " RSA-4096 : " ); fflush( stdout ); cpu_set_timeout(cpu_ms_2_cy(3000, CPU_HZ),&timer); for( i = 1; ! cpu_is_timeout(&timer); i++ ) { buf[0] = 0; rsa_private( &rsa, buf, buf ); } printf( "%9lu private/s\n", i / 3 ); rsa_free( &rsa ); #endif printf( "\n" ); #ifdef WIN32 printf( " Press Enter to exit this program.\n" ); fflush( stdout ); getchar(); #endif return( 0 ); }
// 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); } } }