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;
}
//!
//! @brief This function initializes the USB Stream driver.
//!
void usb_stream_init(
uint32_t sample_rate_hz
, uint8_t num_channels
, uint8_t bits_per_sample
, bool swap_channels)
{
uint32_t i;
usb_stream_context->sample_rate = sample_rate_hz;
usb_stream_context->rd_id=
usb_stream_context->wr_id= 0;
usb_stream_context->synchronized= false;
usb_stream_context->bits_per_sample=bits_per_sample;
usb_stream_context->channel_count =num_channels;
usb_stream_resync_frequency=0;
for( i=0 ; i<USB_STREAM_BUFFER_NUMBER ; i++ )
usb_stream_context->audio_buffer_size[i] = 0;
audio_mixer_dacs_setup_direct(sample_rate_hz,
num_channels,
bits_per_sample,
swap_channels);
// Start the broken stream timer
cpu_set_timeout(cpu_ms_2_cy(BROKEN_STREAM_TIMER, FCPU_HZ), &broken_stream_timer);
}
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;
}
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;
}
void controller_init(uint32_t fcpu_hz, uint32_t fhsb_hz, uint32_t fpbb_hz,
uint32_t fpba_hz)
{
// wait until the device settles its CHG line
delay_ms(230);
at42qt1060_init(fcpu_hz);
at42qt1060_register_int(&touch_detect_callback);
//static_fcpu_hz = fcpu_hz;
cpu_set_timeout(cpu_ms_2_cy(JOYSTICK_KEY_DEBOUNCE_MS, static_fcpu_hz),
&joystick_key_sensibility_timer);
}
//!
//! @brief This function initializes the hardware/software resources
//! required for device HID task.
//!
void device_hid_task_init(void)
{
cpu_set_timeout( cpu_ms_2_cy(TIMER_STARTUP, FCPU_HZ), &key_timer );
#if USB_HOST_FEATURE == true
// If both device and host features are enabled, check if device mode is engaged
// (accessing the USB registers of a non-engaged mode, even with load operations,
// may corrupt USB FIFO data).
if (Is_usb_device())
#endif // USB_HOST_FEATURE == true
Usb_enable_sof_interrupt();
}
/** Initialization ************************************************************/
static void qt60168_resources_init(U32 fpba_hz)
{
static const gpio_map_t QT60168_SPI_GPIO_MAP =
{
{QT60168_SPI_SCK_PIN, QT60168_SPI_SCK_FUNCTION }, // SPI Clock.
{QT60168_SPI_MISO_PIN, QT60168_SPI_MISO_FUNCTION }, // MISO.
{QT60168_SPI_MOSI_PIN, QT60168_SPI_MOSI_FUNCTION }, // MOSI.
{QT60168_SPI_NPCS0_PIN, QT60168_SPI_NPCS0_FUNCTION} // Chip Select NPCS.
};
// SPI options.
spi_options_t spiOptions =
{
.reg = QT60168_SPI_NCPS,
.baudrate = 1000000, // Defined in conf_qt60168.h.
.bits = 8, // Defined in conf_qt60168.h.
.spck_delay = 0,
.trans_delay = 0,
.stay_act = 0,
.spi_mode = 3,
.modfdis = 1
};
// Assign I/Os to SPI.
gpio_enable_module(QT60168_SPI_GPIO_MAP,
sizeof(QT60168_SPI_GPIO_MAP) / sizeof(QT60168_SPI_GPIO_MAP[0]));
// Initialize as master.
spi_initMaster(QT60168_SPI, &spiOptions);
// Set selection mode: variable_ps, pcs_decode, delay.
spi_selectionMode(QT60168_SPI, 0, 0, 0);
// Enable SPI.
spi_enable(QT60168_SPI);
// Initialize QT60168 with SPI clock Osc0.
spi_setupChipReg(QT60168_SPI, &spiOptions, 2*FOSC0);
}
void controller_init(U32 fcpu_hz, U32 fhsb_hz, U32 fpbb_hz, U32 fpba_hz) {
qt60168_resources_init(fpba_hz);
// Initialize QT60168 component.
qt60168_init(fpba_hz);
// Init timer to get key value.
rtc_init_qt();
// Invalidate the timeout already
cpu_set_timeout(0, &cpu_time_clear_wheel);
}
//!
//! @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 );
}
}
}
void controller_init(int cpu_hz, int hsb_hz, int pba_hz, int pbb_hz)
{
Disable_global_interrupt();
INTC_register_interrupt(&touch_button_isr, AVR32_GPIO_IRQ_6, 0);//AVR32_INTC_INT0);
// Other buttons on PB[24..26] -> GPIO_IRQ_7 (PB23 - PB31)
INTC_register_interrupt(&touch_button_isr, AVR32_GPIO_IRQ_7, 0);
gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_UP, GPIO_PIN_CHANGE);
gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_DOWN, GPIO_PIN_CHANGE);
gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_RIGHT, GPIO_PIN_CHANGE);
gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_LEFT, GPIO_PIN_CHANGE);
gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_ENTER, GPIO_PIN_CHANGE);
// Enable interrupts globally.
Enable_global_interrupt();
static_fcpu_hz = cpu_hz;
cpu_set_timeout(cpu_ms_2_cy(JOYSTICK_KEY_DEBOUNCE_MS, static_fcpu_hz), &joystick_key_sensibility_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;
}
//!
//! @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 Entry point of the audio management interface.
*
*/
void com_task(void)
{
static struct state_machine_context state_m = {
.state = STATE_INITIALIZATION,
.async_cmd = false,
.view = GUI_UPDATE_VIEW_NONE,
.view_elt = GUI_UPDATE_ELT_NONE,
.elapsed_time_timer.timer_state = CPU_TIMER_STATE_STOPPED
};
// Update the GUI
gui_update(state_m.view, &state_m.view_elt, &state_m.display_list, &state_m.info, &state_m.player_status);
// Ask the audio interface to execute pending tasks
ai_async_cmd_task();
if (state_m.async_cmd)
{
// If current command is not done
if (!is_ai_async_cmd_finished())
{
// If it is a new command that is being proceed
if (state_m.in_progress_timer.timer_state == CPU_TIMER_STATE_STOPPED)
cpu_set_timeout(cpu_ms_2_cy(500, FCPU_HZ), &state_m.in_progress_timer);
// If current command is not done and it is taking a long
else if (cpu_is_timeout(&state_m.in_progress_timer))
state_m.view_elt |= GUI_UPDATE_ELT_IN_PROGRESS;
return;
}
else
{
state_m.cmd_status = ai_async_cmd_out_status();
cpu_stop_timeout(&state_m.in_progress_timer);
}
}
// If a device is connected
if (state_m.state != STATE_INITIALIZATION &&
state_m.state != STATE_IDLE_ENTRY_POINT &&
state_m.state != STATE_IDLE_WAIT_FOR_EVENT)
{
// If no device is connected, then jump to the disconnection state
if (ai_is_none())
{
ai_command_abort();
state_m.state = STATE_DEVICE_DISCONNECTED;
}
}
switch (state_m.state)
{
case STATE_INITIALIZATION:
state_m.state = STATE_IDLE_ENTRY_POINT;
cpu_stop_timeout(&state_m.in_progress_timer);
// Set default volume if specified
#if defined(DEFAULT_VOLUME)
audio_mixer_dacs_set_volume(DEFAULT_VOLUME);
#endif
break;
case STATE_DEVICE_CONNECTED:
controller_init(FCPU_HZ, FHSB_HZ, FPBB_HZ, FPBA_HZ);
state_m.state = STATE_NAVIGATION_ENTRY_POINT;
state_m.view_elt |= GUI_UPDATE_ELT_CONNECTED;
break;
case STATE_DEVICE_DISCONNECTED:
controller_shutdown();
state_m.state = STATE_IDLE_ENTRY_POINT;
state_m.view_elt |= GUI_UPDATE_ELT_DISCONNECTED;
break;
case STATE_IDLE_ENTRY_POINT:
case STATE_IDLE_WAIT_FOR_EVENT:
case STATE_IDLE_DRIVE_LOAD:
idle_task(&state_m);
break;
case STATE_NAVIGATION_ENTRY_POINT:
case STATE_NAVIGATION_UPDATE_LIST:
case STATE_NAVIGATION_UPDATE_LIST_GET_NAME:
case STATE_NAVIGATION_UPDATE_LIST_STORE_NAME:
case STATE_NAVIGATION_UPDATE_ISDIR:
case STATE_NAVIGATION_WAIT_FOR_EVENT:
case STATE_NAVIGATION_UPDATE_STATUS:
case STATE_NAVIGATION_CD:
case STATE_NAVIGATION_GOTOPARENT:
case STATE_NAVIGATION_GOTOPARENT_ERROR_HANDLING:
case STATE_NAVIGATION_PLAY_SELECTED_FILE:
case STATE_NAVIGATION_WAIT_FOR_SELECTION:
case STATE_NAVIGATION_UPDATE_METADATA_AND_PLAY:
navigation_task(&state_m);
break;
case STATE_PLAYBACK_ENTRY_POINT:
case STATE_PLAYBACK_WAIT_FOR_EVENT:
case STATE_PLAYBACK_HANDLE_FAST_MODES:
case STATE_PLAYBACK_UPDATE_TIME:
case STATE_PLAYBACK_UPDATE_STATUS:
playback_task(&state_m);
break;
case STATE_CONFIG_ENTRY_POINT:
case STATE_CONFIG_WAIT_FOR_EVENT:
case STATE_CONFIG_UPDATE_STATES:
case STATE_CONFIG_READ_REPEAT_STATE:
case STATE_CONFIG_READ_SHUFFLE_STATE:
config_task(&state_m);
break;
case STATE_CHECK_DEVICE_ENTRY_POINT:
case STATE_CHECK_DEVICE_UPDATE_STATUS:
check_device_task(&state_m);
break;
case STATE_TRACK_CHANGED_ENTRY_POINT:
case STATE_TRACK_CHANGED_TOTAL_TIME:
case STATE_TRACK_CHANGED_FILE_NAME:
case STATE_TRACK_CHANGED_ARTIST:
case STATE_TRACK_CHANGED_TITLE:
case STATE_TRACK_CHANGED_IMAGE:
case STATE_TRACK_CHANGED_RESUME:
case STATE_TRACK_CHECK_RESUME:
track_changed_task(&state_m);
break;
case STATE_COMMAND_PLAY_ANY_SONG:
command_task(&state_m);
break;
default:
break;
}
/*
// Power sleep mode is managed here
if( usb_device_get_state()==DEVICE_STATE_NOT_CONNECTED ) {
if( cpu_is_timer_stopped(&sleep_timer) ) {
cpu_set_timeout(cpu_ms_2_cy(SLEEP_MODE_MS, FCPU_HZ), &sleep_timer);
}
else if( cpu_is_timeout(&sleep_timer) ) {
gui_enter_idle();
SLEEP(AVR32_PM_SMODE_IDLE);
gui_leave_idle();
}
} else {
cpu_stop_timeout(&sleep_timer);
}
*/
}
//!
//! @brief This function initializes the USB Stream driver.
//!
void usb_stream_init(uint32_t sample_rate_hz, uint8_t num_channels, uint8_t bits_per_sample, bool swap_channels)
{
const resampling_config_t default_param = AUDIO_STREAM_IN_OUT_FS_DEFAULT_VALUE;
const resampling_config_t translation_tab[] = AUDIO_STREAM_IN_OUT_FS_TRANSLATION_TAB;
int i;
int max_buffer_size;
int underrun_fs, overrun_fs, order;
dsp16_resampling_options_t options;
// Reset the structure
memset(&options, 0, sizeof(dsp16_resampling_options_t));
// Add default values
options.coefficients_generation = DSP16_RESAMPLING_OPTIONS_USE_DYNAMIC;
options.dynamic.coefficients_normalization = true;
if (num_channels == 1)
{
num_channels = 2;
usb_stream_context->duplicate_channels = true;
}
else
usb_stream_context->duplicate_channels = false;
// Free the existing context if any
usb_stream_close();
// Clear the error flag
usb_stream_context->error = USB_STREAM_ERROR_NONE;
// Choose which output sampling rate to choose
usb_stream_context->fs_output = default_param.output_fs_hz;
underrun_fs = default_param.output_underrun_fs_hz;
overrun_fs = default_param.output_overrun_fs_hz;
order = default_param.order;
usb_stream_context->ctx_original.gain = default_param.gain;
usb_stream_context->ctx_underrun.gain = default_param.gain_underrun;
usb_stream_context->ctx_overrun.gain = default_param.gain_overrun;
for (i=0; i<sizeof(translation_tab) / sizeof(translation_tab[0]); i++)
{
if (translation_tab[i].input_fs_hz == sample_rate_hz)
{
usb_stream_context->fs_output = translation_tab[i].output_fs_hz;
underrun_fs = translation_tab[i].output_underrun_fs_hz;
overrun_fs = translation_tab[i].output_overrun_fs_hz;
order = translation_tab[i].order;
// Set gain stage for each context
usb_stream_context->ctx_original.gain = translation_tab[i].gain;
usb_stream_context->ctx_underrun.gain = translation_tab[i].gain_underrun;
usb_stream_context->ctx_overrun.gain = translation_tab[i].gain_overrun;
break;
}
}
if (num_channels > AUDIO_STREAM_MAX_NB_CHANNELS)
{
usb_stream_context->error = USB_STREAM_ERROR_UNSUPPORTED;
return;
}
// Create a new resampling context
usb_stream_context->ctx_original.resampling = dsp16_resampling_setup(sample_rate_hz,
usb_stream_context->fs_output,
usb_stream_context->input_buffer_size,
order,
num_channels,
(malloc_fct_t) malloc,
&options);
usb_stream_context->ctx_overrun.resampling = dsp16_resampling_setup(sample_rate_hz,
overrun_fs,
usb_stream_context->input_buffer_size,
order,
num_channels,
(malloc_fct_t) malloc,
&options);
usb_stream_context->ctx_underrun.resampling = dsp16_resampling_setup(sample_rate_hz,
underrun_fs,
usb_stream_context->input_buffer_size,
order,
num_channels,
(malloc_fct_t) malloc,
&options);
if (!usb_stream_context->ctx_original.resampling
|| !usb_stream_context->ctx_overrun.resampling
|| !usb_stream_context->ctx_underrun.resampling)
{
usb_stream_context->error = USB_STREAM_ERROR_UNSUPPORTED;
usb_stream_close();
return;
}
// Get the maximum size of the output buffer (the same will be used with the different frequencies)
max_buffer_size = dsp16_resampling_get_output_max_buffer_size(usb_stream_context->ctx_original.resampling);
max_buffer_size = max(max_buffer_size, dsp16_resampling_get_output_max_buffer_size(usb_stream_context->ctx_overrun.resampling));
max_buffer_size = max(max_buffer_size, dsp16_resampling_get_output_max_buffer_size(usb_stream_context->ctx_underrun.resampling));
// Allocate memory for the output buffers
for(i=0; i<AUDIO_STREAM_NB_OUTPUT_BUFFERS; i++)
{
if (!(usb_stream_context->output_buffers[i] = malloc(sizeof(dsp16_t)*(max_buffer_size + 1)*num_channels)))
{
usb_stream_context->error = USB_STREAM_ERROR_UNSUPPORTED;
usb_stream_close();
return;
}
}
// Allocate memory for the temporary output buffer
if (!(usb_stream_context->output_temp_buffer = malloc(sizeof(dsp16_t)*max_buffer_size)))
{
usb_stream_context->error = USB_STREAM_ERROR_UNSUPPORTED;
usb_stream_close();
return;
}
// Fills the context structure
usb_stream_context->error = USB_STREAM_ERROR_NONE;
usb_stream_context->nb_channels = num_channels;
if (bits_per_sample == 32)
bits_per_sample = 16;
usb_stream_context->bits_per_sample = bits_per_sample;
usb_stream_context->swap_channels = swap_channels;
// No full buffer available yet
usb_stream_context->current_full_buffer = -1;
// Set buffers to "initialization" state
usb_stream_context->current_buffer = 0;
for(i=0; i<AUDIO_STREAM_NB_INPUT_BUFFERS; i++)
usb_stream_context->input_buffers[i]->buffer_state = BUFFER_STATE_EMPTY;
usb_stream_context->synchronized = false;
// Configure the DAC
audio_mixer_dacs_setup_direct(usb_stream_context->fs_output,
num_channels,
bits_per_sample,
swap_channels);
// Use by default the original re-sampling setup
usb_stream_context->ctx = &usb_stream_context->ctx_original;
// Set status to initialized
usb_stream_context->status = USB_STREAM_STATUS_IDLE;
// Start the broken stream timer
cpu_set_timeout(cpu_ms_2_cy(BROKEN_STREAM_TIMER, FCPU_HZ), &broken_stream_timer);
}
static void twi_init(U32 fpba_hz)
{
const gpio_map_t AT42QT1060_TWI_GPIO_MAP =
{
{AT42QT1060_TWI_SCL_PIN, AT42QT1060_TWI_SCL_FUNCTION},
{AT42QT1060_TWI_SDA_PIN, AT42QT1060_TWI_SDA_FUNCTION}
};
const twi_options_t AT42QT1060_TWI_OPTIONS =
{
.pba_hz = 24000000,
.speed = AT42QT1060_TWI_MASTER_SPEED,
.chip = AT42QT1060_TWI_ADDRESS
};
// Assign I/Os to SPI.
gpio_enable_module(AT42QT1060_TWI_GPIO_MAP,
sizeof(AT42QT1060_TWI_GPIO_MAP) / sizeof(AT42QT1060_TWI_GPIO_MAP[0]));
// Initialize as master.
twi_master_init(AT42QT1060_TWI, &AT42QT1060_TWI_OPTIONS);
}
/*! \brief Callback function for a detect event of the touch sensor device.
*/
void touch_detect_callback(void)
{
touch_detect = true;
}
struct at42qt1060_data touch_data;
void controller_task(void)
{
// if a touch is detected we read the status
if(touch_detect)
{
touch_data.detect_status =
at42qt1060_read_reg(AT42QT1060_DETECTION_STATUS);
// need to read input port status too to reset CHG line
at42qt1060_read_reg(AT42QT1060_INPUT_PORT_STATUS);
touch_detect = false;
}
}
static void controller_detect_int_handler(void)
{
if(gpio_get_pin_interrupt_flag(AT42QT1060_DETECT_PIN))
{
gpio_clear_pin_interrupt_flag(AT42QT1060_DETECT_PIN);
touch_detect_callback();
}
}
void controller_init(U32 fcpu_hz, U32 fhsb_hz, U32 fpbb_hz, U32 fpba_hz)
{
// Disable all interrupts
Disable_global_interrupt();
twi_init(fpba_hz);
// wait until the device settles its CHG line
cpu_delay_ms(230, fcpu_hz);
at42qt1060_init(fcpu_hz);
BSP_INTC_IntReg(&controller_detect_int_handler, AVR32_GPIO_IRQ_0 + AT42QT1060_DETECT_PIN/8, AVR32_INTC_INT1);
// For now we only react on falling edge
// Actually this is a level interrupt (low active)
gpio_enable_pin_interrupt(AT42QT1060_DETECT_PIN, GPIO_FALLING_EDGE);
gpio_clear_pin_interrupt_flag(AT42QT1060_DETECT_PIN);
//static_fcpu_hz = fcpu_hz;
cpu_set_timeout(cpu_ms_2_cy(JOYSTICK_KEY_DEBOUNCE_MS, static_fcpu_hz),
&joystick_key_sensibility_timer);
// Enable global interrupts
Enable_global_interrupt();
}
//!
//! @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;
}
}
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;
}
}
void controller_init(uint32_t fcpu_hz, uint32_t fhsb_hz, uint32_t fpbb_hz, uint32_t fpba_hz) {
static const gpio_map_t QT60168_SPI_GPIO_MAP = { { QT60168_SPI_SCK_PIN,
QT60168_SPI_SCK_FUNCTION }, // SPI Clock.
{ QT60168_SPI_MISO_PIN, QT60168_SPI_MISO_FUNCTION }, // MISO.
{ QT60168_SPI_MOSI_PIN, QT60168_SPI_MOSI_FUNCTION }, // MOSI.
{ QT60168_SPI_NPCS0_PIN, QT60168_SPI_NPCS0_FUNCTION } // Chip Select NPCS.
};
// SPI options.
spi_options_t spiOptions = {
.reg = QT60168_SPI_NCPS,
.baudrate = QT60168_SPI_MASTER_SPEED, // Defined in conf_qt60168.h.
.bits = QT60168_SPI_BITS, // Defined in conf_qt60168.h.
.spck_delay = 0, .trans_delay = 0, .stay_act = 0, .spi_mode = 3,
.modfdis = 1 };
// Assign I/Os to SPI.
gpio_enable_module(QT60168_SPI_GPIO_MAP, sizeof(QT60168_SPI_GPIO_MAP)
/ sizeof(QT60168_SPI_GPIO_MAP[0]));
// Set selection mode: variable_ps, pcs_decode, delay.
spi_selectionMode(QT60168_SPI, 0, 0, 0);
// Enable SPI.
spi_enable(QT60168_SPI);
// Initialize QT60168 with SPI clock Osc0.
spi_setupChipReg(QT60168_SPI, &spiOptions, fpba_hz);
// Initialize QT60168 component.
qt60168_init(fpba_hz);
// Init timer to get key value.
rtc_init_qt();
// Invalidate the timeout already
cpu_set_timeout(0, &cpu_time_clear_wheel);
}
void rtc_init_qt( void ) {
// Init touch_states
controller_clear();
// Disable all interrupts
cpu_irq_disable();
// Register the RTC interrupt handler to the interrupt controller.
irq_register_handler(rtc_irq, AVR32_RTC_IRQ, 0);
// Initialize the RTC
rtc_init(&AVR32_RTC, RTC_OSC_32KHZ, 4);
rtc_set_top_value(&AVR32_RTC, 1);
// Enable the interrupts
rtc_enable_interrupt(&AVR32_RTC);
// Enable the RTC
rtc_enable(&AVR32_RTC);
// Enable global interrupts
cpu_irq_enable();
}
ISR(usb_general_interrupt, AVR32_USBB_IRQ_GROUP, USB_INT_LEVEL)
#endif
{
#ifdef FREERTOS_USED
portBASE_TYPE task_woken = pdFALSE;
#endif
uint8_t i;
/* avoid Cppcheck Warning */
UNUSED(i);
// ---------- DEVICE/HOST events management ------------------------------------
#if USB_DEVICE_FEATURE == true && USB_HOST_FEATURE == true
// ID pin change detection
if (Is_usb_id_transition() && Is_usb_id_interrupt_enabled())
{
g_usb_mode = (Is_usb_id_device()) ? USB_MODE_DEVICE : USB_MODE_HOST;
Usb_ack_id_transition();
if (g_usb_mode != g_old_usb_mode) // Basic debounce
{
// Previously in device mode, check if disconnection was detected
if (g_old_usb_mode == USB_MODE_DEVICE)
{
if (usb_connected)
{
// Device mode diconnection actions
usb_connected = false;
usb_configuration_nb = 0;
Usb_vbus_off_action();
}
}
// Previously in host mode, check if disconnection was detected
else if (Is_host_attached())
{
// Host mode diconnection actions
device_state = DEVICE_UNATTACHED;
Host_device_disconnection_action();
}
LOG_STR(log_pin_id_changed);
Usb_send_event((Is_usb_device()) ? EVT_USB_DEVICE_FUNCTION :
EVT_USB_HOST_FUNCTION);
Usb_id_transition_action();
//! @todo ID pin hot state change!!!
// Preliminary management: HARDWARE RESET!!!
#if ID_PIN_CHANGE_GENERATE_RESET == ENABLE
// Hot ID transition generates CPU reset
Usb_disable();
Usb_disable_otg_pad();
#ifdef FREERTOS_USED
// Release the semaphore in order to start a new device/host task
taskENTER_CRITICAL();
xSemaphoreGiveFromISR(usb_tsk_semphr, &task_woken);
taskEXIT_CRITICAL();
#else
#if defined(CPU_RESET_CALLBACK)
CPU_RESET_CALLBACK();
#endif
Reset_CPU();
#endif
#endif
g_old_usb_mode = g_usb_mode; // Store current USB mode, for mode change detection
}
}
#endif // End DEVICE/HOST FEATURE MODE
// ---------- DEVICE events management -----------------------------------------
#if USB_DEVICE_FEATURE == true
#if USB_HOST_FEATURE == true
// If both device and host features are enabled, check if device mode is engaged
// (accessing the USB registers of a non-engaged mode, even with load operations,
// may corrupt USB FIFO data).
if (Is_usb_device())
#endif
{
// VBus state detection
if (Is_usb_vbus_transition() && Is_usb_vbus_interrupt_enabled())
{
Usb_ack_vbus_transition();
if (Is_usb_vbus_high())
{
usb_start_device();
Usb_send_event(EVT_USB_POWERED);
Usb_vbus_on_action();
}
else
{
Usb_unfreeze_clock();
Usb_detach();
usb_connected = false;
usb_configuration_nb = 0;
Usb_send_event(EVT_USB_UNPOWERED);
Usb_vbus_off_action();
#ifdef FREERTOS_USED
// Release the semaphore in order to start a new device/host task
taskENTER_CRITICAL();
xSemaphoreGiveFromISR(usb_tsk_semphr, &task_woken);
taskEXIT_CRITICAL();
#endif
}
}
// Device Start-of-Frame received
if (Is_usb_sof() && Is_usb_sof_interrupt_enabled())
{
Usb_ack_sof();
Usb_sof_action();
}
// Device Suspend event (no more USB activity detected)
if (Is_usb_suspend() && Is_usb_suspend_interrupt_enabled())
{
Usb_ack_suspend();
Usb_enable_wake_up_interrupt();
(void)Is_usb_wake_up_interrupt_enabled();
Usb_freeze_clock();
Usb_send_event(EVT_USB_SUSPEND);
Usb_suspend_action();
}
// Wake-up event (USB activity detected): Used to resume
if (Is_usb_wake_up() && Is_usb_wake_up_interrupt_enabled())
{
Usb_unfreeze_clock();
(void)Is_usb_clock_frozen();
Usb_ack_wake_up();
Usb_disable_wake_up_interrupt();
Usb_wake_up_action();
Usb_send_event(EVT_USB_WAKE_UP);
}
// Resume state bus detection
if (Is_usb_resume() && Is_usb_resume_interrupt_enabled())
{
Usb_disable_wake_up_interrupt();
Usb_ack_resume();
Usb_disable_resume_interrupt();
Usb_resume_action();
Usb_send_event(EVT_USB_RESUME);
}
// USB bus reset detection
if (Is_usb_reset() && Is_usb_reset_interrupt_enabled())
{
Usb_ack_reset();
usb_init_device();
Usb_reset_action();
Usb_send_event(EVT_USB_RESET);
}
}
#endif // End DEVICE FEATURE MODE
// ---------- HOST events management -------------------------------------------
#if USB_HOST_FEATURE == true
#if USB_DEVICE_FEATURE == true
// If both device and host features are enabled, check if host mode is engaged
// (accessing the USB registers of a non-engaged mode, even with load operations,
// may corrupt USB FIFO data).
else
#endif
{
// The device has been disconnected
if (Is_host_device_disconnection() && Is_host_device_disconnection_interrupt_enabled())
{
host_disable_all_pipes();
Host_ack_device_disconnection();
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
reset_it_pipe_str();
#endif
#ifdef HOST_VBUS_LOW_TIMEOUT
cpu_set_timeout(HOST_VBUS_LOW_TIMEOUT, &timer_vbus_low);
device_state = DEVICE_VBUS_LOW;
#else
device_state = DEVICE_UNATTACHED;
#endif
LOG_STR(log_device_disconnected);
Usb_send_event(EVT_HOST_DISCONNECTION);
Host_device_disconnection_action();
#ifdef FREERTOS_USED
// Release the semaphore in order to start a new device/host task
taskENTER_CRITICAL();
xSemaphoreGiveFromISR(usb_tsk_semphr, &task_woken);
taskEXIT_CRITICAL();
#endif
}
// Device connection
if (Is_host_device_connection() && Is_host_device_connection_interrupt_enabled())
{
Host_ack_device_connection();
host_disable_all_pipes();
Usb_send_event(EVT_HOST_CONNECTION);
Host_device_connection_action();
}
// Host Start-of-Frame has been sent
if (Is_host_sof() && Is_host_sof_interrupt_enabled())
{
Host_ack_sof();
Usb_send_event(EVT_HOST_SOF);
private_sof_counter++;
// Delay time-out management for interrupt tranfer mode in host mode
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE && TIMEOUT_DELAY_ENABLE == ENABLE
if (private_sof_counter >= 250) // Count 250 ms (SOF @ 1 ms)
{
private_sof_counter = 0;
for (i = 0; i < MAX_PEP_NB; i++)
{
if (it_pipe_str[i].enable &&
++it_pipe_str[i].timeout > TIMEOUT_DELAY && Host_get_pipe_type(i) != TYPE_INTERRUPT)
{
it_pipe_str[i].enable = false;
it_pipe_str[i].status = PIPE_DELAY_TIMEOUT;
Host_reset_pipe(i);
if (!is_any_interrupt_pipe_active() && !g_sav_int_sof_enable) // If no more transfer is armed
{
Host_disable_sof_interrupt();
}
it_pipe_str[i].handler(PIPE_DELAY_TIMEOUT, it_pipe_str[i].nb_byte_processed);
}
}
}
#endif
Host_sof_action();
}
// Host Wake-up has been received
if (Is_host_hwup() && Is_host_hwup_interrupt_enabled())
{
// CAUTION: HWUP can be cleared only when USB clock is active (not frozen)!
//! @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
Host_disable_hwup_interrupt(); // Wake-up interrupt should be disabled as host is now awoken!
Host_ack_hwup(); // Clear HWUP interrupt flag
Usb_send_event(EVT_HOST_HWUP); // Send software event
Host_hwup_action(); // Map custom action
}
Host_int_action();
while ((i = Host_get_interrupt_pipe_number()) < MAX_PEP_NB)
{
if (Is_host_in_received(i) && Is_host_in_received_interrupt_enabled(i))
{
Host_freeze_pipe(i);
Host_disable_in_received_interrupt(i);
}
}
#if defined(USB_HIGH_SPEED_SUPPORT) && USB_HIGH_SPEED_SUPPORT == true && \
defined(PIPE_AUDIO_IN)
// Workaround - freeze the IN audio pipe
if (Is_host_in_received(PIPE_AUDIO_IN))
{
extern void workaround_freeze_iso_in(void);
workaround_freeze_iso_in();
}
#endif // USB_HIGH_SPEED_SUPPORT == true
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
// Host pipe interrupts
while ((i = Host_get_interrupt_pipe_number()) < MAX_PEP_NB) usb_pipe_interrupt(i);
#endif
}
#endif // End HOST FEATURE MODE
#ifdef FREERTOS_USED
return task_woken;
#endif
}
/*! \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;
}
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();
}
//!
//! @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;
}
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);
}
}
}