/** * Copyright (c) 2016 - 2018, Nordic Semiconductor ASA * * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * 2. Redistributions in binary form, except as embedded into a Nordic * Semiconductor ASA integrated circuit in a product or a software update for * such product, must reproduce the above copyright notice, this list of * conditions and the following disclaimer in the documentation and/or other * materials provided with the distribution. * * 3. Neither the name of Nordic Semiconductor ASA nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * 4. This software, with or without modification, must only be used with a * Nordic Semiconductor ASA integrated circuit. * * 5. Any software provided in binary form under this license must not be reverse * engineered, decompiled, modified and/or disassembled. * * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ /** @file * @defgroup fatfs_example_main main.c * @{ * @ingroup fatfs_example * @brief FATFS Example Application main file. * * This file contains the source code for a sample application using FAT filesystem and SD card library. * */ #include "bsp.h" #include "diskio_blkdev.h" #include "ff.h" #include "nrf.h" #include "nrf_block_dev_sdc.h" #include "app_usbd.h" #include "app_usbd_cdc_acm.h" #include "app_usbd_core.h" #include "app_usbd_serial_num.h" #include "app_usbd_string_desc.h" #include "nrf_drv_usbd.h" #include "nrf_gpio.h" #include "nrf_drv_clock.h" #include "nrf_drv_gpiote.h" #include "nrf_log.h" #include "nrf_log_ctrl.h" #include "nrf_log_default_backends.h" #define SDC_SCK_PIN NRF_GPIO_PIN_MAP(1, 13) ///< SDC serial clock (SCK) pin. #define SDC_MOSI_PIN NRF_GPIO_PIN_MAP(1, 15) ///< SDC serial data in (DI) pin. #define SDC_MISO_PIN NRF_GPIO_PIN_MAP(0, 2) ///< SDC serial data out (DO) pin. #define SDC_CS_PIN NRF_GPIO_PIN_MAP(1, 10) ///< SDC chip select (CS) pin. // #define BUTTON_1 NRF_GPIO_PIN_MAP(1, 6) #define TEST_TIME_DELAY NRF_GPIO_PIN_MAP(0, 13) #define FILE_NAME "NORDIC.TXT" #define TEST_STRING "Hello world." #define LED_USB_RESUME (BSP_BOARD_LED_0) #define LED_CDC_ACM_OPEN (BSP_BOARD_LED_1) #define LED_CDC_ACM_RX (BSP_BOARD_LED_2) #define LED_CDC_ACM_TX (BSP_BOARD_LED_3) #define BTN_CDC_DATA_SEND 0 #define BTN_CDC_NOTIFY_SEND 1 #ifndef USBD_POWER_DETECTION #define USBD_POWER_DETECTION true #endif // UARTUI static void cdc_acm_user_ev_handler(app_usbd_class_inst_t const *p_inst, app_usbd_cdc_acm_user_event_t event); #define CDC_ACM_COMM_INTERFACE 0 #define CDC_ACM_COMM_EPIN NRF_DRV_USBD_EPIN2 #define CDC_ACM_DATA_INTERFACE 1 #define CDC_ACM_DATA_EPIN NRF_DRV_USBD_EPIN1 #define CDC_ACM_DATA_EPOUT NRF_DRV_USBD_EPOUT1 #define READ_SIZE 64 static char m_rx_buffer[READ_SIZE]; static char m_tx_buffer[READ_SIZE]; static void fatfs_example(); /** * @brief CDC_ACM class instance * */ APP_USBD_CDC_ACM_GLOBAL_DEF(m_app_cdc_acm, cdc_acm_user_ev_handler, CDC_ACM_COMM_INTERFACE, CDC_ACM_DATA_INTERFACE, CDC_ACM_COMM_EPIN, CDC_ACM_DATA_EPIN, CDC_ACM_DATA_EPOUT, APP_USBD_CDC_COMM_PROTOCOL_AT_V250); /** * @brief SDC block device definition * */ NRF_BLOCK_DEV_SDC_DEFINE( m_block_dev_sdc, NRF_BLOCK_DEV_SDC_CONFIG( SDC_SECTOR_SIZE, APP_SDCARD_CONFIG(SDC_MOSI_PIN, SDC_MISO_PIN, SDC_SCK_PIN, SDC_CS_PIN)), NFR_BLOCK_DEV_INFO_CONFIG("Nordic", "SDC", "1.00")); static void cdc_acm_user_ev_handler(app_usbd_class_inst_t const *p_inst, app_usbd_cdc_acm_user_event_t event) { app_usbd_cdc_acm_t const *p_cdc_acm = app_usbd_cdc_acm_class_get(p_inst); switch (event) { case APP_USBD_CDC_ACM_USER_EVT_PORT_OPEN: { bsp_board_led_on(LED_CDC_ACM_OPEN); /*Setup first transfer*/ ret_code_t ret = app_usbd_cdc_acm_read(&m_app_cdc_acm, m_rx_buffer, READ_SIZE); UNUSED_VARIABLE(ret); break; } case APP_USBD_CDC_ACM_USER_EVT_PORT_CLOSE: bsp_board_led_off(LED_CDC_ACM_OPEN); break; case APP_USBD_CDC_ACM_USER_EVT_TX_DONE: // nrfx_gpiote_out_clear(TEST_TIME_DELAY); bsp_board_led_invert(LED_CDC_ACM_TX); break; case APP_USBD_CDC_ACM_USER_EVT_RX_DONE: { ret_code_t ret; // NRF_LOG_INFO("Bytes waiting: %d", app_usbd_cdc_acm_bytes_stored(p_cdc_acm)); app_usbd_cdc_acm_bytes_stored(&m_app_cdc_acm); do { /*Get amount of data transfered*/ size_t size = app_usbd_cdc_acm_rx_size(&m_app_cdc_acm); // NRF_LOG_INFO("RX: size: %lu char: %c", size, m_rx_buffer[0]); /* Fetch data until internal buffer is empty */ ret = app_usbd_cdc_acm_read(&m_app_cdc_acm, m_rx_buffer, READ_SIZE); } while (ret == NRF_SUCCESS); memcpy(m_tx_buffer, m_rx_buffer, READ_SIZE); app_usbd_cdc_acm_write(&m_app_cdc_acm, m_tx_buffer, READ_SIZE); // bsp_board_led_invert(LED_CDC_ACM_RX); break; } default: break; } } static void usbd_user_ev_handler(app_usbd_event_type_t event) { switch (event) { case APP_USBD_EVT_DRV_SUSPEND: bsp_board_led_off(LED_USB_RESUME); break; case APP_USBD_EVT_DRV_RESUME: bsp_board_led_on(LED_USB_RESUME); break; case APP_USBD_EVT_STARTED: break; case APP_USBD_EVT_STOPPED: app_usbd_disable(); bsp_board_leds_off(); break; case APP_USBD_EVT_POWER_DETECTED: // NRF_LOG_INFO("USB power detected"); if (!nrf_drv_usbd_is_enabled()) { app_usbd_enable(); } break; case APP_USBD_EVT_POWER_REMOVED: // NRF_LOG_INFO("USB power removed"); app_usbd_stop(); break; case APP_USBD_EVT_POWER_READY: // NRF_LOG_INFO("USB ready"); app_usbd_start(); break; default: break; } } /// end for USB CDC void clocks_start(void) { NRF_CLOCK->EVENTS_HFCLKSTARTED = 0; NRF_CLOCK->TASKS_HFCLKSTART = 1; while (NRF_CLOCK->EVENTS_HFCLKSTARTED == 0) ; } //-----------------------GPIO----------------------------- static void in_pin_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action) { if (pin == BUTTON_1) { // bsp_board_led_invert(LED_CDC_ACM_RX); fatfs_example(); } else { } } void gpio_init(void) { bsp_board_init(BSP_INIT_LEDS); ret_code_t err_code; err_code = nrf_drv_gpiote_init(); // APP_ERROR_CHECK(err_code); nrf_drv_gpiote_in_config_t in_config = GPIOTE_CONFIG_IN_SENSE_HITOLO(false); in_config.pull = NRF_GPIO_PIN_PULLUP; err_code = nrf_drv_gpiote_in_init(BUTTON_1, &in_config, in_pin_handler); APP_ERROR_CHECK(err_code); nrf_drv_gpiote_in_event_enable(BUTTON_1, true); } /** * @brief Function for demonstrating FAFTS usage. */ static FATFS fs; static DIR dir; static FILINFO fno; static FIL file; static void fatfs_init() { uint32_t bytes_written; FRESULT ff_result; DSTATUS disk_state = STA_NOINIT; // Initialize FATFS disk I/O interface by providing the block device. static diskio_blkdev_t drives[] = { DISKIO_BLOCKDEV_CONFIG(NRF_BLOCKDEV_BASE_ADDR(m_block_dev_sdc, block_dev), NULL)}; diskio_blockdev_register(drives, ARRAY_SIZE(drives)); NRF_LOG_INFO("Initializing disk 0 (SDC)..."); for (uint32_t retries = 3; retries && disk_state; --retries) { disk_state = disk_initialize(0); } if (disk_state) { NRF_LOG_INFO("Disk initialization failed."); return; } uint32_t blocks_per_mb = (1024uL * 1024uL) / m_block_dev_sdc.block_dev.p_ops->geometry(&m_block_dev_sdc.block_dev)->blk_size; uint32_t capacity = m_block_dev_sdc.block_dev.p_ops->geometry(&m_block_dev_sdc.block_dev)->blk_count / blocks_per_mb; NRF_LOG_INFO("Capacity: %d MB", capacity); NRF_LOG_INFO("Mounting volume..."); ff_result = f_mount(&fs, "", 1); if (ff_result) { bsp_board_led_invert(1); NRF_LOG_INFO("Mount failed."); return; } NRF_LOG_INFO("\r\n Listing directory: /"); ff_result = f_opendir(&dir, "/"); if (ff_result) { NRF_LOG_INFO("Directory listing failed!"); return; } do { ff_result = f_readdir(&dir, &fno); if (ff_result != FR_OK) { NRF_LOG_INFO("Directory read failed."); return; } if (fno.fname[0]) { if (fno.fattrib & AM_DIR) { NRF_LOG_RAW_INFO(" <DIR> %s", (uint32_t)fno.fname); } else { NRF_LOG_RAW_INFO("%9lu %s", fno.fsize, (uint32_t)fno.fname); } } } while (fno.fname[0]); NRF_LOG_RAW_INFO(""); } static void fatfs_example() { uint32_t bytes_written; FRESULT ff_result; NRF_LOG_INFO("Writing to file " FILE_NAME "..."); ff_result = f_open(&file, FILE_NAME, FA_READ | FA_WRITE | FA_OPEN_APPEND); if (ff_result != FR_OK) { NRF_LOG_INFO("Unable to open or create file: " FILE_NAME "."); sprintf(m_tx_buffer,"ff_result = %d", ff_result); app_usbd_cdc_acm_write(&m_app_cdc_acm, m_tx_buffer, sizeof(m_tx_buffer)); bsp_board_led_invert(LED_CDC_ACM_TX); return; } ff_result = f_write(&file, TEST_STRING, sizeof(TEST_STRING) - 1, (UINT *)&bytes_written); if (ff_result != FR_OK) { NRF_LOG_INFO("Write failed\r\n."); } else { NRF_LOG_INFO("%d bytes written.", bytes_written); } (void)f_close(&file); return; } /** * @brief Function for main application entry. */ int main(void) { static const app_usbd_config_t usbd_config = { .ev_state_proc = usbd_user_ev_handler}; nrf_drv_clock_init(); clocks_start(); gpio_init(); APP_ERROR_CHECK(NRF_LOG_INIT(NULL)); NRF_LOG_DEFAULT_BACKENDS_INIT(); NRF_LOG_INFO("FATFS example started."); app_usbd_serial_num_generate(); app_usbd_init(&usbd_config); app_usbd_class_inst_t const *class_cdc_acm = app_usbd_cdc_acm_class_inst_get(&m_app_cdc_acm); app_usbd_class_append(class_cdc_acm); if (USBD_POWER_DETECTION) { app_usbd_power_events_enable(); } else { app_usbd_enable(); app_usbd_start(); } fatfs_init(); while (true) { __WFE(); } } /** @} */id my code ,please help me