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