int test_exti(struct harness_t *harness_p)
{
int i;
struct exti_driver_t exti;
struct pin_driver_t pin;
pin_init(&pin, &pin_d4_dev, PIN_OUTPUT);
pin_write(&pin, 1);
BTASSERT(exti_init(&exti,
&exti_d3_dev,
EXTI_TRIGGER_FALLING_EDGE,
isr,
NULL) == 0);
BTASSERT(exti_start(&exti) == 0);
for (i = 0; i < 10; i++) {
pin_write(&pin, 0);
time_busy_wait_us(10000);
pin_write(&pin, 1);
time_busy_wait_us(10000);
}
std_printf(FSTR("flag = %d\r\n"), (int)flag);
BTASSERT(flag == 10);
return (0);
}
int uart_soft_init(struct uart_soft_driver_t *self_p,
struct pin_device_t *tx_dev_p,
struct pin_device_t *rx_dev_p,
struct exti_device_t *rx_exti_dev_p,
int baudrate,
void *rxbuf_p,
size_t size)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(tx_dev_p != NULL, EINVAL);
ASSERTN(rx_dev_p != NULL, EINVAL);
ASSERTN(rx_exti_dev_p != NULL, EINVAL);
ASSERTN(rxbuf_p != NULL, EINVAL);
self_p->sample_time = BAUDRATE2US(baudrate);
chan_init(&self_p->chout,
chan_read_null,
(ssize_t (*)(void *, const void *, size_t))uart_soft_write_cb,
chan_size_null);
pin_init(&self_p->tx_pin, tx_dev_p, PIN_OUTPUT);
pin_init(&self_p->rx_pin, rx_dev_p, PIN_INPUT);
/* Keep TX line high when no transmission is ongoing. */
pin_write(&self_p->tx_pin, 1);
exti_init(&self_p->rx_exti,
rx_exti_dev_p,
EXTI_TRIGGER_FALLING_EDGE,
rx_isr,
self_p);
exti_start(&self_p->rx_exti);
return (queue_init(&self_p->chin, rxbuf_p, size));
}
static void init(void)
{
long number;
struct fat16_dir_t dir;
struct fat16_dir_entry_t entry;
struct song_t *song_p;
uint32_t seconds;
fat16_read_t read;
fat16_write_t write;
void * arg_p;
sys_start();
uart_module_init();
uart_init(&uart, &uart_device[0], 38400, qinbuf, sizeof(qinbuf));
uart_start(&uart);
sys_set_stdout(&uart.chout);
std_printf(sys_get_info());
fs_command_init(&cmd_list, FSTR("/list"), cmd_list_cb, NULL);
fs_command_register(&cmd_list);
fs_command_init(&cmd_play, FSTR("/play"), cmd_play_cb, NULL);
fs_command_register(&cmd_play);
fs_command_init(&cmd_pause, FSTR("/pause"), cmd_pause_cb, NULL);
fs_command_register(&cmd_pause);
fs_command_init(&cmd_next, FSTR("/next"), cmd_next_cb, NULL);
fs_command_register(&cmd_next);
fs_command_init(&cmd_prev, FSTR("/prev"), cmd_prev_cb, NULL);
fs_command_register(&cmd_prev);
fs_command_init(&cmd_stop, FSTR("/stop"), cmd_stop_cb, NULL);
fs_command_register(&cmd_stop);
fs_command_init(&cmd_repeat, FSTR("/repeat"), cmd_repeat_cb, NULL);
fs_command_register(&cmd_repeat);
fs_command_init(&cmd_set_bits_per_sample,
FSTR("/set_bits_per_sample"),
cmd_set_bits_per_sample_cb,
NULL);
fs_command_register(&cmd_set_bits_per_sample);
if (storage_init(&read, &write, &arg_p) != 0) {
std_printf(FSTR("storage init failed\r\n"));
return;
}
std_printf(FSTR("initializing fat16\r\n"));
fat16_init(&fs, read, write, arg_p, 0);
std_printf(FSTR("fat16 initialized\r\n"));
if (fat16_mount(&fs) != 0) {
std_printf(FSTR("failed to mount fat16\r\n"));
return;
}
std_printf(FSTR("fat16 mounted\r\n"));
event_init(&event);
exti_module_init();
/* Initialize the buttons. */
exti_init(&buttons[0],
&exti_d18_dev,
EXTI_TRIGGER_FALLING_EDGE,
on_button_play,
NULL);
exti_start(&buttons[0]);
exti_init(&buttons[1],
&exti_d19_dev,
EXTI_TRIGGER_FALLING_EDGE,
on_button_prev,
NULL);
exti_start(&buttons[1]);
exti_init(&buttons[2],
&exti_d20_dev,
EXTI_TRIGGER_FALLING_EDGE,
on_button_next,
NULL);
exti_start(&buttons[2]);
exti_init(&buttons[3],
&exti_d21_dev,
EXTI_TRIGGER_FALLING_EDGE,
on_button_stop,
NULL);
exti_start(&buttons[3]);
dac_init(&dac,
&dac_0_dev,
&pin_dac0_dev,
&pin_dac1_dev,
2 * SAMPLES_PER_SOCOND);
hash_map_init(&song_map,
buckets,
membersof(buckets),
entries,
membersof(entries),
hash_number);
sem_init(&sem, 0, 1);
music_player_init(&music_player,
&fs,
&dac,
get_current_song_path,
get_next_song_path,
NULL);
/* Initialize the song number. */
current_song = FIRST_SONG_NUMBER;
number = FIRST_SONG_NUMBER;
/* Add songs to the hash map. */
fat16_dir_open(&fs, &dir, ".", O_READ);
while (fat16_dir_read(&dir, &entry) == 1) {
if (number - FIRST_SONG_NUMBER == membersof(songs)) {
std_printf("Maximum number of songs already added. "
"Skipping the rest of the songs.\r\n");
break;
}
/* Skip folders. */
if (entry.is_dir == 1) {
continue;
}
song_p = &songs[number - FIRST_SONG_NUMBER];
/* Initialize the song entry. */
song_p->number = number;
strcpy(song_p->name, entry.name);
seconds = (entry.size / 4 / SAMPLES_PER_SOCOND);
song_p->minutes = (seconds / 60);
song_p->seconds = (seconds % 60);
std_printf("Adding song %s to playlist.\r\n",
entry.name);
hash_map_add(&song_map, number, song_p);
number++;
}
fat16_dir_close(&dir);
last_song_number = (number - 1);
music_player_start(&music_player);
}
