/**
* \brief Initialize SD/MMC storage.
*/
static void init_storage(void)
{
FRESULT res;
Ctrl_status status;
/* Initialize SD/MMC stack. */
sd_mmc_init();
while (true) {
printf("init_storage: Please plug an SD/MMC card in slot.\r\n");
/* Wait card present and ready. */
do {
status = sd_mmc_test_unit_ready(0);
if (CTRL_FAIL == status) {
printf("init_storage: SD Card install Failed.\r\n");
printf("init_storage: Please unplug and re-plug the card.\r\n");
while (CTRL_NO_PRESENT != sd_mmc_check(0)) {
}
}
} while (CTRL_GOOD != status);
printf("init_storage: Mount SD card...\r\n");
memset(&fatfs, 0, sizeof(FATFS));
res = f_mount(LUN_ID_SD_MMC_0_MEM, &fatfs);
if (FR_INVALID_DRIVE == res) {
printf("init_storage: SD card Mount failed. res %d\r\n", res);
return;
}
printf("init_storage: SD card Mount OK.\r\n");
add_state(STORAGE_READY);
return;
}
}
/**
* Initialize for SD/MMC support
*/
void media_sd_init(void)
{
dbg_print("media_sd: init ...\r\n");
/* IOs are initialized in board_init() */
sd_mmc_init();
dbg_print("media_sd: init ... done\r\n");
}
void MassStorage::Init()
{
static const char * const VolMutexNames[] = { "SD0", "SD1" };
static_assert(ARRAY_SIZE(VolMutexNames) >= NumSdCards, "Incorrect VolMutexNames array");
// Create the mutexes
fsMutex.Create("FileSystem");
dirMutex.Create("DirSearch");
for (size_t i = 0; i < NumFileWriteBuffers; ++i)
{
freeWriteBuffers = new FileWriteBuffer(freeWriteBuffers);
}
for (size_t card = 0; card < NumSdCards; ++card)
{
SdCardInfo& inf = info[card];
memset(&inf.fileSystem, 0, sizeof(inf.fileSystem));
inf.mounting = inf.isMounted = false;
inf.cdPin = SdCardDetectPins[card];
inf.cardState = (inf.cdPin == NoPin) ? CardDetectState::present : CardDetectState::notPresent;
inf.volMutex.Create(VolMutexNames[card]);
}
sd_mmc_init(SdWriteProtectPins, SdSpiCSPins); // initialize SD MMC stack
// We no longer mount the SD card here because it may take a long time if it fails
}
void memories_initialization(void)
{
#ifdef CONF_BOARD_SMC_PSRAM
psram_init();
#endif
#ifdef CONF_BOARD_SRAM
ext_sram_init();
#endif
#if defined CONF_BOARD_SD_MMC_HSMCI || defined CONF_BOARD_SD_MMC_SPI
sd_mmc_init();
#endif
}
/**
* \brief Application entry point.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
uint8_t slot = 0;
sd_mmc_err_t err;
system_init();
delay_init();
cdc_uart_init();
irq_initialize_vectors();
cpu_irq_enable();
time_tick_init();
// Initialize SD MMC stack
sd_mmc_init();
printf("\x0C\n\r-- SD/MMC Card Example --\n\r");
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
while (1) {
if (slot == sd_mmc_nb_slot()) {
slot = 0;
}
printf("Please plug an SD/MMC card in slot %d.\n\r", slot+1);
// Wait for a card and ready
do {
err = sd_mmc_check(slot);
if ((SD_MMC_ERR_NO_CARD != err)
&& (SD_MMC_INIT_ONGOING != err)
&& (SD_MMC_OK != err)) {
printf("Card install FAILED\n\r");
printf("Please unplug and re-plug the card.\n\r");
while (SD_MMC_ERR_NO_CARD != sd_mmc_check(slot)) {
}
}
} while (SD_MMC_OK != err);
// Display basic card information
main_display_info_card(slot);
/* Test the card */
if (sd_mmc_get_type(slot) & (CARD_TYPE_SD | CARD_TYPE_MMC)) {
// SD/MMC Card R/W
main_test_memory(slot);
}
printf("Test finished, please unplugged the card.\n\r");
while (SD_MMC_OK == sd_mmc_check(slot)) {
}
slot++;
}
}
void memories_initialization(void)
{
#if (defined AT45DBX_MEM) && (AT45DBX_MEM == ENABLE)
// sysclk_enable_peripheral_clock(AT45DBX_SPI_MODULE);
// is already done by XMEGA SPI driver
at45dbx_init();
#endif
#if ((defined SD_MMC_0_MEM) && (SD_MMC_0_MEM == ENABLE)) \
|| ((defined SD_MMC_1_MEM) && (SD_MMC_1_MEM == ENABLE))
sd_mmc_init();
#endif
}
void sd_open(struct memory_card *card)
{
int ret;
struct aml_card_info *aml_card_info = card->card_plat_info;
SD_MMC_Card_Info_t *sd_mmc_info = (SD_MMC_Card_Info_t *)card->card_info;
#if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6
switch_mod_gate_by_type(MOD_SDIO,1);
#endif
if (aml_card_info->card_extern_init)
aml_card_info->card_extern_init();
ret = sd_mmc_init(sd_mmc_info);
if(ret)
ret = sd_mmc_init(sd_mmc_info);
if(ret)
ret = sd_mmc_init(sd_mmc_info);
card->capacity = sd_mmc_info->blk_nums;
card->sdio_funcs = sd_mmc_info->sdio_function_nums;
memcpy(card->raw_cid, &(sd_mmc_info->raw_cid), sizeof(card->raw_cid));
if(sd_mmc_info->write_protected_flag)
card->state |= CARD_STATE_READONLY;
#if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6
switch_mod_gate_by_type(MOD_SDIO,0);
#endif
if(ret)
card->unit_state = CARD_UNIT_READY;
else
card->unit_state = CARD_UNIT_PROCESSED;
return;
}
void memories_initialization(void)
{
#ifdef CONF_BOARD_SMC_PSRAM
psram_init();
#endif
#ifdef CONF_BOARD_SRAM
sram_init();
#endif
#ifdef CONF_BOARD_SDRAMC
/* Enable SMC peripheral clock */
pmc_enable_periph_clk(ID_SMC);
/* Complete SDRAM configuration */
sdramc_init((sdramc_memory_dev_t *)&SDRAM_MICRON_MT48LC16M16A2,
sysclk_get_cpu_hz());
#endif
#ifdef CONF_BOARD_AT45DBX
at45dbx_init();
if (at45dbx_mem_check() != true) {
while (1) {
}
}
#endif
#ifdef CONF_BOARD_SD_MMC_HSMCI
uint8_t slot = 0;
sd_mmc_err_t err;
sd_mmc_init();
if (slot == sd_mmc_nb_slot()) {
slot = 0;
}
// Wait for a card and ready
do {
err = sd_mmc_check(slot);
if ((SD_MMC_ERR_NO_CARD != err)
&& (SD_MMC_INIT_ONGOING != err)
&& (SD_MMC_OK != err)) {
while (SD_MMC_ERR_NO_CARD != sd_mmc_check(slot)) {
}
}
} while (SD_MMC_OK != err);
#endif
}
void MassStorage::Init()
{
hsmciPinsinit();
// Initialize SD MMC stack
sd_mmc_init();
int sdPresentCount = 0;
while ((CTRL_NO_PRESENT == sd_mmc_check(0)) && (sdPresentCount < 5))
{
//platform->Message(HOST_MESSAGE, "Please plug in the SD card.\n");
//delay(1000);
sdPresentCount++;
}
if(sdPresentCount >= 5)
{
platform->Message(HOST_MESSAGE, "Can't find the SD card.\n");
return;
}
//print card info
// SerialUSB.print("sd_mmc_card->capacity: ");
// SerialUSB.print(sd_mmc_get_capacity(0));
// SerialUSB.print(" bytes\n");
// SerialUSB.print("sd_mmc_card->clock: ");
// SerialUSB.print(sd_mmc_get_bus_clock(0));
// SerialUSB.print(" Hz\n");
// SerialUSB.print("sd_mmc_card->bus_width: ");
// SerialUSB.println(sd_mmc_get_bus_width(0));
memset(&fileSystem, 0, sizeof(FATFS));
//f_mount (LUN_ID_SD_MMC_0_MEM, NULL);
//int mounted = f_mount(LUN_ID_SD_MMC_0_MEM, &fileSystem);
int mounted = f_mount(0, &fileSystem);
if (mounted != FR_OK)
{
platform->Message(HOST_MESSAGE, "Can't mount filesystem 0: code ");
snprintf(scratchString, STRING_LENGTH, "%d", mounted);
platform->Message(HOST_MESSAGE, scratchString);
platform->Message(HOST_MESSAGE, "\n");
}
}
void datalog_tasks_init(void)
{
uint8_t slot = 0;
sd_mmc_err_t err;
sd_mmc_init();
if (slot == sd_mmc_nb_slot()) {
slot = 0;
}
// Wait for a card and ready
do {
err = sd_mmc_check(slot);
if ((SD_MMC_ERR_NO_CARD != err)
&& (SD_MMC_INIT_ONGOING != err)
&& (SD_MMC_OK != err)) {
while (SD_MMC_ERR_NO_CARD != sd_mmc_check(slot)) {
}
}
} while (SD_MMC_OK != err);
}
/**
* \brief SD/MMC stack initialization test.
*
* \param test Current test case.
*/
static void run_sd_mmc_init_test(const struct test_case *test)
{
sd_mmc_err_t err;
/* Initialize SD MMC stack */
sd_mmc_init();
/* Wait card connection */
do {
err = sd_mmc_check(0);
} while (SD_MMC_ERR_NO_CARD == err);
/* Check if the first state is an initialization */
test_assert_true(test, err == SD_MMC_INIT_ONGOING,
"No card initialization phase detected.");
/* Check if the second step is an installation success */
test_assert_true(test, sd_mmc_check(0) == SD_MMC_OK,
"SD/MMC card initialization failed.");
}
void sd_open(struct memory_card *card)
{
int ret;
struct aml_card_info *aml_card_info = card->card_plat_info;
SD_MMC_Card_Info_t *sd_mmc_info = (SD_MMC_Card_Info_t *)card->card_info;
if (aml_card_info->card_extern_init)
aml_card_info->card_extern_init();
ret = sd_mmc_init(sd_mmc_info);
card->capacity = sd_mmc_info->blk_nums;
card->sdio_funcs = sd_mmc_info->sdio_function_nums;
memcpy(card->raw_cid, &(sd_mmc_info->raw_cid), sizeof(card->raw_cid));
if(ret)
card->unit_state = CARD_UNIT_READY;
else
card->unit_state = CARD_UNIT_PROCESSED;
return;
}
/*! \brief Main function. Execution starts here.
*/
int main(void)
{
irq_initialize_vectors();
cpu_irq_enable();
/* Initialize ASF services */
sleepmgr_init();
sysclk_init();
board_init();
gfx_mono_init();
sd_mmc_init();
rtc_init();
stdio_usb_init(); /* Initialize STDIO and start USB */
udc_stop(); /* Stop USB by default */
main_introduction();
/* Initialize tasks */
app_touch_init();
app_cpu_load_init();
app_sampling_init();
/* The main loop */
while (true) {
/* Enter in sleep mode */
app_cpu_load_enter_sleep();
sleepmgr_enter_sleep();
/* Execute tasks */
app_usb_task();
app_microsd_task();
app_sampling_task();
app_touch_task();
app_cpu_load_task();
}
}
/**
* \brief Show SD card status on the OLED screen.
*/
static void display_sd_info(void)
{
FRESULT res;
uint8_t card_check;
uint8_t sd_card_type;
uint32_t sd_card_size;
char size[64];
/* Is SD card present? */
if (gpio_pin_is_low(SD_MMC_0_CD_GPIO) == false) {
multi_language_show_no_sd_info();
} else {
multi_language_show_sd_info();
sd_mmc_init();
card_check = sd_mmc_check(0);
while (card_check != SD_MMC_OK) {
card_check = sd_mmc_check(0);
delay_ms(1);
}
if (card_check == SD_MMC_OK) {
sd_card_type = sd_mmc_get_type(0);
sd_card_size = sd_mmc_get_capacity(0);
/* Card type */
switch (sd_card_type) {
case CARD_TYPE_SD:
multi_language_show_normal_card_info();
break;
case CARD_TYPE_SDIO:
break;
case CARD_TYPE_HC:
multi_language_show_high_capacity_card_info();
break;
case CARD_TYPE_SD_COMBO:
break;
default:
multi_language_show_unknow_card_info();
}
multi_language_show_card_size_info(size, sd_card_size);
/* Try to mount file system. */
memset(&fs, 0, sizeof(FATFS));
res = f_mount(LUN_ID_SD_MMC_0_MEM, &fs);
if (FR_INVALID_DRIVE == res) {
multi_language_show_no_fatfs_info();
sd_fs_found = 0;
} else {
get_num_files_on_sd();
if (sd_num_files == 0) {
multi_language_show_no_files_info();
sd_fs_found = 1;
} else {
multi_language_show_browse_info();
sd_fs_found = 1;
}
}
}
}
}
void ZP_Init(void)
{
#ifdef DEBUG
printf("Setting up system clock...\n");
#endif
/* Setup SysTick Timer for 1 msec interrupts */
if (SysTick_Config(sysclk_get_cpu_hz() / 1000))
while (1) {}
#ifdef DEBUG
printf("ZP Init:\n");
printf("Setting up pins...\n");
#endif
#ifdef DEBUG
printf("Setting up SD stack...\n");
#endif
/* Initialize SD MMC stack */
sd_mmc_init();
uint8_t sd_check = 0;
/* Wait card present and ready */
do {
#ifdef DEBUG
if (sd_check == 1)
{
printf("Please plug an SD card in slot.\n");
sd_check = 2;
}
#endif
status = sd_mmc_test_unit_ready(0);
if (CTRL_FAIL == status) {
printf("Card install FAIL\n\r");
printf("Please unplug and re-plug the card.\n\r");
while (CTRL_NO_PRESENT != sd_mmc_check(0)) {
}
}
if (sd_check == 0)
sd_check = 1;
} while (CTRL_GOOD != status);
#ifdef DEBUG
printf("SD Card Found\n");
printf("Mounting disk...");
#endif
memset(&fs, 0, sizeof(FATFS));
res = f_mount(LUN_ID_SD_MMC_0_MEM, &fs);
if (FR_INVALID_DRIVE == res) {
printf("[FAIL] res %d\r\n", res);
}
#ifdef DEBUG
printf("Disk mounted\n");
#endif
TCHAR root_directory[3] = "0:";
root_directory[0] = '0' + LUN_ID_SD_MMC_0_MEM;
file_name[0] = '0' + LUN_ID_SD_MMC_0_MEM;
DIR dirs;
res = f_opendir(&dirs, root_directory);
if(f_opendir(&dir, "0:Scripts") == FR_NO_PATH)
{
res = f_mkdir("0:Scripts");
printf("Made Scripts folder\n");
}
printf("res: %d\n", res);
printf("Open Script\n");
//f_open(&f_script, "0:script.bin", FA_OPEN_EXISTING | FA_READ);
}
/*! \brief Main function. Execution starts here.
*/
int main(void)
{
irq_initialize_vectors();
cpu_irq_enable();
wdt_disable(WDT);
// Initialize the sleep manager
sleepmgr_init();
// Board initialization
sysclk_init();
init_board();
init_pwm();
init_i2c();
// Module initialization
init_module_peripherals_bp();
/* Initialize SD MMC stack */
delay_ms(200);
sd_mmc_init();
// Start USB stack to authorize VBus monitoring
udc_start();
// Init SCPI parser
console_init();
// Enable 12v
enable_12v();
#ifdef TEST_FW
set_user_led_colour(100, 100, 100);
#else
set_user_led_colour(0, 100, 0);
#endif
while (true)
{
console_process();
if((get_ok_12v_status() == RETURN_OK) && (last_ok_12v_state == FALSE))
{
#ifdef TEST_FW
set_user_led_colour(300, 300, 300);
#else
set_user_led_colour(0, 100, 0);
#endif
last_ok_12v_state = TRUE;
}
else if((get_ok_12v_status() == RETURN_NOK) && (last_ok_12v_state == TRUE))
{
set_user_led_colour(0, 100, 0);
last_ok_12v_state = FALSE;
}
if(integrator_flag == TRUE)
{
integrator_flag = FALSE;
ch0_integration_time_counter++;
ch1_integration_time_counter++;
ch0_counter_integrated += get_counter0_value();
ch1_counter_integrated += get_counter1_value();
if(ch0_integration_time_counter == ch0_integration_time_goal)
{
ch0_integration_time_counter = 0;
if(meas_push_activated)
{
printf("Counter0 value: %llu\x0D", ch0_counter_integrated);
}
if(get_countera_en_status() == TRUE)
{
if(last_countera_en == FALSE)
last_countera_en = TRUE;
else
add_new_countera_measurement_to_queue(ch0_counter_integrated);
}
else
last_countera_en = FALSE;
ch0_counter_integrated = 0;
}
if(ch1_integration_time_counter == ch1_integration_time_goal)
{
ch1_integration_time_counter = 0;
if(meas_push_activated)
{
printf("Counter1 value: %llu\x0D", ch1_counter_integrated);
}
if(get_counterb_en_status() == TRUE)
{
if(last_counterb_en == FALSE)
last_counterb_en = TRUE;
else
add_new_counterb_measurement_to_queue(ch1_counter_integrated);
}
else
last_counterb_en = FALSE;
ch1_counter_integrated = 0;
}
}
if(second_flag == TRUE)
{
second_flag = FALSE;
}
if (main_b_msc_enable)
{
if (!udi_msc_process_trans())
{
//sleepmgr_enter_sleep();
}
}
else
{
//sleepmgr_enter_sleep();
}
}
}
/**
* \brief Main application
*/
int main(void)
{
char test_file_name[] = "0:sd_image.bin";
FRESULT res;
FATFS fs;
FIL file_object;
uint32_t len=0;
uint32_t curr_prog_addr=APP_START_ADDRESS;
struct nvm_config config;
UINT iRead=0;
check_boot_mode();
system_init();
delay_init();
irq_initialize_vectors();
cpu_irq_enable();
/* Initialize SD MMC stack */
sd_mmc_init();
nvm_get_config_defaults(&config);
nvm_set_config(&config);
/* Turn ON LED */
port_pin_set_output_level(BOOT_LED, false);
#ifdef __DEBUG_PRINT__
serial_port_init();
printf("\x0C\n\r-- SD/MMC Card FatFs Boot Loader --\n\r");
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
printf("Please plug an SD/MMC card in slot.\n\r");
#endif
/* Wait card present and ready */
sd_mmc_ready();
memset(&fs, 0, sizeof(FATFS));
res = f_mount(LUN_ID_SD_MMC_0_MEM, &fs);
if (FR_INVALID_DRIVE == res) {
#ifdef __DEBUG_PRINT__
printf("[FAIL] Mounting SD card failed result= %d\r\n", res);
#endif
}
#ifdef __DEBUG_PRINT__
printf("Mounting the SD card successful...\r\n");
#endif
res =f_open(&file_object,(const char *)test_file_name,FA_READ);
if(res != FR_OK) error_fatal(FILE_OPEN_ERROR);
do {
if(file_object.fsize > MAX_CODE_SIZE) error_fatal(MAX_SIZE_ERROR);
res = f_read(&file_object, (void *) buff, MAX_BUF_SIZE, &iRead);
if(res != FR_OK) error_fatal(FILE_READ_ERROR);
/* Program the read data into Flash */
if(iRead)
{
program_memory(curr_prog_addr, buff,iRead);
#ifdef __DEBUG_PRINT__
printf("*");
#endif
}
/* Increment the current programming address */
curr_prog_addr += iRead;
len += iRead;
if(len > MAX_CODE_SIZE)
error_fatal(MAX_SIZE_ERROR);
/* Do this till end of file */
} while (iRead != 0);
#ifdef __DEBUG_PRINT__
printf("\r\n[PROGRAMMING COMPLETED]..Resetting !!!!\r\n");
#endif
// Intentionally not closing the file object to reduce code size !!!.
start_application();
while(1);
// Should have reset by now !!!.
}
static int sd_request(struct memory_card *card, struct card_blk_request *brq)
{
SD_MMC_Card_Info_t *sd_mmc_info = (SD_MMC_Card_Info_t *)card->card_info;
unsigned int lba, byte_cnt,ret;
unsigned char *data_buf;
struct card_host *host = card->host;
struct memory_card *sdio_card;
SD_MMC_Card_Info_t *sdio_info;
lba = brq->card_data.lba;
byte_cnt = brq->card_data.blk_size * brq->card_data.blk_nums;
data_buf = brq->crq.buf;
if(sd_mmc_info == NULL){
brq->card_data.error = SD_MMC_ERROR_NO_CARD_INS;
printk("[sd_request] sd_mmc_info == NULL, return SD_MMC_ERROR_NO_CARD_INS\n");
return 0;
}
if(!sd_mmc_info->blk_len){
card->card_io_init(card);
card->card_detector(card);
if(card->card_status == CARD_REMOVED){
brq->card_data.error = SD_MMC_ERROR_NO_CARD_INS;
return 0;
}
#if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6
switch_mod_gate_by_type(MOD_SDIO,1);
#endif
ret = sd_mmc_init(sd_mmc_info);
#if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6
switch_mod_gate_by_type(MOD_SDIO,0);
#endif
if(ret){
brq->card_data.error = SD_MMC_ERROR_NO_CARD_INS;
return 0;
}
}
#if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6
switch_mod_gate_by_type(MOD_SDIO,1);
#endif
sdio_card = card_find_card(host, CARD_SDIO);
if (sdio_card) {
sdio_close_host_interrupt(SDIO_IF_INT);
sdio_info = (SD_MMC_Card_Info_t *)sdio_card->card_info;
sd_gpio_enable(sdio_info->io_pad_type);
}
sd_sdio_enable(sd_mmc_info->io_pad_type);
if(brq->crq.cmd == READ) {
brq->card_data.error = sd_mmc_read_data(sd_mmc_info, lba, byte_cnt, data_buf);
}
else if(brq->crq.cmd == WRITE) {
brq->card_data.error = sd_mmc_write_data(sd_mmc_info, lba, byte_cnt, data_buf);
}
sd_gpio_enable(sd_mmc_info->io_pad_type);
if(brq->card_data.error == SD_WAIT_FOR_COMPLETION_TIMEOUT)
{
printk("[sd_request] wait for completion timeout, reinit\n");
card->card_io_init(card);
card->card_detector(card);
if(card->card_status == CARD_REMOVED){
printk("[sd_request] card removed\n");
brq->card_data.error = SD_MMC_ERROR_NO_CARD_INS;
return 0;
}
sd_mmc_staff_init(sd_mmc_info);
ret = sd_mmc_init(sd_mmc_info);
if(ret){
printk("[sd_request] reinit fail %d\n", ret);
brq->card_data.error = SD_MMC_ERROR_NO_CARD_INS;
return 0;
}
sd_sdio_enable(sd_mmc_info->io_pad_type);
if(brq->crq.cmd == READ) {
brq->card_data.error = sd_mmc_read_data(sd_mmc_info, lba, byte_cnt, data_buf);
}
else if(brq->crq.cmd == WRITE) {
brq->card_data.error = sd_mmc_write_data(sd_mmc_info, lba, byte_cnt, data_buf);
}
sd_gpio_enable(sd_mmc_info->io_pad_type);
if(brq->card_data.error == SD_WAIT_FOR_COMPLETION_TIMEOUT)
printk("[sd_request] after reinit still error \n");
}
sdio_card = card_find_card(host, CARD_SDIO);
if(sdio_card) {
sdio_info = (SD_MMC_Card_Info_t *)sdio_card->card_info;
sd_sdio_enable(sdio_info->io_pad_type);
if (sdio_info->sd_save_hw_io_flag) {
WRITE_CBUS_REG(SDIO_CONFIG, sdio_info->sd_save_hw_io_config);
WRITE_CBUS_REG(SDIO_MULT_CONFIG, sdio_info->sd_save_hw_io_mult_config);
}
sdio_open_host_interrupt(SDIO_IF_INT);
}
#if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6
switch_mod_gate_by_type(MOD_SDIO,0);
#endif
return 0;
}
void memories_initialization(void)
{
//-- Hmatrix bus configuration
// This improve speed performance
#ifdef AVR32_HMATRIXB
union {
unsigned long scfg;
avr32_hmatrixb_scfg_t SCFG;
} u_avr32_hmatrixb_scfg;
sysclk_enable_pbb_module(SYSCLK_HMATRIX);
// For the internal-flash HMATRIX slave, use last master as default.
u_avr32_hmatrixb_scfg.scfg =
AVR32_HMATRIXB.scfg[AVR32_HMATRIXB_SLAVE_FLASH];
u_avr32_hmatrixb_scfg.SCFG.defmstr_type =
AVR32_HMATRIXB_DEFMSTR_TYPE_LAST_DEFAULT;
AVR32_HMATRIXB.scfg[AVR32_HMATRIXB_SLAVE_FLASH] =
u_avr32_hmatrixb_scfg.scfg;
// For the internal-SRAM HMATRIX slave, use last master as default.
u_avr32_hmatrixb_scfg.scfg =
AVR32_HMATRIXB.scfg[AVR32_HMATRIXB_SLAVE_SRAM];
u_avr32_hmatrixb_scfg.SCFG.defmstr_type =
AVR32_HMATRIXB_DEFMSTR_TYPE_LAST_DEFAULT;
AVR32_HMATRIXB.scfg[AVR32_HMATRIXB_SLAVE_SRAM] =
u_avr32_hmatrixb_scfg.scfg;
# ifdef AVR32_HMATRIXB_SLAVE_EBI
// For the EBI HMATRIX slave, use last master as default.
u_avr32_hmatrixb_scfg.scfg =
AVR32_HMATRIXB.scfg[AVR32_HMATRIXB_SLAVE_EBI];
u_avr32_hmatrixb_scfg.SCFG.defmstr_type =
AVR32_HMATRIXB_DEFMSTR_TYPE_LAST_DEFAULT;
AVR32_HMATRIXB.scfg[AVR32_HMATRIXB_SLAVE_EBI] =
u_avr32_hmatrixb_scfg.scfg;
# endif
#endif
#ifdef AVR32_HMATRIX
union {
unsigned long scfg;
avr32_hmatrix_scfg_t SCFG;
} u_avr32_hmatrix_scfg;
sysclk_enable_pbb_module(SYSCLK_HMATRIX);
// For the internal-flash HMATRIX slave, use last master as default.
u_avr32_hmatrix_scfg.scfg =
AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_FLASH];
u_avr32_hmatrix_scfg.SCFG.defmstr_type =
AVR32_HMATRIX_DEFMSTR_TYPE_LAST_DEFAULT;
AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_FLASH] =
u_avr32_hmatrix_scfg.scfg;
// For the internal-SRAM HMATRIX slave, use last master as default.
u_avr32_hmatrix_scfg.scfg =
AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_SRAM];
u_avr32_hmatrix_scfg.SCFG.defmstr_type =
AVR32_HMATRIX_DEFMSTR_TYPE_LAST_DEFAULT;
AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_SRAM] =
u_avr32_hmatrix_scfg.scfg;
# ifdef AVR32_HMATRIX_SLAVE_EBI
// For the EBI HMATRIX slave, use last master as default.
u_avr32_hmatrix_scfg.scfg =
AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_EBI];
u_avr32_hmatrix_scfg.SCFG.defmstr_type =
AVR32_HMATRIX_DEFMSTR_TYPE_LAST_DEFAULT;
AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_EBI] =
u_avr32_hmatrix_scfg.scfg;
# endif
#endif
#ifdef AVR32_HMATRIX_MASTER_USBB_DMA
union {
unsigned long mcfg;
avr32_hmatrix_mcfg_t MCFG;
} u_avr32_hmatrix_mcfg;
// For the USBB DMA HMATRIX master, use infinite length burst.
u_avr32_hmatrix_mcfg.mcfg =
AVR32_HMATRIX.mcfg[AVR32_HMATRIX_MASTER_USBB_DMA];
u_avr32_hmatrix_mcfg.MCFG.ulbt =
AVR32_HMATRIX_ULBT_INFINITE;
AVR32_HMATRIX.mcfg[AVR32_HMATRIX_MASTER_USBB_DMA] =
u_avr32_hmatrix_mcfg.mcfg;
// For the USBB DPRAM HMATRIX slave, use the USBB DMA as fixed default master.
u_avr32_hmatrix_scfg.scfg =
AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_USBB_DPRAM];
u_avr32_hmatrix_scfg.SCFG.fixed_defmstr =
AVR32_HMATRIX_MASTER_USBB_DMA;
u_avr32_hmatrix_scfg.SCFG.defmstr_type =
AVR32_HMATRIX_DEFMSTR_TYPE_FIXED_DEFAULT;
AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_USBB_DPRAM] =
u_avr32_hmatrix_scfg.scfg;
#endif
#if (defined AT45DBX_MEM) && (AT45DBX_MEM == ENABLE)
at45dbx_init();
#endif
#if ((defined SD_MMC_0_MEM) && (SD_MMC_0_MEM == ENABLE)) \
|| ((defined SD_MMC_1_MEM) && (SD_MMC_1_MEM == ENABLE))
sd_mmc_init();
#endif
}
/**
* \brief Application entry point.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
uint8_t slot = 0;
sd_mmc_err_t err;
const usart_serial_options_t usart_serial_options = {
.baudrate = CONF_TEST_BAUDRATE,
.charlength = CONF_TEST_CHARLENGTH,
.paritytype = CONF_TEST_PARITY,
.stopbits = CONF_TEST_STOPBITS,
};
irq_initialize_vectors();
cpu_irq_enable();
sysclk_init();
board_init();
stdio_serial_init(CONF_TEST_USART, &usart_serial_options);
time_tick_init();
// Initialize SD MMC stack
sd_mmc_init();
printf("\x0C\n\r-- SD/MMC/SDIO Card Example --\n\r");
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
while (1) {
if (slot == sd_mmc_nb_slot()) {
slot = 0;
}
printf("Please plug an SD, MMC or SDIO card in slot %d.\n\r", slot+1);
// Wait for a card and ready
do {
err = sd_mmc_check(slot);
if ((SD_MMC_ERR_NO_CARD != err)
&& (SD_MMC_INIT_ONGOING != err)
&& (SD_MMC_OK != err)) {
printf("Card install FAILED\n\r");
printf("Please unplug and re-plug the card.\n\r");
while (SD_MMC_ERR_NO_CARD != sd_mmc_check(slot)) {
}
}
} while (SD_MMC_OK != err);
// Display basic card information
main_display_info_card(slot);
/* Test the card */
if (sd_mmc_get_type(slot) & CARD_TYPE_SDIO) {
// Test CIA of SDIO card
main_test_sdio(slot);
}
if (sd_mmc_get_type(slot) & (CARD_TYPE_SD | CARD_TYPE_MMC)) {
// SD/MMC Card R/W
main_test_memory(slot);
}
printf("Test finished, please unplugged the card.\n\r");
while (SD_MMC_OK == sd_mmc_check(slot)) {
}
slot++;
}
}
/**
* \brief Application entry point.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
char test_file_name[] = "0:sd_mmc_test.txt";
Ctrl_status status;
FRESULT res;
FATFS fs;
FIL file_object;
const usart_serial_options_t usart_serial_options = {
.baudrate = CONF_TEST_BAUDRATE,
.charlength = CONF_TEST_CHARLENGTH,
.paritytype = CONF_TEST_PARITY,
.stopbits = CONF_TEST_STOPBITS,
};
irq_initialize_vectors();
cpu_irq_enable();
sysclk_init();
board_init();
stdio_serial_init(CONF_TEST_USART, &usart_serial_options);
/* Initialize SD MMC stack */
sd_mmc_init();
printf("\x0C\n\r-- SD/MMC/SDIO Card Example on FatFs --\n\r");
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
while (1) {
printf("Please plug an SD, MMC or SDIO card in slot.\n\r");
/* Wait card present and ready */
do {
status = sd_mmc_test_unit_ready(0);
if (CTRL_FAIL == status) {
printf("Card install FAIL\n\r");
printf("Please unplug and re-plug the card.\n\r");
while (CTRL_NO_PRESENT != sd_mmc_check(0)) {
}
}
} while (CTRL_GOOD != status);
printf("Mount disk (f_mount)...\r\n");
memset(&fs, 0, sizeof(FATFS));
res = f_mount(LUN_ID_SD_MMC_0_MEM, &fs);
if (FR_INVALID_DRIVE == res) {
printf("[FAIL] res %d\r\n", res);
goto main_end_of_test;
}
printf("[OK]\r\n");
printf("Create a file (f_open)...\r\n");
test_file_name[0] = LUN_ID_SD_MMC_0_MEM + '0';
res = f_open(&file_object,
(char const *)test_file_name,
FA_CREATE_ALWAYS | FA_WRITE);
if (res != FR_OK) {
printf("[FAIL] res %d\r\n", res);
goto main_end_of_test;
}
printf("[OK]\r\n");
printf("Write to test file (f_puts)...\r\n");
if (0 == f_puts("Test SD/MMC stack\n", &file_object)) {
f_close(&file_object);
printf("[FAIL]\r\n");
goto main_end_of_test;
}
printf("[OK]\r\n");
f_close(&file_object);
printf("Test successfull.\n\r");
main_end_of_test:
printf("Please unplug the card.\n\r");
while (CTRL_NO_PRESENT != sd_mmc_check(0)) {
}
}
}
/*! \brief Main function. Execution starts here.
*/
int main(void)
{
irq_initialize_vectors();
cpu_irq_enable();
wdt_disable(WDT);
// Initialize the sleep manager
sleepmgr_init();
// Board initialization
sysclk_init();
init_board();
init_pwm();
init_i2c();
// Module initialization
init_module_peripherals_bp();
/* Initialize SD MMC stack */
delay_ms(200);
sd_mmc_init();
// Start USB stack to authorize VBus monitoring
udc_start();
// Init SCPI parser
console_init();
// Enable 12V
enable_12v();
while (true)
{
console_process();
if((get_ok_12v_status() == RETURN_OK) && (last_ok_12v_state == false))
{
set_user_led_colour(0, 100, 0);
last_ok_12v_state = true;
}
else if((get_ok_12v_status() == RETURN_NOK) && (last_ok_12v_state == true))
{
set_user_led_colour(0, 0, 0);
last_ok_12v_state = false;
}
// else if(get_sync_signal_status() == RETURN_OK)
// set_user_led_colour(0, 0, 100);
// else if(get_ok_12v_status() == RETURN_OK)
// set_user_led_colour(100, 0, 0);
// else
// set_user_led_colour(0, 0, 0);
if (main_b_msc_enable)
{
if (!udi_msc_process_trans())
{
//sleepmgr_enter_sleep();
}
}
else
{
//sleepmgr_enter_sleep();
}
}
}
/**
* \brief Show SD card status on the OLED screen.
*/
static void display_sd_info(void)
{
uint8_t card_check;
uint8_t sd_card_type;
uint8_t sd_card_version;
uint32_t sd_card_size;
uint8_t size[10];
// Is SD card present?
if (gpio_pin_is_low(SD_MMC_0_CD_GPIO) == false)
{
ssd1306_write_text("Please insert SD card...");
}
else
{
ssd1306_write_text("SD card information:");
sd_mmc_init();
card_check = sd_mmc_check(0);
while (card_check != SD_MMC_OK)
{
card_check = sd_mmc_check(0);
delay_ms(1);
}
if (card_check == SD_MMC_OK)
{
sd_card_type = sd_mmc_get_type(0);
sd_card_version = sd_mmc_get_version(0);
sd_card_size = sd_mmc_get_capacity(0);
ssd1306_set_page_address(1);
ssd1306_set_column_address(0);
// Card type
switch(sd_card_type)
{
case CARD_TYPE_SD:
ssd1306_write_text("- Type: Normal SD card");
break;
case CARD_TYPE_SDIO:
ssd1306_write_text("- Type: SDIO card");
break;
case CARD_TYPE_HC:
ssd1306_write_text("- Type: High Capacity card");
break;
case CARD_TYPE_SD_COMBO:
ssd1306_write_text("- Type: SDIO/Memory card");
break;
default:
ssd1306_write_text("- Type: unknown");
}
ssd1306_set_page_address(2);
ssd1306_set_column_address(0);
// SD card version
switch(sd_card_version)
{
case CARD_VER_SD_1_0:
ssd1306_write_text("- Version: 1.0x");
break;
case CARD_VER_SD_1_10:
ssd1306_write_text("- Version: 1.10");
break;
case CARD_VER_SD_2_0:
ssd1306_write_text("- Version: 2.00");
break;
case CARD_VER_SD_3_0:
ssd1306_write_text("- Version: 3.0x");
break;
default:
ssd1306_write_text("- Version: unknown");
}
ssd1306_set_page_address(3);
ssd1306_set_column_address(0);
sprintf(size, "- Total size: %lu KB", sd_card_size);
ssd1306_write_text(size);
}
}
}
/**
* \brief Check for valid firmware in SD card.
*/
static void check_valid_firmware(void)
{
/* Check if the application bin in SD card */
uint32_t i;
uint8_t card_check;
FRESULT res;
TCHAR path[3];
/* Init the path to "0:" */
path[0] = 0x0030;
path[1] = 0x003A;
path[2] = 0x0000;
/* Is SD card present? */
if (gpio_pin_is_low(SD_MMC_0_CD_GPIO) == false) {
return;
}
sd_mmc_init();
card_check = sd_mmc_check(0);
while (card_check != SD_MMC_OK) {
card_check = sd_mmc_check(0);
delay_ms(1);
}
/* Try to mount file system. */
memset(&fs, 0, sizeof(FATFS));
res = f_mount(LUN_ID_SD_MMC_0_MEM, &fs);
if (FR_INVALID_DRIVE == res) {
return;
}
/* Test if the disk is formatted */
res = f_opendir(&dir, path);
if (res != FR_OK) {
return;
}
for (i = 0; i < LANGUAGE_NUMBER; i++) {
/* Open the application bin file. */
res = f_open(&file_object, file_name_unicode[i],
(FA_OPEN_EXISTING | FA_READ));
if (res != FR_OK) {
continue;
}
/* Close the file*/
res = f_close(&file_object);
if (res != FR_OK) {
continue;
}
/* Set the firmware type */
firmware_type |= (0x01 << i);
}
if ((firmware_type & 0x1F) == 0) {
return;
}
/* Show switch info */
multi_language_show_switch_info();
/* Wait 6 seconds to show above info. */
delay_s(6);
/* Set the flag. */
valid_firmware_found = 1;
}
