/*!
* @brief Main function.
*/
int main(void)
{
struct netif fsl_netif0;
ip_addr_t fsl_netif0_ipaddr, fsl_netif0_netmask, fsl_netif0_gw;
MPU_Type *base = MPU;
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
/* Disable MPU. */
base->CESR &= ~MPU_CESR_VLD_MASK;
lwip_init();
IP4_ADDR(&fsl_netif0_ipaddr, configIP_ADDR0, configIP_ADDR1, configIP_ADDR2, configIP_ADDR3);
IP4_ADDR(&fsl_netif0_netmask, configNET_MASK0, configNET_MASK1, configNET_MASK2, configNET_MASK3);
IP4_ADDR(&fsl_netif0_gw, 192, 168, 1, 9);
netif_add(&fsl_netif0, &fsl_netif0_ipaddr, &fsl_netif0_netmask, &fsl_netif0_gw, NULL, ethernetif_init,
ethernet_input);
netif_set_default(&fsl_netif0);
netif_set_up(&fsl_netif0);
udp_echo_init();
for (;;)
{
}
}
int main(void)
{
gpio_pin_config_t config;
BOARD_InitPins();
BOARD_BootClockHSRUN();
BOARD_InitDebugConsole();
/* Enable USB Host VBUS */
config.outputLogic = 1;
config.pinDirection = kGPIO_DigitalOutput;
GPIO_PinInit(GPIOC, 9, &config);
APP_init();
while (1)
{
#if ((defined USB_HOST_CONFIG_KHCI) && (USB_HOST_CONFIG_KHCI))
USB_HostKhciTaskFunction(g_hostHandle);
#endif
#if ((defined USB_HOST_CONFIG_EHCI) && (USB_HOST_CONFIG_EHCI))
USB_HostEhciTaskFunction(g_hostHandle);
#endif
USB_HosCdcTask(&g_cdc);
}
}
int main(void)
{
uint32_t i = 0;
uint8_t err = 0;
spi_transfer_t xfer = {0};
spi_slave_config_t userConfig;
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
PRINTF("\n\rSlave is working....\n\r");
/*
* userConfig.polarity = kSPI_ClockPolarityActiveHigh;
* userConfig.phase = kSPI_ClockPhaseFirstEdge;
* userConfig.direction = kSPI_MsbFirst;
* userConfig.enableStopInWaitMode = false;
* userConfig.dataMode = kSPI_8BitMode;
* userConfig.txWatermark = kSPI_TxFifoOneHalfEmpty;
* userConfig.rxWatermark = kSPI_RxFifoOneHalfFull;
*/
SPI_SlaveGetDefaultConfig(&userConfig);
SPI_SlaveInit(EXAMPLE_SPI_SLAVE, &userConfig);
SPI_SlaveTransferCreateHandle(EXAMPLE_SPI_SLAVE, &handle, slaveCallback, NULL);
for (i = 0; i < 64; i++)
{
sendBuff[i] = i;
}
/* receive data from master */
xfer.txData = sendBuff;
xfer.rxData = buff;
xfer.dataSize = BUFFER_SIZE;
SPI_SlaveTransferNonBlocking(EXAMPLE_SPI_SLAVE, &handle, &xfer);
while (slaveFinished != true)
{
}
for (i = 0; i < BUFFER_SIZE; i++)
{
if (buff[i] != i)
{
PRINTF("\n\rThe %d number is wrong! It is %dn\r", i, buff[i]);
err++;
}
}
PRINTF("\r\n");
if (err == 0)
{
PRINTF("Succeed!\n\r");
}
while (1)
{
}
}
/*!
* @brief Main function
*/
int main(void)
{
uint32_t currentCounter = 0U;
lptmr_config_t lptmrConfig;
LED_INIT();
/* Board pin, clock, debug console init */
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
/* Configure LPTMR */
/*
* lptmrConfig.timerMode = kLPTMR_TimerModeTimeCounter;
* lptmrConfig.pinSelect = kLPTMR_PinSelectInput_0;
* lptmrConfig.pinPolarity = kLPTMR_PinPolarityActiveHigh;
* lptmrConfig.enableFreeRunning = false;
* lptmrConfig.bypassPrescaler = true;
* lptmrConfig.prescalerClockSource = kLPTMR_PrescalerClock_1;
* lptmrConfig.value = kLPTMR_Prescale_Glitch_0;
*/
LPTMR_GetDefaultConfig(&lptmrConfig);
/* Initialize the LPTMR */
LPTMR_Init(LPTMR0, &lptmrConfig);
/* Set timer period */
LPTMR_SetTimerPeriod(LPTMR0, USEC_TO_COUNT(1000000U, LPTMR_SOURCE_CLOCK));
/* Enable timer interrupt */
LPTMR_EnableInterrupts(LPTMR0, kLPTMR_TimerInterruptEnable);
/* Enable at the NVIC */
EnableIRQ(LPTMR0_IRQn);
PRINTF("Low Power Timer Example\r\n");
/* Start counting */
LPTMR_StartTimer(LPTMR0);
while (1)
{
if (currentCounter != lptmrCounter)
{
currentCounter = lptmrCounter;
PRINTF("LPTMR interrupt No.%d \r\n", currentCounter);
}
}
}
/*!
* @brief Main function
*/
int main(void)
{
/* Structure of initialize PIT */
pit_config_t pitConfig;
/* Initialize and enable LED */
LED_INIT();
/* Board pin, clock, debug console init */
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
/*
* pitConfig.enableRunInDebug = false;
*/
PIT_GetDefaultConfig(&pitConfig);
/* Init pit module */
PIT_Init(PIT, &pitConfig);
/* Set timer period for channel 0 */
PIT_SetTimerPeriod(PIT, kPIT_Chnl_0, USEC_TO_COUNT(1000000U, PIT_SOURCE_CLOCK));
/* Enable timer interrupts for channel 0 */
PIT_EnableInterrupts(PIT, kPIT_Chnl_0, kPIT_TimerInterruptEnable);
/* Enable at the NVIC */
EnableIRQ(PIT_IRQ_ID);
/* Start channel 0 */
PRINTF("\r\nStarting channel No.0 ...");
PIT_StartTimer(PIT, kPIT_Chnl_0);
while (true)
{
/* Check whether occur interupt and toggle LED */
if (true == pitIsrFlag)
{
PRINTF("\r\n Channel No.0 interrupt is occured !");
LED_TOGGLE();
pitIsrFlag = false;
}
}
}
int main(void) {
int N;
int32_t dt_micros=0;
BOARD_InitPins();
//BOARD_BootClockRUN(); //120 MHz
BOARD_BootClockHSRUN(); //180MHz
BOARD_InitDebugConsole();
initMicros();
PRINTF("FIR/FFT Benchmarking...\r\n");
PRINTF(" : System Clock = %i Hz\r\n",CLOCK_GetFreq(kCLOCK_CoreSysClk));
//PRINTF(" : LPTMR Source Clock = %i Hz\r\n", LPTMR_CLOCK_HZ);
//PRINTF(" : micros per tick = %4.1f\r\n", millis_per_tic*1000);
//loop forever
N = MAX_N;
int N_LOOP = 0;
for (;;) {
if (N_LOOP < 4) {
//do the processing
#if (OPERATION_TO_DO == DO_NAIVE_FIR)
dt_micros = naive_fir_func(N,N_TRIALS);
#elif (OPERATION_TO_DO == DO_KISS_FFT)
dt_micros = kiss_fft_func(N,N_TRIALS);
#elif (OPERATION_TO_DO == DO_ARM_FFT)
dt_micros = arm_fft_func(N,N_TRIALS);
#endif
//report the timing
PRINTF("%s: N = %i\tin %6.1f usec per operation\r\n",alg_name,N,((float)dt_micros)/((float)N_TRIALS));
//prepare for next step
N = N/2;
if (N < 8) {
N = MAX_N;
N_LOOP++;
}
}
}
return 0;
}
int main(void)
{
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
USB_HostApplicationInit();
while (1)
{
#if ((defined USB_HOST_CONFIG_KHCI) && (USB_HOST_CONFIG_KHCI))
USB_HostKhciTaskFunction(g_HostHandle);
#endif /* USB_HOST_CONFIG_KHCI */
#if ((defined USB_HOST_CONFIG_EHCI) && (USB_HOST_CONFIG_EHCI))
USB_HostEhciTaskFunction(g_HostHandle);
#endif /* USB_HOST_CONFIG_EHCI */
USB_HostHidGenericTask(&g_HostHidGeneric);
}
}
int main(void)
{
BOARD_InitPins();
BOARD_BootClockHSRUN();
BOARD_InitDebugConsole();
USB_HostApplicationInit();
while (1U)
{
#if ((defined USB_HOST_CONFIG_KHCI) && (USB_HOST_CONFIG_KHCI))
USB_HostKhciTaskFunction(hostHandle);
#endif
#if ((defined USB_HOST_CONFIG_EHCI) && (USB_HOST_CONFIG_EHCI))
USB_HostEhciTaskFunction(hostHandle);
#endif
HOST_PhdcManagerTask(&g_phdcManagerInstance);
}
}
/*!
* @brief Main function
*/
int main(void)
{
dac_config_t dacConfigStruct;
uint32_t dacValue;
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
PRINTF("\r\nDAC basic Example.\r\n");
/* Configure the DAC. */
/*
* dacConfigStruct.referenceVoltageSource = kDAC_ReferenceVoltageSourceVref2;
* dacConfigStruct.enableLowPowerMode = false;
*/
DAC_GetDefaultConfig(&dacConfigStruct);
DAC_Init(DEMO_DAC_INSTANCE, &dacConfigStruct);
DAC_Enable(DEMO_DAC_INSTANCE, true);
DAC_SetBufferReadPointer(DEMO_DAC_INSTANCE, 0U); /* Make sure the read pointer to the start. */
/*
* The buffer is not enabled, so the read pointer can not move automatically. However, the buffer's read pointer
* and itemss can be written manually by user.
*/
while (1)
{
PRINTF("\r\nPlease input a value (0 - 4095) to output with DAC: ");
SCANF("%d", &dacValue);
PRINTF("\r\nInput value is %d\r\n", dacValue);
if (dacValue > 0xFFFU)
{
PRINTF("Your value is output of range.\r\n");
continue;
}
DAC_SetBufferValue(DEMO_DAC_INSTANCE, 0U, dacValue);
PRINTF("DAC out: %d\r\n", dacValue);
/*
* The value in the first item would be converted. User can measure the output voltage from DAC_OUTx pin.
*/
}
}
void main(void)
#endif
{
BOARD_InitPins();
BOARD_BootClockHSRUN();
BOARD_InitDebugConsole();
USB_DeviceApplicationInit();
while (1U)
{
#if USB_DEVICE_CONFIG_USE_TASK
#if defined(USB_DEVICE_CONFIG_EHCI) && (USB_DEVICE_CONFIG_EHCI > 0U)
USB_DeviceEhciTaskFunction(g_UsbDeviceComposite.deviceHandle);
#endif
#if defined(USB_DEVICE_CONFIG_KHCI) && (USB_DEVICE_CONFIG_KHCI > 0U)
USB_DeviceKhciTaskFunction(g_UsbDeviceComposite.deviceHandle);
#endif
#endif
}
}
int main(void) {
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
GPIO_PinInit(BOARD_LED_RED_GPIO, BOARD_LED_RED_GPIO_PIN, \
&(gpio_pin_config_t){kGPIO_DigitalOutput, 0u});
GPIO_PinInit(BOARD_LED_GREEN_GPIO, BOARD_LED_GREEN_GPIO_PIN, \
&(gpio_pin_config_t){kGPIO_DigitalOutput, 0u});
GPIO_PinInit(BOARD_LED_BLUE_GPIO, BOARD_LED_BLUE_GPIO_PIN, \
&(gpio_pin_config_t){kGPIO_DigitalOutput, 0u});
GPIO_SetPinsOutput(BOARD_LED_RED_GPIO, 1u << BOARD_LED_RED_GPIO_PIN);
GPIO_SetPinsOutput(BOARD_LED_GREEN_GPIO, 1u << BOARD_LED_GREEN_GPIO_PIN);
GPIO_SetPinsOutput(BOARD_LED_BLUE_GPIO, 1u << BOARD_LED_BLUE_GPIO_PIN);
for(;;) {
GPIO_TogglePinsOutput(BOARD_LED_BLUE_GPIO, 1u << BOARD_LED_BLUE_GPIO_PIN);
delay();
}
}
/*!
* @brief Main function
*/
int main(void)
{
ip_addr_t fsl_netif0_ipaddr, fsl_netif0_netmask, fsl_netif0_gw;
MPU_Type *base = MPU;
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
/* Disable MPU. */
base->CESR &= ~MPU_CESR_VLD_MASK;
LWIP_DEBUGF(UDPECHO_DBG, ("TCP/IP initializing...\r\n"));
tcpip_init(NULL, NULL);
LWIP_DEBUGF(UDPECHO_DBG, ("TCP/IP initialized.\r\n"));
IP4_ADDR(&fsl_netif0_ipaddr, configIP_ADDR0, configIP_ADDR1, configIP_ADDR2, configIP_ADDR3);
IP4_ADDR(&fsl_netif0_netmask, configNET_MASK0, configNET_MASK1, configNET_MASK2, configNET_MASK3);
IP4_ADDR(&fsl_netif0_gw, configGW_ADDR0, configGW_ADDR1, configGW_ADDR2, configGW_ADDR3);
netif_add(&fsl_netif0, &fsl_netif0_ipaddr, &fsl_netif0_netmask, &fsl_netif0_gw, NULL, ethernetif_init, tcpip_input);
netif_set_default(&fsl_netif0);
LWIP_PLATFORM_DIAG(("\r\n************************************************"));
LWIP_PLATFORM_DIAG((" UDP Echo example"));
LWIP_PLATFORM_DIAG(("************************************************"));
LWIP_PLATFORM_DIAG((" IPv4 Address : %u.%u.%u.%u", ((u8_t *)&fsl_netif0_ipaddr)[0],
((u8_t *)&fsl_netif0_ipaddr)[1], ((u8_t *)&fsl_netif0_ipaddr)[2],
((u8_t *)&fsl_netif0_ipaddr)[3]));
LWIP_PLATFORM_DIAG((" IPv4 Subnet mask : %u.%u.%u.%u", ((u8_t *)&fsl_netif0_netmask)[0],
((u8_t *)&fsl_netif0_netmask)[1], ((u8_t *)&fsl_netif0_netmask)[2],
((u8_t *)&fsl_netif0_netmask)[3]));
LWIP_PLATFORM_DIAG((" IPv4 Gateway : %u.%u.%u.%u", ((u8_t *)&fsl_netif0_gw)[0], ((u8_t *)&fsl_netif0_gw)[1],
((u8_t *)&fsl_netif0_gw)[2], ((u8_t *)&fsl_netif0_gw)[3]));
LWIP_PLATFORM_DIAG(("************************************************"));
udp_echo_init();
/* should not reach this statement */
for (;;)
;
}
/*!
* @brief Main function
*/
int main(void)
{
/* Define the init structure for the input switch pin */
gpio_pin_config_t sw_config = {
kGPIO_DigitalInput, 0,
};
/* Define the init structure for the output LED pin */
gpio_pin_config_t led_config = {
kGPIO_DigitalOutput, 0,
};
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
/* Print a note to terminal. */
PRINTF("\r\n GPIO Driver example\r\n");
PRINTF("\r\n Press %s to turn on/off a LED \r\n", BOARD_SW_NAME);
/* Init input switch GPIO. */
PORT_SetPinInterruptConfig(BOARD_SW_PORT, BOARD_SW_GPIO_PIN, kPORT_InterruptFallingEdge);
EnableIRQ(BOARD_SW_IRQ);
GPIO_PinInit(BOARD_SW_GPIO, BOARD_SW_GPIO_PIN, &sw_config);
/* Init output LED GPIO. */
GPIO_PinInit(BOARD_LED_GPIO, BOARD_LED_GPIO_PIN, &led_config);
while (1)
{
if (g_ButtonPress)
{
PRINTF(" %s is pressed \r\n", BOARD_SW_NAME);
/* Reset state of button. */
g_ButtonPress = false;
}
}
}
void main(void)
#endif
{
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
APPInit();
while (1)
{
APP_task();
#if USB_DEVICE_CONFIG_USE_TASK
#if defined(USB_DEVICE_CONFIG_EHCI) && (USB_DEVICE_CONFIG_EHCI > 0U)
USB_DeviceEhciTaskFunction(s_cdcVcom.deviceHandle);
#endif
#if defined(USB_DEVICE_CONFIG_KHCI) && (USB_DEVICE_CONFIG_KHCI > 0U)
USB_DeviceKhciTaskFunction(s_cdcVcom.deviceHandle);
#endif
#endif
}
}
/*!
* @brief Main function
*/
int main(void)
{
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
PRINTF("DSPI edma example start.\r\n");
PRINTF("This example use one dspi instance as master and another as slave on one board.\r\n");
PRINTF("Master use edma way , slave uses interrupt.\r\n");
PRINTF("Please make sure you make the correct line connection. Basically, the connection is: \r\n");
PRINTF("DSPI_master -- DSPI_slave \r\n");
PRINTF(" CLK -- CLK \r\n");
PRINTF(" PCS -- PCS \r\n");
PRINTF(" SOUT -- SIN \r\n");
PRINTF(" SIN -- SOUT \r\n");
/* DMA Mux setting and EDMA init */
uint32_t masterRxChannel, masterIntermediaryChannel, masterTxChannel;
uint32_t slaveRxChannel, slaveTxChannel;
edma_config_t userConfig;
masterRxChannel = 0U;
masterIntermediaryChannel = 1U;
masterTxChannel = 2U;
slaveRxChannel = 3U;
slaveTxChannel = 4U;
/* DMA MUX init */
DMAMUX_Init(EXAMPLE_DSPI_MASTER_DMA_MUX_BASEADDR);
#if (defined EXAMPLE_DSPI_MASTER_DMA_MUX_BASE) && (defined EXAMPLE_DSPI_SLAVE_DMA_MUX_BASE) && \
(EXAMPLE_DSPI_MASTER_DMA_MUX_BASE != EXAMPLE_DSPI_SLAVE_DMA_MUX_BASE)
DMAMUX_Init(EXAMPLE_DSPI_SLAVE_DMA_MUX_BASEADDR);
#endif
DMAMUX_SetSource(EXAMPLE_DSPI_MASTER_DMA_MUX_BASEADDR, masterRxChannel, EXAMPLE_DSPI_MASTER_DMA_RX_REQUEST_SOURCE);
DMAMUX_EnableChannel(EXAMPLE_DSPI_MASTER_DMA_MUX_BASEADDR, masterRxChannel);
#if (defined EXAMPLE_DSPI_MASTER_DMA_TX_REQUEST_SOURCE)
DMAMUX_SetSource(EXAMPLE_DSPI_MASTER_DMA_MUX_BASEADDR, masterTxChannel, EXAMPLE_DSPI_MASTER_DMA_TX_REQUEST_SOURCE);
DMAMUX_EnableChannel(EXAMPLE_DSPI_MASTER_DMA_MUX_BASEADDR, masterTxChannel);
#endif
DMAMUX_SetSource(EXAMPLE_DSPI_SLAVE_DMA_MUX_BASEADDR, slaveRxChannel, EXAMPLE_DSPI_SLAVE_DMA_RX_REQUEST_SOURCE);
DMAMUX_EnableChannel(EXAMPLE_DSPI_SLAVE_DMA_MUX_BASEADDR, slaveRxChannel);
#if (defined EXAMPLE_DSPI_SLAVE_DMA_TX_REQUEST_SOURCE)
DMAMUX_SetSource(EXAMPLE_DSPI_SLAVE_DMA_MUX_BASEADDR, slaveTxChannel, EXAMPLE_DSPI_SLAVE_DMA_TX_REQUEST_SOURCE);
DMAMUX_EnableChannel(EXAMPLE_DSPI_SLAVE_DMA_MUX_BASEADDR, slaveTxChannel);
#endif
/* EDMA init*/
/*
* userConfig.enableRoundRobinArbitration = false;
* userConfig.enableHaltOnError = true;
* userConfig.enableContinuousLinkMode = false;
* userConfig.enableDebugMode = false;
*/
EDMA_GetDefaultConfig(&userConfig);
EDMA_Init(EXAMPLE_DSPI_MASTER_DMA_BASEADDR, &userConfig);
#if (defined EXAMPLE_DSPI_SLAVE_DMA_BASE) && (defined EXAMPLE_DSPI_MASTER_DMA_BASE) && \
(EXAMPLE_DSPI_SLAVE_DMA_BASE != EXAMPLE_DSPI_MASTER_DMA_BASE)
EDMA_Init(EXAMPLE_DSPI_SLAVE_DMA_BASEADDR, &userConfig);
#endif
/*DSPI init*/
uint32_t srcClock_Hz;
uint32_t errorCount;
uint32_t i;
dspi_master_config_t masterConfig;
dspi_slave_config_t slaveConfig;
dspi_transfer_t masterXfer;
dspi_transfer_t slaveXfer;
/*Master config*/
masterConfig.whichCtar = kDSPI_Ctar0;
masterConfig.ctarConfig.baudRate = TRANSFER_BAUDRATE;
masterConfig.ctarConfig.bitsPerFrame = 8U;
masterConfig.ctarConfig.cpol = kDSPI_ClockPolarityActiveHigh;
masterConfig.ctarConfig.cpha = kDSPI_ClockPhaseFirstEdge;
masterConfig.ctarConfig.direction = kDSPI_MsbFirst;
masterConfig.ctarConfig.pcsToSckDelayInNanoSec = 1000000000U / TRANSFER_BAUDRATE;
masterConfig.ctarConfig.lastSckToPcsDelayInNanoSec = 1000000000U / TRANSFER_BAUDRATE;
masterConfig.ctarConfig.betweenTransferDelayInNanoSec = 1000000000U / TRANSFER_BAUDRATE;
masterConfig.whichPcs = EXAMPLE_DSPI_MASTER_PCS_FOR_INIT;
masterConfig.pcsActiveHighOrLow = kDSPI_PcsActiveLow;
masterConfig.enableContinuousSCK = false;
masterConfig.enableRxFifoOverWrite = false;
masterConfig.enableModifiedTimingFormat = false;
masterConfig.samplePoint = kDSPI_SckToSin0Clock;
srcClock_Hz = CLOCK_GetFreq(DSPI_MASTER_CLK_SRC);
DSPI_MasterInit(EXAMPLE_DSPI_MASTER_BASEADDR, &masterConfig, srcClock_Hz);
/*Slave config*/
slaveConfig.whichCtar = kDSPI_Ctar0;
slaveConfig.ctarConfig.bitsPerFrame = masterConfig.ctarConfig.bitsPerFrame;
slaveConfig.ctarConfig.cpol = masterConfig.ctarConfig.cpol;
slaveConfig.ctarConfig.cpha = masterConfig.ctarConfig.cpha;
slaveConfig.enableContinuousSCK = masterConfig.enableContinuousSCK;
slaveConfig.enableRxFifoOverWrite = masterConfig.enableRxFifoOverWrite;
slaveConfig.enableModifiedTimingFormat = masterConfig.enableModifiedTimingFormat;
slaveConfig.samplePoint = masterConfig.samplePoint;
DSPI_SlaveInit(EXAMPLE_DSPI_SLAVE_BASEADDR, &slaveConfig);
/* Set up the transfer data */
for (i = 0U; i < TRANSFER_SIZE; i++)
{
masterTxData[i] = i % 256U;
masterRxData[i] = 0U;
slaveTxData[i] = ~masterTxData[i];
slaveRxData[i] = 0U;
}
/* Set up dspi slave first */
memset(&(dspiEdmaSlaveRxRegToRxDataHandle), 0, sizeof(dspiEdmaSlaveRxRegToRxDataHandle));
memset(&(dspiEdmaSlaveTxDataToTxRegHandle), 0, sizeof(dspiEdmaSlaveTxDataToTxRegHandle));
EDMA_CreateHandle(&(dspiEdmaSlaveRxRegToRxDataHandle), EXAMPLE_DSPI_SLAVE_DMA_BASEADDR, slaveRxChannel);
EDMA_CreateHandle(&(dspiEdmaSlaveTxDataToTxRegHandle), EXAMPLE_DSPI_SLAVE_DMA_BASEADDR, slaveTxChannel);
isTransferCompleted = false;
DSPI_SlaveTransferCreateHandleEDMA(EXAMPLE_DSPI_SLAVE_BASEADDR, &g_dspi_edma_s_handle, DSPI_SlaveUserCallback, NULL,
&dspiEdmaSlaveRxRegToRxDataHandle, &dspiEdmaSlaveTxDataToTxRegHandle);
slaveXfer.txData = slaveTxData;
slaveXfer.rxData = slaveRxData;
slaveXfer.dataSize = TRANSFER_SIZE;
slaveXfer.configFlags = kDSPI_SlaveCtar0;
if (kStatus_Success != DSPI_SlaveTransferEDMA(EXAMPLE_DSPI_SLAVE_BASEADDR, &g_dspi_edma_s_handle, &slaveXfer))
{
PRINTF("There is error when start DSPI_SlaveTransferEDMA \r\n");
}
/* Set up dspi master */
memset(&(dspiEdmaMasterRxRegToRxDataHandle), 0, sizeof(dspiEdmaMasterRxRegToRxDataHandle));
memset(&(dspiEdmaMasterTxDataToIntermediaryHandle), 0, sizeof(dspiEdmaMasterTxDataToIntermediaryHandle));
memset(&(dspiEdmaMasterIntermediaryToTxRegHandle), 0, sizeof(dspiEdmaMasterIntermediaryToTxRegHandle));
EDMA_CreateHandle(&(dspiEdmaMasterRxRegToRxDataHandle), EXAMPLE_DSPI_MASTER_DMA_BASEADDR, masterRxChannel);
EDMA_CreateHandle(&(dspiEdmaMasterTxDataToIntermediaryHandle), EXAMPLE_DSPI_MASTER_DMA_BASEADDR,
masterIntermediaryChannel);
EDMA_CreateHandle(&(dspiEdmaMasterIntermediaryToTxRegHandle), EXAMPLE_DSPI_MASTER_DMA_BASEADDR, masterTxChannel);
DSPI_MasterTransferCreateHandleEDMA(EXAMPLE_DSPI_MASTER_BASEADDR, &g_dspi_edma_m_handle, DSPI_MasterUserCallback,
NULL, &dspiEdmaMasterRxRegToRxDataHandle,
&dspiEdmaMasterTxDataToIntermediaryHandle,
&dspiEdmaMasterIntermediaryToTxRegHandle);
/* Start master transfer */
masterXfer.txData = masterTxData;
masterXfer.rxData = masterRxData;
masterXfer.dataSize = TRANSFER_SIZE;
masterXfer.configFlags = kDSPI_MasterCtar0 | EXAMPLE_DSPI_MASTER_PCS_FOR_TRANSFER | kDSPI_MasterPcsContinuous;
if (kStatus_Success != DSPI_MasterTransferEDMA(EXAMPLE_DSPI_MASTER_BASEADDR, &g_dspi_edma_m_handle, &masterXfer))
{
PRINTF("There is error when start DSPI_MasterTransferEDMA \r\n ");
}
/* Wait until transfer completed */
while (!isTransferCompleted)
{
}
/* Check the data */
errorCount = 0U;
for (i = 0U; i < TRANSFER_SIZE; i++)
{
if (masterTxData[i] != slaveRxData[i])
{
errorCount++;
}
if (slaveTxData[i] != masterRxData[i])
{
errorCount++;
}
}
if (errorCount == 0)
{
PRINTF("DSPI transfer all data matched! \r\n");
}
else
{
PRINTF("Error occured in DSPI transfer ! \r\n");
}
DSPI_Deinit(EXAMPLE_DSPI_MASTER_BASEADDR);
DSPI_Deinit(EXAMPLE_DSPI_SLAVE_BASEADDR);
while (1)
{
}
}
int main(void)
{
uint8_t waveForm = 0;
slcd_config_t config;
slcd_clock_config_t clkConfig =
{
kSLCD_AlternateClk1, // MCGIRCLK wenxue
kSLCD_AltClkDivFactor256, // MCGIRCLK =8M 8M/256=32.15k
kSLCD_ClkPrescaler01, // wenxue LCLK=1
#if FSL_FEATURE_SLCD_HAS_FAST_FRAME_RATE
false
#endif
};
/* Hardware initialize. */
BOARD_InitPins(); // wenxue 要修改
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
/* Enable the MCGIRCLK */
MCG->C1 |= MCG_C1_IRCLKEN_MASK;
PRINTF("\r\nSLCD Example Starts.\r\n");
/* SLCD get default configure. */
/*
* config.displayMode = kSLCD_NormalMode;
* config.powerSupply = kSLCD_InternalVll3UseChargePump;
* config.voltageTrim = kSLCD_RegulatedVolatgeTrim00;
* config.lowPowerBehavior = kSLCD_EnabledInWaitStop;
* config.frameFreqIntEnable = false;
* config.faultConfig = NULL;
*/
SLCD_GetDefaultConfig(&config);
/* Verify and Complete the configuration structure. */
config.clkConfig = &clkConfig;
config.loadAdjust = kSLCD_HighLoadOrSlowestClkSrc;
config.dutyCycle = kSLCD_1Div4DutyCycle;
/* 全部LCD 引脚配置 */
config.slcdLowPinEnabled = 0xFFF0FF7FU; /* LCD_P14/15/20/24/26/27 相应位置为1 */
config.slcdHighPinEnabled = 0x00000F80U; /* LCD_P8/10/11/12/27/28+32= LCD_P40/42/43/44/59/60. 相应位置为1 */
/* COM 口配置 */
config.backPlaneLowPin = 0x0000010EU; /* LCD_P1/2/3/8 */
config.backPlaneHighPin = 0x00000000U; /* */
config.faultConfig = NULL;
/* SLCD Initialize. */
SLCD_Init(LCD, &config);
/* Set SLCD front plane phase to show: all segments on . */
waveForm = (kSLCD_PhaseAActivate | kSLCD_PhaseBActivate | kSLCD_PhaseCActivate | kSLCD_PhaseDActivate);
/* Set SLCD back plane phase. */ /* COM 口 wenxue */
SLCD_SetBackPlanePhase(LCD, 1, kSLCD_PhaseAActivate); /* SLCD COM1 --- LCD_P1. */
SLCD_SetBackPlanePhase(LCD, 2, kSLCD_PhaseBActivate); /* SLCD COM2 --- LCD_P2. */
SLCD_SetBackPlanePhase(LCD, 3, kSLCD_PhaseCActivate); /* SLCD COM3 --- LCD_P3. */
SLCD_SetBackPlanePhase(LCD, 8, kSLCD_PhaseDActivate); /* SLCD COM4 --- LCD_P8. */
/* Set SLCD front plane phase to show. */ /* Seg 口 wenxue */
SLCD_SetFrontPlaneSegments(LCD, 20, waveForm); /* SLCD P05 --- LCD_P20. */
SLCD_SetFrontPlaneSegments(LCD, 24, waveForm); /* SLCD P06 --- LCD_P24. */
SLCD_SetFrontPlaneSegments(LCD, 26, waveForm); /* SLCD P07 --- LCD_P26. */
SLCD_SetFrontPlaneSegments(LCD, 27, waveForm); /* SLCD P08 --- LCD_P27. */
SLCD_SetFrontPlaneSegments(LCD, 40, waveForm); /* SLCD P09 --- LCD_P40. */
SLCD_SetFrontPlaneSegments(LCD, 42, waveForm); /* SLCD P10 --- LCD_P42. */
SLCD_SetFrontPlaneSegments(LCD, 43, waveForm); /* SLCD P11 --- LCD_P43. */
SLCD_SetFrontPlaneSegments(LCD, 44, waveForm); /* SLCD P12 --- LCD_P44. */
/* Starts SLCD display. */
SLCD_StartDisplay(LCD);
PRINTF("\r\nSLCD Displays All Segments.\r\n");
SLCD_TimeDelay(0xFFFFFFU);
PRINTF("\r\nSLCD Starts Blink Mode.\r\n");
/* Blink mode Display. */
SLCD_StartBlinkMode(LCD, kSLCD_BlankDisplayBlink, kSLCD_BlinkRate01);
SLCD_TimeDelay(0xFFFFFFU);
PRINTF("\r\nSLCD Stops Blink Mode.\r\n");
/* Stops SLCD blink display mode. */
SLCD_StopBlinkMode(LCD);
SLCD_TimeDelay(0xFFFFFFU);
PRINTF("\r\nSLCD Stops Display.\r\n");
/* Stops SLCD display. */
SLCD_StopDisplay(LCD);
PRINTF("\r\nSLCD Example Ends.\r\n");
while (1)
{
}
}
/*!
* @brief Main function
*/
int main(void)
{
tpm_config_t tpmInfo;
tpm_chnl_pwm_signal_param_t tpmParam;
tpm_pwm_level_select_t pwmLevel = kTPM_LowTrue;
/* Configure tpm params with frequency 24kHZ */
tpmParam.chnlNumber = (tpm_chnl_t)BOARD_TPM_CHANNEL;
tpmParam.level = pwmLevel;
tpmParam.dutyCyclePercent = updatedDutycycle;
/* Board pin, clock, debug console init */
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
/* Select the clock source for the TPM counter as kCLOCK_PllFllSelClk */
CLOCK_SetTpmClock(1U);
/* Print a note to terminal */
PRINTF("\r\nTPM example to output center-aligned PWM signal\r\n");
PRINTF("\r\nYou will see a change in LED brightness if an LED is connected to the TPM pin");
PRINTF("\r\nIf no LED is connected to the TPM pin, then probe the signal using an oscilloscope");
TPM_GetDefaultConfig(&tpmInfo);
/* Initialize TPM module */
TPM_Init(BOARD_TPM_BASEADDR, &tpmInfo);
TPM_SetupPwm(BOARD_TPM_BASEADDR, &tpmParam, 1U, kTPM_CenterAlignedPwm, 24000U, TPM_SOURCE_CLOCK);
/* Enable channel interrupt flag.*/
TPM_EnableInterrupts(BOARD_TPM_BASEADDR, TPM_CHANNEL_INTERRUPT_ENABLE);
/* Enable at the NVIC */
EnableIRQ(TPM_INTERRUPT_NUMBER);
TPM_StartTimer(BOARD_TPM_BASEADDR, kTPM_SystemClock);
while (1)
{
/* Use interrupt to update the PWM dutycycle */
if (true == tpmIsrFlag)
{
/* Disable interrupt to retain current dutycycle for a few seconds */
TPM_DisableInterrupts(BOARD_TPM_BASEADDR, TPM_CHANNEL_INTERRUPT_ENABLE);
tpmIsrFlag = false;
/* Disable channel output before updating the dutycycle */
TPM_UpdateChnlEdgeLevelSelect(BOARD_TPM_BASEADDR, (tpm_chnl_t)BOARD_TPM_CHANNEL, 0U);
/* Update PWM duty cycle */
TPM_UpdatePwmDutycycle(BOARD_TPM_BASEADDR, (tpm_chnl_t)BOARD_TPM_CHANNEL, kTPM_CenterAlignedPwm,
updatedDutycycle);
/* Start channel output with updated dutycycle */
TPM_UpdateChnlEdgeLevelSelect(BOARD_TPM_BASEADDR, (tpm_chnl_t)BOARD_TPM_CHANNEL, pwmLevel);
/* Delay to view the updated PWM dutycycle */
delay();
/* Enable interrupt flag to update PWM dutycycle */
TPM_EnableInterrupts(BOARD_TPM_BASEADDR, TPM_CHANNEL_INTERRUPT_ENABLE);
}
}
}
/*!
* @brief Main function
*/
int main(void)
{
adc16_config_t adc16ConfigStruct;
adc16_channel_config_t adc16ChannelConfigStruct;
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
EnableIRQ(DEMO_ADC16_IRQn);
PRINTF("\r\nADC16 interrupt Example.\r\n");
/*
* adc16ConfigStruct.referenceVoltageSource = kADC16_ReferenceVoltageSourceVref;
* adc16ConfigStruct.clockSource = kADC16_ClockSourceAsynchronousClock;
* adc16ConfigStruct.enableAsynchronousClock = true;
* adc16ConfigStruct.clockDivider = kADC16_ClockDivider8;
* adc16ConfigStruct.resolution = kADC16_ResolutionSE12Bit;
* adc16ConfigStruct.longSampleMode = kADC16_LongSampleDisabled;
* adc16ConfigStruct.enableHighSpeed = false;
* adc16ConfigStruct.enableLowPower = false;
* adc16ConfigStruct.enableContinuousConversion = false;
*/
ADC16_GetDefaultConfig(&adc16ConfigStruct);
ADC16_Init(DEMO_ADC16_BASE, &adc16ConfigStruct);
ADC16_EnableHardwareTrigger(DEMO_ADC16_BASE, false); /* Make sure the software trigger is used. */
#if defined(FSL_FEATURE_ADC16_HAS_CALIBRATION) && FSL_FEATURE_ADC16_HAS_CALIBRATION
if (kStatus_Success == ADC16_DoAutoCalibration(DEMO_ADC16_BASE))
{
PRINTF("ADC16_DoAutoCalibration() Done.\r\n");
}
else
{
PRINTF("ADC16_DoAutoCalibration() Failed.\r\n");
}
#endif /* FSL_FEATURE_ADC16_HAS_CALIBRATION */
PRINTF("Press any key to get user channel's ADC value ...\r\n");
adc16ChannelConfigStruct.channelNumber = DEMO_ADC16_USER_CHANNEL;
adc16ChannelConfigStruct.enableInterruptOnConversionCompleted = true; /* Enable the interrupt. */
#if defined(FSL_FEATURE_ADC16_HAS_DIFF_MODE) && FSL_FEATURE_ADC16_HAS_DIFF_MODE
adc16ChannelConfigStruct.enableDifferentialConversion = false;
#endif /* FSL_FEATURE_ADC16_HAS_DIFF_MODE */
g_Adc16InterruptCounter = 0U;
while (1)
{
GETCHAR();
g_Adc16ConversionDoneFlag = false;
/*
When in software trigger mode, each conversion would be launched once calling the "ADC16_ChannelConfigure()"
function, which works like writing a conversion command and executing it. For another channel's conversion,
just to change the "channelNumber" field in channel configuration structure, and call the function
"ADC16_ChannelConfigure()"" again.
Also, the "enableInterruptOnConversionCompleted" inside the channel configuration structure is a parameter for
the conversion command. It takes affect just for the current conversion. If the interrupt is still required
for the following conversion, it is necessary to assert the "enableInterruptOnConversionCompleted" every time
for each command.
*/
ADC16_SetChannelConfig(DEMO_ADC16_BASE, DEMO_ADC16_CHANNEL_GROUP, &adc16ChannelConfigStruct);
while (!g_Adc16ConversionDoneFlag)
{
}
PRINTF("ADC Value: %d\r\n", g_Adc16ConversionValue);
PRINTF("ADC Interrupt Count: %d\r\n", g_Adc16InterruptCounter);
}
}
/*!
* @brief Main function
*/
int main(void)
{
pdb_config_t pdbConfigStruct;
pdb_adc_pretrigger_config_t pdbAdcPreTriggerConfigStruct;
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
EnableIRQ(DEMO_PDB_IRQ_ID);
EnableIRQ(DEMO_ADC_IRQ_ID);
PRINTF("\r\nPDB ADC16 Pre-Trigger Example.\r\n");
/* Configure the PDB counter. */
/*
* pdbConfigStruct.loadValueMode = kPDB_LoadValueImmediately;
* pdbConfigStruct.prescalerDivider = kPDB_PrescalerDivider1;
* pdbConfigStruct.dividerMultiplicationFactor = kPDB_DividerMultiplicationFactor1;
* pdbConfigStruct.triggerInputSource = kPDB_TriggerSoftware;
* pdbConfigStruct.enableContinuousMode = false;
*/
PDB_GetDefaultConfig(&pdbConfigStruct);
PDB_Init(DEMO_PDB_BASE, &pdbConfigStruct);
/* Configure the delay interrupt. */
PDB_SetModulusValue(DEMO_PDB_BASE, 1000U);
/* The available delay value is less than or equal to the modulus value. */
PDB_SetCounterDelayValue(DEMO_PDB_BASE, 1000U);
PDB_EnableInterrupts(DEMO_PDB_BASE, kPDB_DelayInterruptEnable);
/* Configure the ADC Pre-Trigger. */
pdbAdcPreTriggerConfigStruct.enablePreTriggerMask = 1U << DEMO_PDB_ADC_PRETRIGGER_CHANNEL;
pdbAdcPreTriggerConfigStruct.enableOutputMask = 1U << DEMO_PDB_ADC_PRETRIGGER_CHANNEL;
pdbAdcPreTriggerConfigStruct.enableBackToBackOperationMask = 0U;
PDB_SetADCPreTriggerConfig(DEMO_PDB_BASE, DEMO_PDB_ADC_TRIGGER_CHANNEL, &pdbAdcPreTriggerConfigStruct);
PDB_SetADCPreTriggerDelayValue(DEMO_PDB_BASE, DEMO_PDB_ADC_TRIGGER_CHANNEL, DEMO_PDB_ADC_PRETRIGGER_CHANNEL, 200U);
/* The available Pre-Trigger delay value is less than or equal to the modulus value. */
PDB_DoLoadValues(DEMO_PDB_BASE);
/* Configure the ADC. */
DEMO_InitPDB_ADC();
g_PdbDelayInterruptCounter = 0U;
g_AdcInterruptCounter = 0U;
while (1)
{
PRINTF("\r\nType any key into terminal to trigger the PDB and then trigger the ADC's conversion ...\r\n");
GETCHAR();
g_PdbDelayInterruptFlag = false;
g_AdcInterruptFlag = false;
PDB_DoSoftwareTrigger(DEMO_PDB_BASE);
while ((!g_PdbDelayInterruptFlag) || (!g_AdcInterruptFlag))
{
}
PRINTF("\r\n");
PRINTF("PDB Interrupt Counter: %d\r\n", g_PdbDelayInterruptCounter);
PRINTF("ADC Conversion Interrupt Counter: %d\r\n", g_AdcInterruptCounter);
PRINTF("ADC Conversion Value: %d\r\n", g_AdcConvValue);
}
}
int main(void) {
/* Init board hardware. */
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
for(uint8_t i = 0; i < NUM_LEDS; i++) {
leds[i].r = 0;
leds[i].g = 0;
leds[i].b = 0;
}
struct FLEXIO_WS2812_LED led;
led.r = 0;
led.g = 0;
led.b = 0;
/* Init and enable FlexIO */
CLOCK_EnableClock(kCLOCK_Flexio0);
flexio_config_t user_config = {
.enableFlexio = true,
.enableInDoze = false,
.enableInDebug = false,
.enableFastAccess = false
};
FLEXIO_Init(FLEXIO0, &user_config);
FLEXIO_Enable(FLEXIO0, true);
FLEXIO_WS2812_Init();
/* Init GPIOs */
gpio_pin_config_t config =
{
kGPIO_DigitalOutput,
0,
};
GPIO_PinInit(GPIOA, 5U, &config);
GPIO_WritePinOutput(GPIOA, 5U, 0U);
GPIO_PinInit(GPIOA, 13U, &config);
GPIO_WritePinOutput(GPIOA, 13U, 0U);
GPIO_PinInit(GPIOA, 12U, &config);
GPIO_WritePinOutput(GPIOA, 12U, 0U);
GPIO_PinInit(GPIOA, 17U, &config);
GPIO_WritePinOutput(GPIOA, 17U, 0U);
GPIO_PinInit(GPIOA, 14U, &config);
GPIO_WritePinOutput(GPIOA, 14U, 0U);
GPIO_PinInit(GPIOC, 7U, &config);
GPIO_WritePinOutput(GPIOC, 7U, 0U);
GPIO_PinInit(GPIOA, 16U, &config);
GPIO_WritePinOutput(GPIOA, 16U, 0U);
GPIO_PinInit(GPIOA, 15U, &config);
GPIO_WritePinOutput(GPIOA, 15U, 0U);
while(1) {
/* Read serial char */
char ch = GETCHAR();
switch(ch) {
/* All LEDs red */
case 'r':
led.r = 255;
led.g = 0;
led.b = 0;
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_TransmitBuffer();
break;
/* All LEDs green */
case 'g':
led.r = 0;
led.g = 255;
led.b = 0;
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_TransmitBuffer();
break;
/* All LEDs red */
case 'b':
led.r = 0;
led.g = 0;
led.b = 255;
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_TransmitBuffer();
break;
/* All LEDs off */
case 'o':
led.r = 0;
led.g = 0;
led.b = 0;
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_TransmitBuffer();
break;
/* Serial test */
case 's':
PRINTF("Serial test\r\n");
break;
/* Start measurement */
case 'p':
updaterange();
PRINTF("%d,%d,%d,%d,%d,%d,%d,%d\r\n", range[0], range[1], range[2], range[3], range[4], range[5], range[6], range[7]);
break;
}
}
}
int main(void)
{
i2c_slave_config_t slaveConfig;
i2c_master_config_t masterConfig;
uint32_t sourceClock;
i2c_master_transfer_t masterXfer;
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
/*Init DMA for example*/
DMAMGR_Init();
/* set master priority lower than slave */
NVIC_EnableIRQ(DMA0_IRQn);
NVIC_SetPriority(DMA0_IRQn, 1);
PRINTF("\r\nI2C example -- MasterDMA_SlaveInterrupt.\r\n");
/*1.Set up i2c slave first*/
/*
* slaveConfig.addressingMode = kI2C_Address7bit;
* slaveConfig.enableGeneralCall = false;
* slaveConfig.enableWakeUp = false;
* slaveConfig.enableHighDrive = false;
* slaveConfig.enableBaudRateCtl = false;
* slaveConfig.enableSlave = true;
*/
I2C_SlaveGetDefaultConfig(&slaveConfig);
slaveConfig.addressingMode = kI2C_Address7bit;
slaveConfig.slaveAddress = I2C_MASTER_SLAVE_ADDR_7BIT;
slaveConfig.upperAddress = 0;
I2C_SlaveInit(EXAMPLE_I2C_SLAVE_BASEADDR, &slaveConfig);
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
g_slave_buff[i] = 0;
}
memset(&g_s_handle, 0, sizeof(g_s_handle));
I2C_SlaveTransferCreateHandle(EXAMPLE_I2C_SLAVE_BASEADDR, &g_s_handle, i2c_slave_callback, NULL);
I2C_SlaveTransferNonBlocking(EXAMPLE_I2C_SLAVE_BASEADDR, &g_s_handle, kI2C_SlaveCompletionEvent);
/*2.Set up i2c master to send data to slave*/
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
g_master_buff[i] = i;
}
PRINTF("Master will send data :");
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
if (i % 8 == 0U)
{
PRINTF("\r\n");
}
PRINTF("0x%2x ", g_master_buff[i]);
}
PRINTF("\r\n\r\n");
/*
* masterConfig.baudRate_Bps = 100000U;
* masterConfig.enableHighDrive = false;
* masterConfig.enableStopHold = false;
* masterConfig.glitchFilterWidth = 0U;
* masterConfig.enableMaster = true;
*/
I2C_MasterGetDefaultConfig(&masterConfig);
masterConfig.baudRate_Bps = I2C_BAUDRATE;
sourceClock = CLOCK_GetFreq(I2C_MASTER_CLK_SRC);
I2C_MasterInit(EXAMPLE_I2C_MASTER_BASEADDR, &masterConfig, sourceClock);
memset(&g_m_dma_handle, 0, sizeof(g_m_dma_handle));
memset(&masterXfer, 0, sizeof(masterXfer));
masterXfer.slaveAddress = I2C_MASTER_SLAVE_ADDR_7BIT;
masterXfer.direction = kI2C_Write;
masterXfer.subaddress = 0;
masterXfer.subaddressSize = 0;
masterXfer.data = g_master_buff;
masterXfer.dataSize = I2C_DATA_LENGTH;
masterXfer.flags = kI2C_TransferDefaultFlag;
DMAMGR_RequestChannel((dma_request_source_t)DMA_REQUEST_SRC, 0, &dmaHandle);
I2C_MasterTransferCreateHandleDMA(EXAMPLE_I2C_MASTER_BASEADDR, &g_m_dma_handle, NULL, NULL, &dmaHandle);
I2C_MasterTransferDMA(EXAMPLE_I2C_MASTER_BASEADDR, &g_m_dma_handle, &masterXfer);
/* wait for transfer completed. */
while (!completionFlag)
{
}
completionFlag = false;
/*3.Transfer completed. Check the data.*/
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
if (g_slave_buff[i] != g_master_buff[i])
{
PRINTF("\r\nError occured in this transfer ! \r\n");
break;
}
}
PRINTF("Slave received data :");
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
if (i % 8 == 0)
{
PRINTF("\r\n");
}
PRINTF("0x%2x ", g_slave_buff[i]);
}
PRINTF("\r\n\r\n");
/*4.Set up slave ready to send data to master.*/
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
g_slave_buff[i] = ~g_slave_buff[i];
}
PRINTF("This time , slave will send data: :");
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
if (i % 8 == 0)
{
PRINTF("\r\n");
}
PRINTF("0x%2x ", g_slave_buff[i]);
}
PRINTF("\r\n\r\n");
/* Already setup the slave transfer in item 1 */
/*5.Set up master to receive data from slave.*/
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
g_master_buff[i] = 0;
}
masterXfer.slaveAddress = I2C_MASTER_SLAVE_ADDR_7BIT;
masterXfer.direction = kI2C_Read;
masterXfer.subaddress = 0;
masterXfer.subaddressSize = 0;
masterXfer.data = g_master_buff;
masterXfer.dataSize = I2C_DATA_LENGTH;
masterXfer.flags = kI2C_TransferDefaultFlag;
I2C_MasterTransferDMA(EXAMPLE_I2C_MASTER_BASEADDR, &g_m_dma_handle, &masterXfer);
/* wait for transfer completed. */
while (!completionFlag)
{
}
completionFlag = false;
/*6.Transfer completed. Check the data.*/
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
if (g_slave_buff[i] != g_master_buff[i])
{
PRINTF("\r\nError occured in the transfer ! \r\n");
break;
}
}
PRINTF("Master received data :");
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
if (i % 8 == 0)
{
PRINTF("\r\n");
}
PRINTF("0x%2x ", g_master_buff[i]);
}
PRINTF("\r\n\r\n");
PRINTF("\r\nEnd of I2C example .\r\n");
while (1)
{
}
}
/*!
* @brief main function
*/
int main(void)
{
int32_t currentTemperature = 0;
uint32_t updateBoundariesCounter = 0;
int32_t tempArray[UPDATE_BOUNDARIES_TIME * 2];
lowPowerAdcBoundaries_t boundaries;
/* Init hardware */
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
/* Init using Led in Demo app */
LED1_INIT();
LED2_INIT();
/* Set to allow entering vlps mode */
SMC_SetPowerModeProtection(SMC, kSMC_AllowPowerModeVlp);
/* Calibrate param Temperature sensor */
ADC16_CalibrateParams(DEMO_ADC16_BASEADDR);
/* Initialize Demo ADC */
if (!ADC16_InitHardwareTrigger(DEMO_ADC16_BASEADDR))
{
PRINTF("Failed to do the ADC init\r\n");
return -1;
}
PRINTF("\n\r ADC LOW POWER DEMO\n");
PRINTF("\r The Low Power ADC project is designed to work with the Tower System or in a stand alone setting\n\n");
PRINTF("\r 1. Set your target board in a place where the temperature is constant.\n");
PRINTF("\r 2. Wait until two Led light turns on.\n");
PRINTF("\r 3. Increment or decrement the temperature to see the changes.\n");
PRINTF("\r Wait two led on...\n\r");
/* setup the HW trigger source */
LPTMR_InitTriggerSourceOfAdc(DEMO_LPTMR_BASE);
ADC16_EnableDMA(DEMO_ADC16_BASEADDR, false);
NVIC_EnableIRQ(DEMO_ADC16_IRQ_ID);
/* Warm up microcontroller and allow to set first boundaries */
while (updateBoundariesCounter < (UPDATE_BOUNDARIES_TIME * 2))
{
while (!conversionCompleted)
{
}
currentTemperature = GetCurrentTempValue();
tempArray[updateBoundariesCounter] = currentTemperature;
updateBoundariesCounter++;
conversionCompleted = false;
}
/* Temp Sensor Calibration */
boundaries = TempSensorCalibration(updateBoundariesCounter, tempArray);
updateBoundariesCounter = 0;
/* Two LED is turned on indicating calibration is done */
LED1_ON();
LED2_ON();
/* Wait for user input before beginning demo */
PRINTF("\r Enter any character to begin...\n");
GETCHAR();
PRINTF("\r ---> OK! Main process is running...!\n");
while (1)
{
/* Prevents the use of wrong values */
while (!conversionCompleted)
{
}
/* Get current Temperature Value */
currentTemperature = GetCurrentTempValue();
/* Store temperature values that are going to be use to calculate average temperature */
tempArray[updateBoundariesCounter] = currentTemperature;
if (currentTemperature > boundaries.upperBoundary)
{
LED2_OFF();
LED1_ON();
}
else if (currentTemperature < boundaries.lowerBoundary)
{
LED2_ON();
LED1_OFF();
}
else
{
LED2_ON();
LED1_ON();
}
/* Call update function */
if (updateBoundariesCounter >= (UPDATE_BOUNDARIES_TIME))
{
boundaries = TempSensorCalibration(updateBoundariesCounter, tempArray);
updateBoundariesCounter = 0;
}
else
{
updateBoundariesCounter++;
}
/* Clear conversionCompleted flag */
conversionCompleted = false;
/* Enter to Very Low Power Stop Mode */
SMC_SetPowerModeVlps(SMC);
}
}
/*!
* @brief Main function
*/
int main(void)
{
uint32_t srcAddr[BUFFER_LENGTH] = {0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U};
uint32_t destAddr[BUFFER_LENGTH] = {0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U};
uint32_t i = 0;
edma_transfer_config_t transferConfig;
edma_tcd_t *tcdMemoryPoolPtr;
edma_config_t userConfig;
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
/* Print source buffer */
PRINTF("EDMA memory to memory transfer example begin.\r\n\r\n");
PRINTF("Destination Buffer:\r\n");
for (i = 0; i < BUFFER_LENGTH; i++)
{
PRINTF("%d\t", destAddr[i]);
}
/* Configure DMAMUX */
DMAMUX_Init(DMAMUX0);
DMAMUX_SetSource(DMAMUX0, 0, 63);
DMAMUX_EnableChannel(DMAMUX0, 0);
/* Configure EDMA one shot transfer */
/*
* userConfig.enableRoundRobinArbitration = false;
* userConfig.enableHaltOnError = true;
* userConfig.enableContinuousLinkMode = false;
* userConfig.enableDebugMode = false;
*/
EDMA_GetDefaultConfig(&userConfig);
EDMA_Init(DMA0, &userConfig);
EDMA_CreateHandle(&g_EDMA_Handle, DMA0, 0);
EDMA_SetCallback(&g_EDMA_Handle, EDMA_Callback, NULL);
EDMA_ResetChannel(g_EDMA_Handle.base, g_EDMA_Handle.channel);
/* Allocate TCD memory poll */
tcdMemoryPoolPtr = (edma_tcd_t *)malloc(sizeof(edma_tcd_t) * (TCD_QUEUE_SIZE + 1));
if (tcdMemoryPoolPtr != NULL)
{
tcdMemoryPoolPtr = (edma_tcd_t *)((uint32_t)(tcdMemoryPoolPtr + 1) & (~0x1FU));
EDMA_InstallTCDMemory(&g_EDMA_Handle, tcdMemoryPoolPtr, TCD_QUEUE_SIZE);
/* Configure and submit transfer structure 1 */
EDMA_PrepareTransfer(&transferConfig, srcAddr, sizeof(srcAddr[0]), destAddr, sizeof(destAddr[0]),
sizeof(srcAddr[0]), sizeof(srcAddr[0]) * HALF_BUFFER_LENGTH, kEDMA_MemoryToMemory);
EDMA_SubmitTransfer(&g_EDMA_Handle, &transferConfig);
/* Configure and submit transfer structure 2 */
EDMA_PrepareTransfer(&transferConfig, &srcAddr[4], sizeof(srcAddr[0]), &destAddr[4], sizeof(destAddr[0]),
sizeof(srcAddr[0]), sizeof(srcAddr[0]) * HALF_BUFFER_LENGTH, kEDMA_MemoryToMemory);
EDMA_SubmitTransfer(&g_EDMA_Handle, &transferConfig);
}
EDMA_StartTransfer(&g_EDMA_Handle);
/* Wait for EDMA transfer finish */
while (g_Transfer_Done != true)
{
}
/* Print destination buffer */
PRINTF("\r\n\r\nEDMA memory to memory transfer example finish.\r\n\r\n");
PRINTF("Destination Buffer:\r\n");
for (i = 0; i < BUFFER_LENGTH; i++)
{
PRINTF("%d\t", destAddr[i]);
}
while (1)
{
}
}
/*!
* @brief Main function
*/
int main(void)
{
i2c_slave_config_t slaveConfig;
i2c_master_config_t masterConfig;
uint32_t sourceClock;
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
PRINTF("\r\nI2C example -- MasterFunctionalInterrupt_SlaveFunctionalInterrupt.\r\n");
/* Enable master and slave NVIC interrupt. */
EnableIRQ(I2C_MASTER_IRQ);
EnableIRQ(I2C_SLAVE_IRQ);
/* Set i2c slave interrupt priority higher. */
NVIC_SetPriority(I2C_SLAVE_IRQ, 0);
NVIC_SetPriority(I2C_MASTER_IRQ, 1);
/*1.Set up i2c slave first*/
/*
* slaveConfig.addressingMode = kI2C_Address7bit;
* slaveConfig.enableGeneralCall = false;
* slaveConfig.enableWakeUp = false;
* slaveConfig.enableHighDrive = false;
* slaveConfig.enableBaudRateCtl = false;
* slaveConfig.enableSlave = true;
*/
I2C_SlaveGetDefaultConfig(&slaveConfig);
slaveConfig.addressingMode = kI2C_Address7bit;
slaveConfig.slaveAddress = I2C_MASTER_SLAVE_ADDR_7BIT;
I2C_SlaveInit(EXAMPLE_I2C_SLAVE_BASEADDR, &slaveConfig);
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
g_slave_buff[i] = 0;
}
/*2.Set up i2c master to send data to slave*/
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
g_master_buff[i] = i;
}
PRINTF("Master will send data :");
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
if (i % 8 == 0)
{
PRINTF("\r\n");
}
PRINTF("0x%2x ", g_master_buff[i]);
}
PRINTF("\r\n\r\n");
/*
* masterConfig.baudRate_Bps = 100000U;
* masterConfig.enableHighDrive = false;
* masterConfig.enableStopHold = false;
* masterConfig.glitchFilterWidth = 0U;
* masterConfig.enableMaster = true;
*/
I2C_MasterGetDefaultConfig(&masterConfig);
masterConfig.baudRate_Bps = I2C_BAUDRATE;
sourceClock = CLOCK_GetFreq(I2C_MASTER_CLK_SRC);
I2C_MasterInit(EXAMPLE_I2C_MASTER_BASEADDR, &masterConfig, sourceClock);
/* Master send address to slave. */
I2C_MasterStart(EXAMPLE_I2C_MASTER_BASEADDR, I2C_MASTER_SLAVE_ADDR_7BIT, kI2C_Write);
/* Enable module interrupt. */
I2C_EnableInterrupts(EXAMPLE_I2C_MASTER_BASEADDR, kI2C_GlobalInterruptEnable);
I2C_EnableInterrupts(EXAMPLE_I2C_SLAVE_BASEADDR, kI2C_GlobalInterruptEnable);
/* Wait slave receive finished. */
while (g_slaveRxIndex < I2C_DATA_LENGTH)
{
}
/* Disable module interrupt. */
I2C_DisableInterrupts(EXAMPLE_I2C_MASTER_BASEADDR, kI2C_GlobalInterruptEnable);
I2C_DisableInterrupts(EXAMPLE_I2C_SLAVE_BASEADDR, kI2C_GlobalInterruptEnable);
/* Master send stop command. */
I2C_MasterStop(EXAMPLE_I2C_MASTER_BASEADDR);
/*3.Transfer completed. Check the data.*/
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
if (g_slave_buff[i] != g_master_buff[i])
{
PRINTF("\r\nError occured in this transfer ! \r\n");
break;
}
}
PRINTF("Slave received data :");
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
if (i % 8 == 0)
{
PRINTF("\r\n");
}
PRINTF("0x%2x ", g_slave_buff[i]);
}
PRINTF("\r\n\r\n");
/*4.Set up slave ready to send data to master.*/
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
g_slave_buff[i] = ~g_slave_buff[i];
}
PRINTF("This time , slave will send data: :");
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
if (i % 8 == 0)
{
PRINTF("\r\n");
}
PRINTF("0x%2x ", g_slave_buff[i]);
}
PRINTF("\r\n\r\n");
/* Already setup the slave transfer ready in item 1. */
/* 5.Set up master to receive data from slave. */
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
g_master_buff[i] = 0;
}
/* Master send address to slave. */
I2C_MasterStart(EXAMPLE_I2C_MASTER_BASEADDR, I2C_MASTER_SLAVE_ADDR_7BIT, kI2C_Read);
/* Enable module interrupt. */
I2C_EnableInterrupts(EXAMPLE_I2C_MASTER_BASEADDR, kI2C_GlobalInterruptEnable);
I2C_EnableInterrupts(EXAMPLE_I2C_SLAVE_BASEADDR, kI2C_GlobalInterruptEnable);
g_masterReadBegin = true;
/* Master put receive data in receive buffer. */
g_masterRxIndex = 0;
/* Wait master receive finished. */
while (g_masterRxIndex < I2C_DATA_LENGTH)
{
}
/* Disable module interrupt. */
I2C_DisableInterrupts(EXAMPLE_I2C_MASTER_BASEADDR, kI2C_GlobalInterruptEnable);
I2C_DisableInterrupts(EXAMPLE_I2C_SLAVE_BASEADDR, kI2C_GlobalInterruptEnable);
/*6.Transfer completed. Check the data.*/
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
if (g_slave_buff[i] != g_master_buff[i])
{
PRINTF("\r\nError occured in the transfer ! \r\n");
break;
}
}
PRINTF("Master received data :");
for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++)
{
if (i % 8 == 0)
{
PRINTF("\r\n");
}
PRINTF("0x%2x ", g_master_buff[i]);
}
PRINTF("\r\n\r\n");
PRINTF("\r\nEnd of I2C example .\r\n");
while (1)
{
}
}
/*!
* @brief Main function
*/
int main(void)
{
/* Variables */
volatile uint32_t j;
/* Data to write to MRAM */
const uint32_t wdata = 0xDDCCBBAAU;
/* Variable to read MRAM */
uint32_t rdata;
uint32_t n;
int32_t *p_mram = (int32_t *)MRAM_START_ADDRESS;
bool result = true;
/* FlexBus configuration structure */
flexbus_config_t flexbusUserConfig;
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
PRINTF("\r\nFLEXBUS Example.\r\n");
/*
* Initialize configurations for MRAM.
* Refer application note: AN4393.
*/
/* Get default config */
/*
* flexbusUserConfig.writeProtect = 0;
* flexbusUserConfig.burstWrite = 0;
* flexbusUserConfig.burstRead = 0;
* flexbusUserConfig.byteEnableMode = 0;
* flexbusUserConfig.autoAcknowledge = true;
* flexbusUserConfig.extendTransferAddress = 0;
* flexbusUserConfig.secondaryWaitStates = 0;
* flexbusUserConfig.byteLaneShift = kFLEXBUS_NotShifted;
* flexbusUserConfig.writeAddressHold = kFLEXBUS_Hold1Cycle;
* flexbusUserConfig.readAddressHold = kFLEXBUS_Hold1Or0Cycles;
* flexbusUserConfig.addressSetup = kFLEXBUS_FirstRisingEdge;
* flexbusUserConfig.portSize = kFLEXBUS_1Byte;
* flexbusUserConfig.group1MultiplexControl = kFLEXBUS_MultiplexGroup1_FB_ALE;
* flexbusUserConfig.group2MultiplexControl = kFLEXBUS_MultiplexGroup2_FB_CS4;
* flexbusUserConfig.group3MultiplexControl = kFLEXBUS_MultiplexGroup3_FB_CS5;
* flexbusUserConfig.group4MultiplexControl = kFLEXBUS_MultiplexGroup4_FB_TBST;
* flexbusUserConfig.group5MultiplexControl = kFLEXBUS_MultiplexGroup5_FB_TA;
*/
FLEXBUS_GetDefaultConfig(&flexbusUserConfig);
/* Configure some parameters when using MRAM */
flexbusUserConfig.waitStates = 2U; /* Wait 2 states */
flexbusUserConfig.chipBaseAddress = MRAM_START_ADDRESS; /* MRAM address for using FlexBus */
flexbusUserConfig.chipBaseAddressMask = 7U; /* 512 Kbytes memory size */
PRINTF("\r\nInitialize FLEXBUS.\r\n");
/* Initialize and configure FLEXBUS module */
FLEXBUS_Init(FB, &flexbusUserConfig);
PRINTF("\r\nStart write/read MRAM.\r\n");
/* Waiting some times */
for (j = 0; j < 0xFFFFFFU; j++)
{
__NOP();
}
for (n = 0x0; n < 0xFU; n++)
{
/* Write data to MRAM */
*(p_mram + n) = wdata;
}
/* Waiting some times */
for (j = 0; j < 0xFFFFU; j++)
{
__NOP();
}
for (n = 0x0; n < 0xFU; n++)
{
/* Read data back from MRAM */
rdata = *(p_mram + n);
/* Verify that rdata equals to wdata */
if (rdata != wdata)
{
result = false;
break;
}
}
if (result)
{
PRINTF("\r\nFLEXBUS (MRAM) test: succeed.\r\n");
}
else
{
PRINTF("\r\nFLEXBUS (MRAM) test: failed.\r\n");
}
FLEXBUS_Deinit(FB);
while (1)
{
}
}
