void DMA_init(void)
{
spi_dma_sem = 0;
/* Initialize eDMA & DMAMUX */
g_edmaUserConfig.chnArbitration = kEDMAChnArbitrationRoundrobin;
g_edmaUserConfig.notHaltOnError = false;
EDMA_DRV_Init(&g_edmaState, &g_edmaUserConfig);
}
void Components_Init(void)
{
/*! DMA_controller Auto initialization start */
EDMA_DRV_Init(&DMA_controller_State,&DMA_controller_InitConfig0);
/*! DMA_controller Auto initialization end */
/*! OLED_SPI Auto initialization start */
DSPI_DRV_EdmaMasterInit(FSL_OLED_SPI, &OLED_SPI_MasterState, &OLED_SPI_MasterConfig, &OLED_SPI_dmaTcd);
DSPI_DRV_EdmaMasterConfigureBus(FSL_OLED_SPI, &OLED_SPI_BusConfig, &OLED_SPI_calculatedBaudRate);
/*! OLED_SPI Auto initialization end */
/*! FLASH_SPI Auto initialization start */
DSPI_DRV_EdmaMasterInit(FSL_FLASH_SPI, &FLASH_SPI_MasterState, &FLASH_SPI_MasterConfig, &FLASH_SPI_dmaTcd);
DSPI_DRV_EdmaMasterConfigureBus(FSL_FLASH_SPI, &FLASH_SPI_BusConfig, &FLASH_SPI_calculatedBaudRate);
/*! FLASH_SPI Auto initialization end */
/*! GPIO Auto initialization start */
GPIO_DRV_Init(NULL,NULL);
/*! GPIO Auto initialization end */
/*! KW40_UART Auto initialization start */
UART_DRV_Init(FSL_KW40_UART,&KW40_UART_State,&KW40_UART_InitConfig0);
/*! KW40_UART Auto initialization end */
/*! DEBUG_UART Auto initialization start */
UART_DRV_Init(FSL_DEBUG_UART,&DEBUG_UART_State,&DEBUG_UART_InitConfig0);
/*! DEBUG_UART Auto initialization end */
/*! FS_I2C Auto initialization start */
I2C_DRV_MasterInit(FSL_FS_I2C, &FS_I2C_MasterState);
I2C_DRV_MasterSetBaudRate(FSL_FS_I2C, &FS_I2C_MasterConfig);
/*! FS_I2C Auto initialization end */
/*! NFS_I2C Auto initialization start */
I2C_DRV_MasterInit(FSL_NFS_I2C, &NFS_I2C_MasterState);
I2C_DRV_MasterSetBaudRate(FSL_NFS_I2C, &NFS_I2C_MasterConfig);
/*! NFS_I2C Auto initialization end */
/*! PWR_Manager Auto initialization start */
// POWER_SYS_Init(powerConfigsArr, 2U, NULL , 0U);
INT_SYS_EnableIRQ(LLWU_IRQn);
/*! PWR_Manager Auto initialization end */
/*! CLOCK Auto initialization start */
RTC_DRV_Init(FSL_CLOCK);
/*! CLOCK Auto initialization end */
/*! BATTERY_ADC Auto initialization start */
ADC16_DRV_Init(FSL_BATTERY_ADC, &BATTERY_ADC_InitConfig);
ADC16_DRV_ConfigConvChn(FSL_BATTERY_ADC, 0U, &BATTERY_ADC_ChnConfig);
/*! BATTERY_ADC Auto initialization end */
/*! sensor_timer Auto initialization start */
LPTMR_DRV_Init(FSL_SENSOR_TIMER,&sensor_timer_State,&sensor_timer_cfg);
/*! sensor_timer Auto initialization end */
}
OSStatus internal_uart_init( mico_uart_t uart, const mico_uart_config_t* config, ring_buffer_t* optional_rx_buffer )
{
#ifndef NO_MICO_RTOS
mico_rtos_init_semaphore(&uart_interfaces[uart].tx_complete, 1);
mico_rtos_init_semaphore(&uart_interfaces[uart].rx_complete, 1);
#else
uart_interfaces[uart].tx_complete = false;
uart_interfaces[uart].rx_complete = false;
#endif
MicoMcuPowerSaveConfig(false);
/* Configure the UART TX/RX pins */
configure_uart_pins(BOARD_APP_UART_INSTANCE);
#if ADD_OS_CODE
#ifndef NO_MICO_RTOS
if(config->flags & UART_WAKEUP_ENABLE){
current_uart = uart;
mico_rtos_init_semaphore( &uart_interfaces[uart].sem_wakeup, 1 );
mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "UART_WAKEUP", thread_wakeup, 0x100, ¤t_uart);
}
#endif
#endif
//OSA_Init();
#ifdef UART_IRQ_APP
/****************************************************************/
uartConfig.baudRate = 115200;
uartConfig.bitCountPerChar = kUart8BitsPerChar;
uartConfig.parityMode = kUartParityDisabled;
uartConfig.stopBitCount = kUartOneStopBit;
/***************************************************************/
UART_DRV_Init(BOARD_APP_UART_INSTANCE, &uartState, &uartConfig);
#else
userConfig_app.chnArbitration = kEDMAChnArbitrationRoundrobin;
userConfig_app.notHaltOnError = false;
uartConfig_app.bitCountPerChar = kUart8BitsPerChar;
uartConfig_app.parityMode = kUartParityDisabled;
uartConfig_app.stopBitCount = kUartOneStopBit;
uartConfig_app.baudRate = 115200;
EDMA_DRV_Init(&state_app, &userConfig_app);
UART_DRV_EdmaInit(BOARD_APP_UART_INSTANCE, &uartStateEdma_app, &uartConfig_app);
INT_SYS_EnableIRQ(g_uartRxTxIrqId[BOARD_APP_UART_INSTANCE]);
#endif
#if RING_BUFF_ON
if (optional_rx_buffer != NULL)
{
// Note that the ring_buffer should've been initialised first
uart_interfaces[uart].rx_buffer = optional_rx_buffer;
uart_interfaces[uart].rx_size = 0;
platform_uart_receive_bytes( uart, optional_rx_buffer->buffer, optional_rx_buffer->size, 0 );
}
#endif
MicoMcuPowerSaveConfig(true);
return kNoErr;
}
/*!
* @brief Check send/receive non blocking with DMA
*
*/
int main(void)
{
uint8_t rxChar = 0, txChar = 0;
uint32_t byteCountBuff = 0;
// Config the eDMA driver
edma_user_config_t userConfig = {
.chnArbitration = kEDMAChnArbitrationRoundrobin,
.notHaltOnError = false
};
// Config the UART driver
lpuart_edma_user_config_t lpuartConfig = {
.clockSource = BOARD_LPUART_CLOCK_SOURCE,
.bitCountPerChar = kLpuart8BitsPerChar,
.parityMode = kLpuartParityDisabled,
.stopBitCount = kLpuartOneStopBit,
.baudRate = BOARD_DEBUG_UART_BAUD
};
// Store runtime state structure for the eDMA driver
edma_state_t state;
// Store runtime state structure for LPUART driver with EDMA
lpuart_edma_state_t lpuartStateDma;
// Enable clock for PORTs, setup board clock source
hardware_init();
// Initialize EDMA module for LPUART
EDMA_DRV_Init(&state, &userConfig);
LPUART_DRV_EdmaInit(BOARD_DEBUG_UART_INSTANCE, &lpuartStateDma, &lpuartConfig);
// Send data block to terminal by non blocking manner
byteCountBuff = sizeof(buffStart);
LPUART_DRV_EdmaSendData(BOARD_DEBUG_UART_INSTANCE, buffStart, byteCountBuff);
while (kStatus_LPUART_TxBusy == LPUART_DRV_EdmaGetTransmitStatus(BOARD_DEBUG_UART_INSTANCE, NULL)){}
// Inform user of what to do
byteCountBuff = sizeof(bufferData1);
LPUART_DRV_EdmaSendData(BOARD_DEBUG_UART_INSTANCE, bufferData1, byteCountBuff);
while (kStatus_LPUART_TxBusy == LPUART_DRV_EdmaGetTransmitStatus(BOARD_DEBUG_UART_INSTANCE, NULL)){}
// Send/receive non blocking function
while(true)
{
rxChar = 0;
// Wait to receive input data
LPUART_DRV_EdmaReceiveData(BOARD_DEBUG_UART_INSTANCE, &rxChar, 1u);
while (kStatus_LPUART_RxBusy == LPUART_DRV_EdmaGetReceiveStatus(BOARD_DEBUG_UART_INSTANCE, NULL)){}
txChar = rxChar;
// Send any character that received
LPUART_DRV_EdmaSendData(BOARD_DEBUG_UART_INSTANCE, &txChar, 1u);
}
}
void Components_Init(void)
{
I2C_DRV_MasterInit(FSL_FS_I2C, &FS_I2C_MasterState);
I2C_DRV_MasterSetBaudRate(FSL_FS_I2C, &FS_I2C_MasterConfig);
EDMA_DRV_Init( &DMA_controller_State, &DMA_controller_InitConfig0 );
DSPI_DRV_EdmaMasterInit(FSL_OLED_SPI, &OLED_SPI_MasterState, &OLED_SPI_MasterConfig, &OLED_SPI_dmaTcd);
DSPI_DRV_EdmaMasterConfigureBus(FSL_OLED_SPI, &OLED_SPI_BusConfig, &OLED_SPI_calculatedBaudRate);
OLED_Init( &oledModule, &oledSettings );
}
OSStatus host_platform_bus_init( void )
{
edma_user_config_t g_edmaUserConfig;
/* Create a semephore to check for completed eDMA transfers. */
mico_rtos_init_semaphore(&spi_transfer_finished_semaphore, 1);
MCU_CLOCKS_NEEDED();
configure_spi_pins(0); // initlize spi0 GPIO
PORT_HAL_SetMuxMode(PORTD_BASE,0u,kPortMuxAsGpio); // configure CS as gpio, use software configure CS.
GPIO_DRV_OutputPinInit(&spiCsPin[0]);
SPI0_CS_DISABLE;
/* Initialize eDMA & DMAMUX */
g_edmaUserConfig.chnArbitration = kEDMAChnArbitrationRoundrobin;
g_edmaUserConfig.notHaltOnError = false;
EDMA_DRV_Init(&g_edmaState, &g_edmaUserConfig);
/* DSPI Master Configuration */
dspi_edma_master_setup(&dspiMasterState, 0, 10000000, 8);
MCU_CLOCKS_NOT_NEEDED();
dmaSPITX.dmaChanNum = DMA_CH0;
dmaSPITX.dmaCh = &dmaCh0;
dmaSPITX.type = kEDMAMemoryToPeripheral;
dmaSPITX.chSource = kDmaRequestMux0SPI0Tx;
dmaSPITX.srcAddr = (uint32_t)NULL;
dmaSPITX.destAddr = (uint32_t)&SPI0->PUSHR;
dmaSPITX.length = 0;
dmaSPITX.size = 4;
dmaSPITX.watermark = 4;
dmaSPITX.period = 0x01U;
dmaSPITX.dmaCallBack = stop_edma_loop;
dmaSPIRX.dmaChanNum = DMA_CH1;
dmaSPIRX.dmaCh = &dmaCh1;
dmaSPIRX.type = kEDMAPeripheralToMemory;
dmaSPIRX.chSource = kDmaRequestMux0SPI0Rx;
dmaSPIRX.srcAddr = (uint32_t)&SPI0->POPR;
dmaSPIRX.destAddr = (uint32_t)NULL;
dmaSPIRX.length = 0;
dmaSPIRX.size = 1;
dmaSPIRX.watermark = 1;
dmaSPIRX.period = 0x01U;
dmaSPIRX.dmaCallBack = stop_edma_loop_putsem;
dmaSPIRX.dmaChStcd = (edma_software_tcd_t *)mem_align(2 * sizeof(edma_software_tcd_t) * dmaSPIRX.period, 32);
spi_status_print(SPI0);
return kNoErr;
}
/*!
* @brief DSPI slave EDMA - blocking.
*
* This function sends back received buffer from master through DSPI interface.
*/
int main(void)
{
uint32_t i;
dspi_status_t dspiResult;
// Set up and init the slave.
edma_state_t dmaState;
edma_user_config_t dmaUserConfig;
dspi_edma_slave_state_t edmaSlaveState;
dspi_edma_slave_user_config_t edmaSlaveConfig;
// Init hardware
hardware_init();
// Init OSA layer, used in DSPI_DRV_MasterTransferBlocking.
OSA_Init();
// Initialze eDMA driver.
dmaUserConfig.chnArbitration = kEDMAChnArbitrationRoundrobin;
EDMA_DRV_Init(&dmaState, &dmaUserConfig);
// Print a note.
PRINTF("\r\n DSPI board to board EMDA blocking example");
PRINTF("\r\n This example run on instance %d ", (uint32_t)DSPI_SLAVE_INSTANCE);
PRINTF("\r\n Be sure DSPI%d-DSPI%d are connected \r\n",
(uint32_t)DSPI_SLAVE_INSTANCE,(uint32_t)DSPI_SLAVE_INSTANCE);
// Setup the configuration and get user options.
edmaSlaveConfig.dataConfig.bitsPerFrame = 8;
edmaSlaveConfig.dataConfig.clkPhase = kDspiClockPhase_FirstEdge;
edmaSlaveConfig.dataConfig.clkPolarity = kDspiClockPolarity_ActiveHigh;
edmaSlaveConfig.dummyPattern = 0;
// Initialize slave driver.
dspiResult = DSPI_DRV_EdmaSlaveInit(DSPI_SLAVE_INSTANCE,
&edmaSlaveState,
&edmaSlaveConfig);
if (dspiResult != kStatus_DSPI_Success)
{
PRINTF("\r\nERROR: Can not initialize slave driver\r\n");
return -1;
}
while(1)
{
PRINTF("\r\n Slave test running...\r\n");
// Reset the receive buffer.
for (i = 0; i < TRANSFER_SIZE; i++)
{
receiveBuffer[i] = 0;
}
// Receive the data.
dspiResult = DSPI_DRV_EdmaSlaveTransferBlocking(DSPI_SLAVE_INSTANCE,
NULL,
receiveBuffer,
TRANSFER_SIZE,
SLAVE_TRANSFER_TIMEOUT);
if (dspiResult != kStatus_DSPI_Success)
{
PRINTF("\r\nERROR: transfer error \r\n");
return -1;
}
// Send the data back to master.
dspiResult = DSPI_DRV_EdmaSlaveTransferBlocking(DSPI_SLAVE_INSTANCE,
receiveBuffer,
NULL,
TRANSFER_SIZE,
SLAVE_TRANSFER_TIMEOUT);
if (dspiResult != kStatus_DSPI_Success)
{
PRINTF("\r\nERROR: transfer error \r\n");
return -1;
}
// Print out receive buffer.
PRINTF("\r\n Slave receive:");
for (i = 0; i < TRANSFER_SIZE; i++)
{
// Print 16 numbers in a line.
if ((i & 0x0F) == 0)
{
PRINTF("\r\n ");
}
PRINTF(" %02X", receiveBuffer[i]);
}
}
}
