/*!
* @brief main function
*/
int main(void)
{
struct netif fsl_netif0;
ip_addr_t fsl_netif0_ipaddr, fsl_netif0_netmask, fsl_netif0_gw;
app_low_level_init();
OSA_Init();
lwip_init();
IP4_ADDR(&fsl_netif0_ipaddr, 192,168,2,102);
IP4_ADDR(&fsl_netif0_netmask, 255,255,255,0);
IP4_ADDR(&fsl_netif0_gw, 192,168,2,100);
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);
echo_init();
#if !ENET_RECEIVE_ALL_INTERRUPT
uint32_t devNumber = 0;
enet_dev_if_t * enetIfPtr;
#if LWIP_HAVE_LOOPIF
devNumber = fsl_netif0.num - 1;
#else
devNumber = fsl_netif0.num;
#endif
enetIfPtr = (enet_dev_if_t *)&enetDevIf[devNumber];
#endif
while(1)
{
#if !ENET_RECEIVE_ALL_INTERRUPT
ENET_receive(enetIfPtr);
#endif
sys_check_timeouts();
}
}
int main( void )
{
// Target board initialisation
BoardInitMcu();
LOG_DEBUG("Mcu initialized.");
OSA_Init();
LOG_DEBUG("OS initialized.");
BoardInitPeriph();
LOG_DEBUG("Peripherals initialized.");
// These tasks will not start in BM.
s_result = OSA_TaskCreate(task_led_rtos, (uint8_t *) "led_rtos", TASK_LED_RTOS_STACK_SIZE,
task_led_rtos_stack, TASK_LED_RTOS_PRIO, (task_param_t) 0, false,
&task_led_rtos_task_handler);
if ( s_result != kStatus_OSA_Success ) {
LOG_ERROR("Failed to create led_rtos task");
}
s_result = OSA_TaskCreate(task_fxos_rtos, (uint8_t *) "fxos_rtos", TASK_FXOS_RTOS_STACK_SIZE,
task_fxos_rtos_stack, TASK_FXOS_RTOS_PRIO, (task_param_t) 0, false,
&task_fxos_rtos_task_handler);
if ( s_result != kStatus_OSA_Success ) {
LOG_ERROR("Failed to create fxos_rtos task");
}
// Print the initial banner
LOG_DEBUG("Hello World!\r\n");
OSA_Start();
for ( ;; ) {
} // Should not achieve here
}
void init_platform( void )
{
PORT_HAL_SetMuxMode(PORTC_BASE,3u,kPortMuxAsGpio);
PORT_HAL_SetMuxMode(PORTC_BASE,4u,kPortMuxAsGpio);
GPIO_DRV_OutputPinInit(&ledPins[0]);
GPIO_DRV_OutputPinInit(&ledPins[1]);
OSA_Init();
}
int main(void)
{
/* Initialize board hardware */
hardware_init();
OSA_Init();
/* Initialize debug serial interface */
dbg_uart_init();
/* Call example task */
ltc_example_task();
while(1);
}
/*!
* @brief main function
*/
int main(void)
{
#if FSL_FEATURE_ADC16_HAS_CALIBRATION
adc16_calibration_param_t tempSnseCalibraitionParam;
#endif
hardware_init();
GPIO_DRV_Init(NULL, ledPins);
// Configure the power mode protection
SMC_HAL_SetProtection(SMC_BASE_PTR, kAllowPowerModeVlp);
ADC16_DRV_StructInitUserConfigDefault(&tempSnseAdcConfig);
#if (FSL_FEATURE_ADC16_MAX_RESOLUTION >= 16)
tempSnseAdcConfig.resolution = kAdc16ResolutionBitOf16;
#endif
#if BOARD_ADC_USE_ALT_VREF
tempSnseAdcConfig.refVoltSrc = kAdc16RefVoltSrcOfValt;
#endif
// Init ADC
ADC16_DRV_Init(ADC_INSTANCE, &tempSnseAdcConfig);
// Calibrate VDD and ADCR_TEMP25
#if FSL_FEATURE_ADC16_HAS_CALIBRATION
// Auto calibraion
ADC16_DRV_GetAutoCalibrationParam(ADC_INSTANCE, &tempSnseCalibraitionParam);
ADC16_DRV_SetCalibrationParam(ADC_INSTANCE, &tempSnseCalibraitionParam);
#endif // FSL_FEATURE_ADC16_HAS_CALIBRATION
calibrateParams();
// get cpu uid low value for slave
gSlaveId = SIM_UIDL_UID(SIM_BASE_PTR);
PRINTF("i2c_rtos_slave_bm demo\r\n");
// task list initialize
OSA_Init();
// create task(in BM: only the first registered task can be executed)
OSA_TaskCreate(task_slave,
(uint8_t *)"slave",
512,
task_slave_stack,
0,
(void *)0,
false,
&task_slave_task_handler);
OSA_Start();
return 0;
}
/*
main
Note:
Program entry, do nessary initialization and lanuch scheduler, in baremetal OSA, it simplely call all tasks in sequence
*/
int main(void)
{
OSA_Init();
hardware_init();
dbg_uart_init();
comm_init();
audio_init();
usb_init();
OS_Task_create(usb_user_task, NULL, 9L, 3000L, "usb task", NULL);
OSA_Start();
return 1;
}
int main (void)
{
OS_ERR err;
#if (CPU_CFG_NAME_EN == DEF_ENABLED)
CPU_ERR cpu_err;
#endif
hardware_init();
GPIO_DRV_Init(switchPins, ledPins);
#if (CPU_CFG_NAME_EN == DEF_ENABLED)
CPU_NameSet((CPU_CHAR *)"MK64FN1M0VMD12",
(CPU_ERR *)&cpu_err);
#endif
OSA_Init(); /* Init uC/OS-III. */
OSSemCreate(&MySem1, /* Create Semaphore 1 */
"sem 1",
0,
&err);
OSSemCreate(&MySem2, /* Create Semaphore 2 */
"sem 2",
0,
&err);
INT_SYS_InstallHandler(PORTC_IRQn, SW1_Intr_Handler); // associate ISR with sw1 intr source
INT_SYS_InstallHandler(PORTA_IRQn, SW2_Intr_Handler); // associate ISR with sw2 intr source
OSTaskCreate(&AppTaskStartTCB, /* Create the start task */
"App Task Start",
AppTaskStart,
0u,
APP_CFG_TASK_START_PRIO,
&AppTaskStartStk[0u],
(APP_CFG_TASK_START_STK_SIZE / 10u),
APP_CFG_TASK_START_STK_SIZE,
0u,
0u,
0u,
(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR | OS_OPT_TASK_SAVE_FP),
&err);
OSA_Start(); /* Start multitasking (i.e. give control to uC/OS-III). */
while (DEF_ON) { /* Should Never Get Here */
;
}
}
/*!
* @brief Check send/receive blocking with DMA
*
*/
int main(void)
{
uint8_t rxChar = 0, txChar = 0;
uint32_t byteCountBuff = 0;
dma_state_t state;
lpsci_dma_state_t lpsciStateDma;
lpsci_dma_user_config_t lpsciConfig = {
#if defined(KL02Z4_SERIES)
.clockSource = kClockLpsciSrcFll,
#else
.clockSource = kClockLpsciSrcPllFllSel,
#endif
.bitCountPerChar = kLpsci8BitsPerChar,
.parityMode = kLpsciParityDisabled,
.stopBitCount = kLpsciOneStopBit,
.baudRate = BOARD_DEBUG_UART_BAUD
};
// Enable clock for PORTs, setup board clock source, config pin
hardware_init();
// Call OSA_Init to setup LP Timer for timeout
OSA_Init();
// Initialize DMA module for LPSCI
DMA_DRV_Init(&state);
LPSCI_DRV_DmaInit(BOARD_DEBUG_UART_INSTANCE, &lpsciStateDma, &lpsciConfig);
// Inform to start polling example
byteCountBuff = sizeof(buffStart);
LPSCI_DRV_DmaSendDataBlocking(BOARD_DEBUG_UART_INSTANCE, buffStart, byteCountBuff, 1000u);
// Inform user of what to do
byteCountBuff = sizeof(bufferData1);
LPSCI_DRV_DmaSendDataBlocking(BOARD_DEBUG_UART_INSTANCE, bufferData1, byteCountBuff, 1000u);
while(true)
{
// Wait to receive input data
if (kStatus_LPSCI_Success == LPSCI_DRV_DmaReceiveDataBlocking(BOARD_DEBUG_UART_INSTANCE, &rxChar, 1u, OSA_WAIT_FOREVER))
{
// Echo received character
txChar = rxChar;
LPSCI_DRV_DmaSendDataBlocking(BOARD_DEBUG_UART_INSTANCE, &txChar, 1u, 1000u);
}
}
}
/*!
* @brief The i2c slave
* The function runs i2c slave with interrupt active mode. Slave receive data from
* master and echo back to master
*/
void main(void)
{
// Number byte data will be transfer
uint32_t count = 0;
// Buffer store data to transfer
uint8_t dataBuff[100] = {0};
// state of slave
i2c_slave_state_t slave;
// user configuration
i2c_slave_user_config_t userConfig =
{
.address = 0x7FU,
.slaveCallback = NULL,
.callbackParam = NULL,
.slaveListening = false,
#if FSL_FEATURE_I2C_HAS_START_STOP_DETECT
.startStopDetect = false,
#endif
#if FSL_FEATURE_I2C_HAS_STOP_DETECT
.stopDetect = false,
#endif
};
// Initialize hardware
hardware_init();
// Configure pin for i2c slave
configure_i2c_pins(BOARD_I2C_COMM_INSTANCE);
// Initialize uart to debug
dbg_uart_init();
// Initialize OSA
OSA_Init();
printf("Slave is running ...");
// Initialize slave
I2C_DRV_SlaveInit(BOARD_I2C_COMM_INSTANCE, &userConfig, &slave);
// Loop transfer
while(1)
{
// Slave receive 1 byte from master
I2C_DRV_SlaveReceiveDataBlocking(BOARD_I2C_COMM_INSTANCE, (uint8_t*)&count, 1, OSA_WAIT_FOREVER);
// Slave receive buffer from master
I2C_DRV_SlaveReceiveDataBlocking(BOARD_I2C_COMM_INSTANCE, dataBuff, count, 1000);
// Slave send buffer received from master
I2C_DRV_SlaveSendDataBlocking(BOARD_I2C_COMM_INSTANCE, dataBuff, count, 1000);
}
}
int main(void)
#endif
{
hardware_init();
OSA_Init();
dbg_uart_init();
#if !(USE_RTOS)
APP_init();
#endif
OS_Task_create(Task_Start, NULL, 4L, 3000L, "task_start", NULL);
OSA_Start();
#if !defined(FSL_RTOS_MQX)
return 1;
#endif
}
int main(void)
{
uart_state_t uartState; // user provides memory for the driver state structure
uart_user_config_t uartConfig;
long int x;
char AT[] = "\nAT";
char rxBuff[10];
uint32_t byteCountBuff = 0;
//Initialise the FRDM-KL26Z Board
hardware_init();
configure_uart_pins(0); //instance 0 is UART1???
// Call OSA_Init to setup LP Timer for timeout
OSA_Init();
uartConfig.baudRate = 9600;
uartConfig.bitCountPerChar = kUart8BitsPerChar;
uartConfig.parityMode = kUartParityDisabled;
uartConfig.stopBitCount = kUartOneStopBit;
UART_DRV_Init(1, &uartState,&uartConfig);
//Print message to serial terminal
PRINTF("First Embedded Systems Lab_Aonghus\r\n");
PRINTF("Type a character and it will be echoed back\r\n\n");
int i = 0;
byteCountBuff = sizeof(AT);
while(1) {
//UART_DRV_SendDataBlocking(1, AT, byteCountBuff, 16000u);
while(UART_DRV_ReceiveDataBlocking ( 1, rxBuff, sizeof(rxBuff),16000u) == kStatus_UART_Success )
{
for(i=0;i<sizeof(rxBuff);i++)
PRINTF("%c",rxBuff[i]);
}
// if(UART_DRV_GetTransmitStatus (1,sizeof(rxBuff)) == kStatus_UART_Success ){
// }
for(x=0;x<10000000;x++);
}
/* Never leave main */
return 0;
}
int main (void)
{
OSA_Init();
/* Initialize clocks, debug console interface and configure required pins */
hardware_init();
/* Disable Memory Protection Unit */
MPU_HAL_Disable(MPU);
testPin.pinName = test_pin_name;
testPin.config.outputLogic = 0;
testPin.config.slewRate = kPortFastSlewRate;
testPin.config.driveStrength = kPortHighDriveStrength;
testPin.config.isOpenDrainEnabled = false;
GPIO_DRV_OutputPinInit(&testPin);
// Structure of initialize PIT channel No.0
pit_user_config_t chn0Confg;
chn0Confg.isInterruptEnabled = true;
chn0Confg.periodUs = 1000000u;
// Init pit module and enable run in debug
PIT_DRV_Init(BOARD_PIT_INSTANCE, false);
// Initialize PIT timer instance for channel 0 and 1
PIT_DRV_InitChannel(BOARD_PIT_INSTANCE, 0, &chn0Confg);
// Start channel 0
PRINTF("\n\rStarting channel No.0 ...");
PIT_DRV_StartTimer(BOARD_PIT_INSTANCE, 0);
// drv_Mpu9250.Init();
sdCard.Init(1);
OSA_TaskCreate((task_t)MainTask, (uint8_t*)"Main Task", 4096, NULL, 2, NULL, true, NULL);
//OSA_TaskCreate((task_t)FnetTask, (uint8_t*)"FNET Task", 2048, NULL, 3, NULL, true, NULL);
OSA_Start(); // This function will not return
while(1);
return(0);
}
/*!
* @brief main function
*/
int main(void)
{
ip_addr_t fsl_netif0_ipaddr, fsl_netif0_netmask, fsl_netif0_gw;
app_low_level_init();
OSA_Init();
lwip_init();
IP4_ADDR(&fsl_netif0_ipaddr, 192,168,2,102);
IP4_ADDR(&fsl_netif0_netmask, 255,255,255,0);
IP4_ADDR(&fsl_netif0_gw, 192,168,2,100);
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);
ping_init();
return 0;
}
void main(void)
#endif
#endif
{
hardware_init();
OSA_Init();
dbg_uart_init();
#if !(USE_RTOS)
APP_init();
#endif
OS_Task_create(Task_Start, NULL, 4L, 1000L, "task_start", NULL);
OSA_Start();
#if (!defined(FSL_RTOS_MQX))&(defined(__CC_ARM) || defined(__GNUC__))
return 1;
#endif
}
int main(void)
#endif
{
ip_addr_t fsl_netif0_ipaddr, fsl_netif0_netmask, fsl_netif0_gw;
app_low_level_init();
OSA_Init();
LWIP_DEBUGF(PING_DEBUG,("TCP/IP initializing...\r\n"));
tcpip_init(NULL,NULL);
LWIP_DEBUGF(PING_DEBUG,("TCP/IP initialized.\r\n"));
IP4_ADDR(&fsl_netif0_ipaddr, 192,168,2,102);
IP4_ADDR(&fsl_netif0_netmask, 255,255,255,0);
IP4_ADDR(&fsl_netif0_gw, 192,168,2,100);
netif_add(&fsl_netif0, &fsl_netif0_ipaddr, &fsl_netif0_netmask, &fsl_netif0_gw, NULL, ethernetif_init, tcpip_input);
netif_set_default(&fsl_netif0);
ping_init();
}
int main (void)
{
OS_ERR err;
#if (CPU_CFG_NAME_EN == DEF_ENABLED)
CPU_ERR cpu_err;
#endif
hardware_init();
GPIO_DRV_Init(switchPins, ledPins);
#if (CPU_CFG_NAME_EN == DEF_ENABLED)
CPU_NameSet((CPU_CHAR *)"MK64FN1M0VMD12",
(CPU_ERR *)&cpu_err);
#endif
OSA_Init(); /* Init uC/OS-III. */
OSTaskCreate(&AppTaskStartTCB, /* Create the start task */
"App Task Start",
AppTaskStart,
0u,
APP_CFG_TASK_START_PRIO,
&AppTaskStartStk[0u],
(APP_CFG_TASK_START_STK_SIZE / 10u),
APP_CFG_TASK_START_STK_SIZE,
0u,
0u,
0u,
(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR | OS_OPT_TASK_SAVE_FP),
&err);
OSA_Start(); /* Start multitasking (i.e. give control to uC/OS-III). */
while (DEF_ON) { /* Should Never Get Here */
;
}
}
int main (void)
{
/***************************************************************************
* RX buffers
**************************************************************************/
/*! @param receiveBuff Buffer used to hold received data */
uint8_t receiveBuff[19] = {0};
/* Initialize standard SDK demo application pins */
hardware_init();
/* Configure the UART TX/RX pins */
configure_uart_pins(BOARD_DEBUG_UART_INSTANCE);
#ifdef USE_STDIO_FUNCTIONS
/* Call this function to initialize the console UART. This function
enables the use of STDIO functions (printf, scanf, etc.) */
dbg_uart_init();
/* Print the initial banner */
printf("\r\nHello World!\n\n\r");
while(1)
{
/********************************************
* Main routine that simply echoes received
* characters forever
*********************************************/
/* First, get character. */
receiveBuff[0] = getchar();
/* Now echo the received character */
putchar(receiveBuff[0]);
}
#else
/***************************************************************************
* UART configuration and state structures
**************************************************************************/
/*! @param uartConfig UART configuration structure */
/*! @param uartState UARt state structure which is used internally by the*/
/*! by the UART driver to keep track of the UART states */
uart_user_config_t uartConfig;
uart_state_t uartState;
/***************************************************************************
* TX buffers
**************************************************************************/
/*! @param sourceBuff Buffer used to hold the string to be transmitted */
uint8_t sourceBuff[19] = {"\r\nHello World!\n\n\r"};
/* Configure the UART for 115200, 8 data bits, No parity, and one stop bit*/
uartConfig.baudRate = 115200;
uartConfig.bitCountPerChar = kUart8BitsPerChar;
uartConfig.parityMode = kUartParityDisabled;
uartConfig.stopBitCount = kUartOneStopBit;
/* Must call the OSA Init function to use Communication drivers */
OSA_Init();
/* Initialize the UART module */
UART_DRV_Init(BOARD_DEBUG_UART_INSTANCE, &uartState, &uartConfig);
/* Print the initial banner */
UART_DRV_SendDataBlocking(BOARD_DEBUG_UART_INSTANCE, sourceBuff, 17, 200);
while(1)
{
/********************************************
* Main routine that simply echoes received
* characters forever
*********************************************/
/* First, get character. */
UART_DRV_ReceiveDataBlocking(BOARD_DEBUG_UART_INSTANCE, receiveBuff, 1,
OSA_WAIT_FOREVER);
/* Now, stuff the buffer for the TX side and send the character*/
sourceBuff[0] = receiveBuff[0];
/* Now echo the received character */
UART_DRV_SendDataBlocking(BOARD_DEBUG_UART_INSTANCE, sourceBuff, 1,
200);
}
#endif
}
/*!
* @brief DSPI master Polling.
*
* Thid function uses DSPI master to send an array to slave
* and receive the array back from slave,
* thencompare whether the two buffers are the same.
*/
int main(void)
{
uint32_t i;
uint32_t loopCount = 1;
SPI_Type * dspiBaseAddr = (SPI_Type*)SPI0_BASE;
uint32_t dspiSourceClock;
uint32_t calculatedBaudRate;
dspi_device_t masterDevice;
dspi_command_config_t commandConfig =
{
.isChipSelectContinuous = false,
.whichCtar = kDspiCtar0,
.whichPcs = kDspiPcs0,
.clearTransferCount = true,
.isEndOfQueue = false
};
// Init hardware
hardware_init();
// Init OSA layer, used in DSPI_DRV_MasterTransferBlocking.
OSA_Init();
// Call this function to initialize the console UART. This function
// enables the use of STDIO functions (printf, scanf, etc.)
dbg_uart_init();
// Print a note.
printf("\r\n DSPI board to board polling example");
printf("\r\n This example run on instance 0 ");
printf("\r\n Be sure DSPI0-DSPI0 are connected ");
// Configure SPI pins.
configure_spi_pins(DSPI_MASTER_INSTANCE);
// Enable DSPI clock.
CLOCK_SYS_EnableSpiClock(DSPI_MASTER_INSTANCE);
// Initialize the DSPI module registers to default value, which disables the module
DSPI_HAL_Init(dspiBaseAddr);
// Set to master mode.
DSPI_HAL_SetMasterSlaveMode(dspiBaseAddr, kDspiMaster);
// Configure for continuous SCK operation
DSPI_HAL_SetContinuousSckCmd(dspiBaseAddr, false);
// Configure for peripheral chip select polarity
DSPI_HAL_SetPcsPolarityMode(dspiBaseAddr, kDspiPcs0, kDspiPcs_ActiveLow);
// Disable FIFO operation.
DSPI_HAL_SetFifoCmd(dspiBaseAddr, false, false);
// Initialize the configurable delays: PCS-to-SCK, prescaler = 0, scaler = 1
DSPI_HAL_SetDelay(dspiBaseAddr, kDspiCtar0, 0, 1, kDspiPcsToSck);
// DSPI system enable
DSPI_HAL_Enable(dspiBaseAddr);
// Configure baudrate.
masterDevice.dataBusConfig.bitsPerFrame = 8;
masterDevice.dataBusConfig.clkPhase = kDspiClockPhase_FirstEdge;
masterDevice.dataBusConfig.clkPolarity = kDspiClockPolarity_ActiveHigh;
masterDevice.dataBusConfig.direction = kDspiMsbFirst;
DSPI_HAL_SetDataFormat(dspiBaseAddr, kDspiCtar0, &masterDevice.dataBusConfig);
// Get DSPI source clock.
dspiSourceClock = CLOCK_SYS_GetSpiFreq(DSPI_MASTER_INSTANCE);
calculatedBaudRate = DSPI_HAL_SetBaudRate(dspiBaseAddr, kDspiCtar0, TRANSFER_BAUDRATE, dspiSourceClock);
printf("\r\n Transfer at baudrate %lu \r\n", calculatedBaudRate);
while(1)
{
// Initialize the transmit buffer.
for (i = 0; i < TRANSFER_SIZE; i++)
{
sendBuffer[i] = i + loopCount;
}
// Print out transmit buffer.
printf("\r\n Master transmit:");
for (i = 0; i < TRANSFER_SIZE; i++)
{
// Print 16 numbers in a line.
if ((i & 0x0F) == 0)
{
printf("\r\n ");
}
printf(" %02X", sendBuffer[i]);
}
// Reset the receive buffer.
for (i = 0; i < TRANSFER_SIZE; i++)
{
receiveBuffer[i] = 0;
}
// Restart the transfer by stop then start again, this will clear out the shift register
DSPI_HAL_StopTransfer(dspiBaseAddr);
// Flush the FIFOs
DSPI_HAL_SetFlushFifoCmd(dspiBaseAddr, true, true);
// Clear status flags that may have been set from previous transfers.
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiTxComplete);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiEndOfQueue);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiTxFifoUnderflow);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiTxFifoFillRequest);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiRxFifoOverflow);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiRxFifoDrainRequest);
// Clear the transfer count.
DSPI_HAL_PresetTransferCount(dspiBaseAddr, 0);
// Start the transfer process in the hardware
DSPI_HAL_StartTransfer(dspiBaseAddr);
// Send the data to slave.
for (i = 0; i < TRANSFER_SIZE; i++)
{
// Write data to PUSHR
DSPI_HAL_WriteDataMastermodeBlocking(dspiBaseAddr, &commandConfig, sendBuffer[i]);
// Delay to wait slave is ready.
OSA_TimeDelay(1);
}
// Delay to wait slave is ready.
OSA_TimeDelay(10);
// Restart the transfer by stop then start again, this will clear out the shift register
DSPI_HAL_StopTransfer(dspiBaseAddr);
// Flush the FIFOs
DSPI_HAL_SetFlushFifoCmd(dspiBaseAddr, true, true);
//Clear status flags that may have been set from previous transfers.
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiTxComplete);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiEndOfQueue);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiTxFifoUnderflow);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiTxFifoFillRequest);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiRxFifoOverflow);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiRxFifoDrainRequest);
// Clear the transfer count.
DSPI_HAL_PresetTransferCount(dspiBaseAddr, 0);
// Start the transfer process in the hardware
DSPI_HAL_StartTransfer(dspiBaseAddr);
// Receive the data from slave.
for (i = 0; i < TRANSFER_SIZE; i++)
{
// Write command to PUSHR.
DSPI_HAL_WriteDataMastermodeBlocking(dspiBaseAddr, &commandConfig, 0);
// Check RFDR flag
while (DSPI_HAL_GetStatusFlag(dspiBaseAddr, kDspiRxFifoDrainRequest)== false)
{}
// Read data from POPR
receiveBuffer[i] = DSPI_HAL_ReadData(dspiBaseAddr);
// Clear RFDR flag
DSPI_HAL_ClearStatusFlag(dspiBaseAddr,kDspiRxFifoDrainRequest);
// Delay to wait slave is ready.
OSA_TimeDelay(1);
}
// Print out receive buffer.
printf("\r\n Master 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]);
}
// Check receiveBuffer.
for (i = 0; i < TRANSFER_SIZE; ++i)
{
if (receiveBuffer[i] != sendBuffer[i])
{
// Master received incorrect.
printf("\r\n ERROR: master received incorrect ");
return -1;
}
}
printf("\r\n DSPI Master Sends/ Recevies Successfully");
// Wait for press any key.
printf("\r\n Press any key to run again");
getchar();
// Increase loop count to change transmit buffer.
loopCount++;
}
}
/************************* Configure for MQX************************************/
#if (defined FSL_RTOS_MQX)&&(MQX_COMMON_CONFIG == MQX_LITE_CONFIG)
#if MQX_STDIO
#error "MQX Lite configuration is designed to work with tool provided STD Library.\
Remove reference to MQX STD library from your build tool project options:\
IAR:\
Linker->Library->aditional_libraries - remove lib_mqx_stdlib.a path \
C/C++ Compiler->Preprocessor->Additional include directories: - remove mqx_stdlib \
\
KEIL: \
Linker->Misc controls - remove lib_mqx_stdlib.lib path \
C/C++->Include Paths - remove mqx_stdlib \
\
KDS: \
C/C++ Build\Settings->Cross ARM C Linker\Miscellaneous - remove lib_mqx_stdlib.a path\
C/C++ Build\Settings->Cross ARM C Compiler\Includes - remove mqx_stdlib (on 4th line)\
\
Atollic: \
C/C++ Build\Settings->C Linker/Libraries->Librarie search path - remove lib_mqx_stdlib \
C/C++ Build\Settings->C Compiler/Directories->Include Paths - remove mqx_stdlib \
CMAKE : \
Remove following lines from CMakeList.txt: \
INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../rtos/mqx/lib/twrk22f120m.armgcc/debug/mqx_stdlib) \
INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../rtos/mqx/lib/twrk22f120m.armgcc/release/mqx_stdlib) \
\
TARGET_LINK_LIBRARIES(lpm_rtos_mqx ${ProjDirPath}/../../../../../rtos/mqx/lib/twrk22f120m.armgcc/debug/mqx_stdlib/lib_mqx_stdlib.a) \
TARGET_LINK_LIBRARIES(lpm_rtos_mqx ${ProjDirPath}/../../../../../rtos/mqx/lib/twrk22f120m.armgcc/release/mqx_stdlib/lib_mqx_stdlib.a) \
."
#endif /* MQX_STDIO */
#elif (defined FSL_RTOS_MQX)&&(MQX_COMMON_CONFIG != MQX_LITE_CONFIG)
#define MAIN_TASK 8
void main_task(uint32_t param);
const TASK_TEMPLATE_STRUCT MQX_template_list[] =
{
{ MAIN_TASK, main_task, 0xC00, 20, "main_task", MQX_AUTO_START_TASK},
{ 0L, 0L, 0L, 0L, 0L, 0L }
};
#endif /* (FSL_RTOS_MQX)&&(MQX_COMMON_CONFIG != MQX_LITE_CONFIG) */
///////////////////////////////////////////////////////////////////////////////
// Code
///////////////////////////////////////////////////////////////////////////////
#if (defined FSL_RTOS_MQX) && (MQX_COMMON_CONFIG != MQX_LITE_CONFIG)
void main_task(uint32_t param)
#else /* (FSL_RTOS_MQX) && (MQX_COMMON_CONFIG != MQX_LITE_CONFIG) */
int main(void)
#endif /* (FSL_RTOS_MQX) && (MQX_COMMON_CONFIG != MQX_LITE_CONFIG) */
{
#if (defined FSL_RTOS_MQX)
// In deffault, MQX enables echo flag for stdin.
// For power manager demo, disable MQX flag to doesn't echo character.
ioctl( 0, IOCTL_NIO_TTY_SET_FLAGS, NIO_TTY_FLAGS_EOL_RN); // 0 - stdin
#endif
memset(&s_dbgState, 0, sizeof(s_dbgState));
hardware_init();
OSA_Init();
#if (!defined FSL_RTOS_MQX)
//init the uart module with base address and config structure
g_uartStatePtr[BOARD_DEBUG_UART_INSTANCE] = &s_dbgState;
/* Init the interrupt sync object. */
OSA_SemaCreate(&s_dbgState.txIrqSync, 0);
OSA_SemaCreate(&s_dbgState.rxIrqSync, 0);
NVIC_EnableIRQ(g_uartRxTxIrqId[BOARD_DEBUG_UART_INSTANCE]);
#endif
// Initializes GPIO driver for LEDs and buttons
#if (defined FSL_RTOS_BM)
GPIO_DRV_Init(switchPins, 0);
#else
GPIO_DRV_Init(switchPins, ledPins);
#endif
NVIC_SetPriority(PM_DBG_UART_IRQn, 6U);
NVIC_SetPriority(RTC_IRQn, 6U);
NVIC_SetPriority(LPTMR0_IRQn, 6U);
NVIC_SetPriority(ADC_IRQ_N, 6U);
NVIC_SetPriority(LLWU_IRQn, 6U);
#if (defined FSL_RTOS_MQX)
OSA_InstallIntHandler(PM_DBG_UART_IRQn, PM_MQX_DBG_UART_IRQ_HANDLER);
#endif
adc16Init(&adcUserConfig, &adcChnConfig, &adcCalibraitionParam);
// Low power manager task.
s_result = OSA_TaskCreate(task_lpm,
(uint8_t *)"lpm",
TASK_LPM_STACK_SIZE,
task_lpm_stack,
TASK_LPM_PRIO,
(task_param_t)0,
false,
&task_lpm_task_handler);
if (s_result != kStatus_OSA_Success)
{
PRINTF("Failed to create lpm task\r\n");
}
// These tasks will not start in BM.
#if (!defined FSL_RTOS_BM)
s_result = OSA_TaskCreate(task_led_rtos,
(uint8_t *)"led_rtos",
TASK_LED_RTOS_STACK_SIZE,
task_led_rtos_stack,
TASK_LED_RTOS_PRIO,
(task_param_t)0,
false,
&task_led_rtos_task_handler);
if (s_result != kStatus_OSA_Success)
{
PRINTF("Failed to create led_rtos task\r\n");
}
s_result = OSA_TaskCreate(task_led_clock,
(uint8_t *)"led_clock",
TASK_LED_CLOCK_STACK_SIZE,
task_led_clock_stack,
TASK_LED_CLOCK_PRIO,
(task_param_t)0,
false,
&task_led_clock_task_handler);
if (s_result != kStatus_OSA_Success)
{
PRINTF("Failed to create led_clock task\r\n");
}
#endif
OSA_Start();
for(;;) {} // Should not achieve here
}
int main(void)
{
uart_state_t uartState; // user provides memory for the driver state structure
uart_user_config_t uartConfig;
long int x;
int recieve_size=0;
char AT[] = "AT\r";
char CMGF[] = "AT+CMGF=1\r";
char CMGS[] = "AT+CMGS=\"+353877763894\"\r";
char MESSAGE[] = "HELLO AONGHUS KL26Z \x1A";
char response[200];
enum STATES {INIT,TXT_MODE,SEND_SMS,SEND_MSG};
enum STATES CurrentState = INIT;
uint32_t byteCountBuff = 0;
//Initialise the FRDM-KL26Z Board
hardware_init();
configure_uart_pins(0); //instance 0 is UART1???
// Call OSA_Init to setup LP Timer for timeout
OSA_Init();
uartConfig.baudRate = 9600;
uartConfig.bitCountPerChar = kUart8BitsPerChar;
uartConfig.parityMode = kUartParityDisabled;
uartConfig.stopBitCount = kUartOneStopBit;
UART_DRV_Init(1, &uartState,&uartConfig);
PRINTF("Full test of send/recieve on UART1\r\n");
int i = 0,y;
for(y=0;y<=sizeof(response);y++)
response[i]='c';
byteCountBuff = sizeof(AT);
wait_time = 16000u;
while(1){
switch(CurrentState){
case INIT: //Check connection to MODEM by sending AT. Expected response is OK
recieve_size =4;
byteCountBuff = sizeof(AT);
result = send_command(1,AT,byteCountBuff,wait_time,response,recieve_size);
if(result == SUCCESS){
printf("returned INIT\r\n");//"OK" was returned by MODEM
CurrentState = TXT_MODE;
}
break;
case TXT_MODE: //Check connection to MODEM by sending AT. Expected response is OK
recieve_size =4;
byteCountBuff = sizeof(CMGF);
result = send_command(1,CMGF,byteCountBuff,wait_time,response,recieve_size);
if(result == SUCCESS){
printf("returned TXT_MODE\r\n");//"OK" was returned by MODEM
CurrentState = SEND_SMS;
}
break;
case SEND_SMS: //Check connection to MODEM by sending AT. Expected response is OK
recieve_size = 2;
byteCountBuff = sizeof(CMGS);
result = send_command(1,CMGS,byteCountBuff,wait_time,response,recieve_size);
if(result == SUCCESS){
printf("returned SEND_SMS\r\n");//"OK" was returned by MODEM
CurrentState = SEND_MSG;
}
break;
case SEND_MSG: //Check connection to MODEM by sending AT. Expected response is OK
recieve_size =8;
byteCountBuff = sizeof(MESSAGE);
result = send_command(1,MESSAGE,byteCountBuff,wait_time,response,recieve_size);
if(result == SUCCESS){
printf("returned SEND_MSG\r\n");//"OK" was returned by MODEM
//CurrentState = CHECK_PIN;
}
break;
default:
break;
}//end switch-case
}
/* Never leave main */
return 0;
}
//void UART1_IRQHandler(void)
//{
// UART_DRV_IRQHandler(1);
//}
int main(void)
{
//Simple UART1
// // Init hardware
// uart_state_t uartState1; // user provides memory for the driver state structure
// uart_user_config_t uartConfig1;
//
// hardware_init();
// configure_uart_pins(0);
//
//
// OSA_Init();
//
//
// uartConfig1.baudRate = 9600;
// uartConfig1.bitCountPerChar = kUart8BitsPerChar;
// uartConfig1.parityMode = kUartParityDisabled;
// uartConfig1.stopBitCount = kUartOneStopBit;
//
//PRINTF("Just to init Uart\r");
// UART_DRV_Init(1, &uartState1, &uartConfig1);
// PRINTF("Uart initilized\n\r");
//
// while(1){
// PRINTF("About to send data\n\r");
//UART_DRV_SendDataBlocking(1, AT, sizeof(AT),16000u); // function
//// UART_DRV_ReceiveDataBlocking(1, &TXBUFF, 2,16000); // function
//// PRINTF("\n\rWho am i register value is: %01X", TXBUFF[0]);
//
// //PRINTF()
// PRINTF("Tried to sent some\n");
//
// }
//Accu init
i2c_master_state_t master;
i2c_device_t device =
{
.address = 0x1DU,
.baudRate_kbps = 400 // 400 Kbps
};
hardware_init();
UART2_config(9600);
enable_UART2_receive_interrupt();
i2cinitreg();
// Initialize OSA
OSA_Init();
// Initialize i2c master
I2C_DRV_MasterInit(I2C_INSTANCE_0, &master);
PRINTF("\r\n=INIT\r\n");
I2C_DRV_MasterReceiveDataBlocking(I2C_INSTANCE_0, &device,WHO_AM_I, 1, rxBuff, 1, 1000);
//Prints out values in recived register
PRINTF("\n\rWho am i register value is: %01X", rxBuff[0]);
configureAccuAndMag(device);
PRINTF("\r\n==================== I2C MASTER BLOCKING ===================\r\n");
PRINTF("\r\n1. Master checks who am i register\
\r\n2. Master configures accelerometer and magnetometer\
\r\n3. Takes 200 samples, average them and displays results\r\n");
PRINTF("\r\n============================================================\r\n\n");
PRINTF("Press any key to start transfer:\r\n\n");
GETCHAR();
while(1){
x = 0;
y = 0;
z = 0;
for(count = 0; count < 200; count++){
I2C_DRV_MasterReceiveDataBlocking(I2C_INSTANCE_0, &device,READ_DATA, 1, rxBuff, 13, 1000);
x += (int16_t)(((rxBuff[1] << 8) | rxBuff[2]))>> 2;
y += (int16_t)(((rxBuff[3] << 8) | rxBuff[4]))>> 2;
z += (int16_t)(((rxBuff[5] << 8) | rxBuff[6]))>> 2;
}
x = x/200;
y = y/200;
getWhere(x,y);
}
PRINTF("\r\n==================== I2C MASTER FINISH =================== \r\n");
// Deinit i2c
I2C_DRV_MasterDeinit(0);
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// Pin configure
///////////////////////////////////////////////////////////////////////////////
void i2cinitreg(){
PORTE_PCR24 |= (0x05u)<<8 | 0x03u;
PORTE_PCR25 |= (0x05u)<<8 | 0x03u;
}
int main (void)
{
uint32_t j;
spi_status_t spiResult;
spi_slave_state_t spiSlaveState;
spi_dma_slave_state_t spiDmaSlaveState;
spi_slave_user_config_t slaveUserConfig;
spi_dma_slave_user_config_t userDmaConfig =
{
#if FSL_FEATURE_SPI_16BIT_TRANSFERS
.bitCount = kSpi8BitMode,
#endif
.polarity = kSpiClockPolarity_ActiveHigh,
.phase = kSpiClockPhase_FirstEdge,
.direction = kSpiMsbFirst
};
dma_state_t dmaState;
// Init the DMA module
DMA_DRV_Init(&dmaState);
// init the hardware, this also sets up up the SPI pins for each specific SoC
hardware_init();
dbg_uart_init();
OSA_Init();
printf("\r\n SPI board to board dma non-blocking example");
printf("\r\n This example run on instance 0 ");
printf("\r\n Be sure master's SPI0 and slave's SPI0 are connected ");
// USER CONFIGURABLE OPTION FOR SPI INSTANCE (if applicable)
// Configure SPI pin
configure_spi_pins(SPI_SLAVE_INSTANCE);
if (SPI_DRV_DmaSlaveInit(SPI_SLAVE_INSTANCE, &spiDmaSlaveState, &userDmaConfig) != kStatus_SPI_Success)
{
printf("\r\nError in slave DMA init \r\n");
}
while(1)
{
printf("\r\nSlave example is running...");
spiResult = SPI_DRV_DmaSlaveTransfer(SPI_SLAVE_INSTANCE, NULL,
s_spiSinkBuffer, TRANSFER_SIZE);
while(kStatus_SPI_Success != SPI_DRV_DmaSlaveGetTransferStatus(SPI_SLAVE_INSTANCE, NULL));
if (spiResult != kStatus_SPI_Success)
{
printf("\r\nERROR: slave receives error ");
return -1;
}
for (j = 0; j < TRANSFER_SIZE; j++)
{
s_spiSourceBuffer[j] = s_spiSinkBuffer[j];
}
spiResult = SPI_DRV_DmaSlaveTransfer(SPI_SLAVE_INSTANCE, s_spiSourceBuffer,
NULL, TRANSFER_SIZE);
while(kStatus_SPI_Success != SPI_DRV_DmaSlaveGetTransferStatus(SPI_SLAVE_INSTANCE, NULL));
if (spiResult != kStatus_SPI_Success)
{
printf("\r\nERROR: slave sends error ");
return -1;
}
// Print out receive buffer
printf("\r\nSlave receive:");
for (j = 0; j < TRANSFER_SIZE; j++)
{
if (j%16 == 0)
{
printf("\r\n ");
}
printf(" %02X", s_spiSinkBuffer[j]);
}
}
}
/*!
* @brief main function
*/
int main(void)
{
uint8_t i;
uint8_t index, indexChar, value;
uint8_t cmdBuff[1] = {0xFF};
uint8_t sendBuff[1] = {0xFF}; // save data sent to i2c slave
uint8_t receiveBuff[1] = {0xFF}; // save data received from i2c slave
i2c_master_state_t master;
i2c_status_t returnValue;
i2c_device_t slave =
{
.address = 0x3A,
.baudRate_kbps = 100
};
hardware_init();
dbg_uart_init();
// Configure I2C pins
configure_i2c_pins(BOARD_I2C_COMM_INSTANCE);
OSA_Init();
GPIO_DRV_Init(0, ledPins);
// Init I2C module
I2C_DRV_MasterInit(BOARD_I2C_COMM_INSTANCE, &master);
printf("\r\n====== I2C Master ======\r\n\r\n");
OSA_TimeDelay(500);
LED_toggle_master();
OSA_TimeDelay(500);
LED_toggle_master();
OSA_TimeDelay(500);
LED_toggle_master();
OSA_TimeDelay(500);
LED_toggle_master();
while (1)
{
printf("\r\nI2C Master reads values from I2C Slave sub address:\r\n");
printf("\r\n------------------------------------");
printf("\r\nSlave Sub Address | Character ");
printf("\r\n------------------------------------");
for (i=Subaddress_Index_0; i<Invalid_Subaddress_Index; i++)
{
cmdBuff[0] = i;
returnValue = I2C_DRV_MasterReceiveDataBlocking(
BOARD_I2C_COMM_INSTANCE,
&slave,
cmdBuff,
1,
receiveBuff,
sizeof(receiveBuff),
500);
if (returnValue == kStatus_I2C_Success)
{
printf("\r\n[%d] %c", i, receiveBuff[0]);
}
else
{
printf("\r\nI2C communication failed, error code: %d", returnValue);
}
}
printf("\r\n------------------------------------");
printf("\r\n");
printf("\r\nPlease input Slave sub address and the new character.");
do
{
printf("\r\nSlave Sub Address: ");
indexChar = getchar();
putchar(indexChar);
printf("\r\nInput New Character: ");
value = getchar();
putchar(value);
printf("\n");
index = (uint8_t)(indexChar - '0');
if (index >= Invalid_Subaddress_Index)
{
printf("\r\nInvalid Sub Address.");
}
} while (index >= Invalid_Subaddress_Index);
cmdBuff[0] = index;
sendBuff[0] = value;
returnValue = I2C_DRV_MasterSendDataBlocking(
BOARD_I2C_COMM_INSTANCE,
&slave,
cmdBuff,
1,
sendBuff,
sizeof(sendBuff),
500);
if (returnValue != kStatus_I2C_Success)
{
printf("\r\nI2C communication failed, error code: %d", returnValue);
}
}
}
int main()
{
char * AT = "\r\nAT\r\n";//Setting up a char variable AT for the a long string
char * PIN_CHECK = "\r\nAT+CPIN?\r\n";//Setting up a char variable PIN_CHECK for the a long string
char * ENTER_PIN = "\r\nAT+CPIN=\"1234\"\r\n";//Setting up a char variable ENTER_PIN for the a long string
char * CREG = "\r\nAT+CREG?\r\n";//Setting up a char variable CREG for the a long string
char response[20]; //A character buffer called response that can hold 20 characters
int result = 0; //int result to check the value of the response sent back
int transmit_send = 0;
volatile int CurrentTick; //Volitile interger to hold the current tick count of the current time
char * ptr; //Character
char * stat;
enum STATES {INIT, CHECK_PIN, SEND_PIN, CHECK_NETWORK_REG, SEND_SMS, CONNECTED};
enum STATES CurrentState = INIT;
uart_state_t uartState; // user provides memory for the driver state structure
uart_user_config_t uartConfig;
buffer_init();
hardware_init();
//UART0_config();
PIT_Configure_interrupt_mode(1);
configure_uart_pins(0); //instance 0 is UART1???
// Call OSA_Init to setup LP Timer for timeout
OSA_Init();
uartConfig.baudRate = 9600;
uartConfig.bitCountPerChar = kUart8BitsPerChar;
uartConfig.parityMode = kUartParityDisabled;
uartConfig.stopBitCount = kUartOneStopBit;
UART_DRV_Init(1, &uartState,&uartConfig);
//PRINTF("UART0 Test Code\n\r");
//PRINTF("Any entered character will be echoed\r\n\n");
while(1)
{
switch(CurrentState)
{
case INIT: //Check connection to MODEM by sending AT. Expected response is OK
printf("Testing Modem Connection\n");
result = send_command(AT, response, sizeof(response), 2000);
if(result == SUCCESS || result == ERROR)
{
//printf_response(response);
}
if(result == SUCCESS) //"OK" was returned by MODEM
CurrentState = CHECK_PIN;
else //incorrect response or timeout. Delay and try again
{
CurrentTick = tick_count;
while((tick_count - CurrentTick) < 5)
{}
}
break;
case CHECK_PIN: //Check if SIM card is ready
result = send_command(PIN_CHECK, response, sizeof(response), 10);
if(result == SUCCESS || result == ERROR)
{
//printf_response(response);
}
if(result == SUCCESS) //"OK" returned, check response string for "READY" or "SIM_PIN"
{
if(strstr(response, "READY"))
{
CurrentState = CHECK_NETWORK_REG;
}
else if(strstr(response, "SIM PIN"))
{
CurrentState = SEND_PIN;
}
}
else
CurrentState = INIT;
break;
case SEND_PIN: //Send PIN code. "OK" response if PIN is correct
result = send_command(ENTER_PIN, response, sizeof(response),10);
if(result == SUCCESS || result == ERROR)
{
//printf_response(response);
}
if(result == SUCCESS) //"OK" returned, check response string for "READY" or "SIM_PIN"
{
CurrentState = CHECK_NETWORK_REG;
}
else
CurrentState = INIT;
break;
case CHECK_NETWORK_REG: //check if registered on mobile network
result = send_command(CREG, response, sizeof(response), 20);
if(strstr(response, "+CREG"))
{
stat = (char *)strstr(response,":");
stat += 4;
switch(*stat)
{
case '0':
CurrentState = INIT;
break;
case '1':
CurrentState = SEND_SMS;
break;
case '2':
CurrentTick = tick_count;
while((tick_count - CurrentTick) < 5)
{}
CurrentState = CHECK_NETWORK_REG;
break;
case '3':
CurrentState = INIT;
break;
case '4':
CurrentState = CONNECTED;
break;
case '5':
CurrentState = SEND_SMS;
break;
}
}
case SEND_SMS: //Send a text message
transmit_send = send_sms("\"0877763894\"","\"Testing 123 \"");
if(transmit_send == SUCCESS)
{
CurrentState = CONNECTED;
}
else if(transmit_send == FAIL)
{
printf("A transmission fail has been detected or you have timed out\r\n");
CurrentState = SEND_SMS;
}
else if(transmit_send == ERROR)
{
printf("A transmission ERROR has been detected,rebooting\r\n");
CurrentState = INIT;
}
break;
case CONNECTED:
printf("\nInside Connected \r\n");
while(1) //dummy loop
{}
break;
default:
break;
}//end switch-case
}
}
/*!
* @brief The i2c slave
* The function runs i2c slave with interrupt active mode. Slave receive data from
* master and echo back to master
*/
int main(void)
{
// Number byte data will be transfer
uint32_t count = 0;
uint32_t i = 0;
// Buffer store data to transfer
uint8_t dataBuff[DATA_LENGTH] = {0};
// state of slave
i2c_slave_state_t slave;
// user configuration
i2c_slave_user_config_t userConfig =
{
.address = 0x7FU,
.slaveCallback = NULL,
.callbackParam = NULL,
.slaveListening = false,
#if FSL_FEATURE_I2C_HAS_START_STOP_DETECT
.startStopDetect = false,
#endif
#if FSL_FEATURE_I2C_HAS_STOP_DETECT
.stopDetect = false,
#endif
};
// Initialize hardware
hardware_init();
// Initialize OSA
OSA_Init();
PRINTF("\r\n================== I2C SLAVE NON-BLOCKING =================\r\n\r\n");
PRINTF("Slave is running ...");
// Initialize slave
I2C_DRV_SlaveInit(BOARD_I2C_INSTANCE, &userConfig, &slave);
// Loop transfer
while(1)
{
// Slave receive buffer from master
I2C_DRV_SlaveReceiveData(BOARD_I2C_INSTANCE, (uint8_t*)&count, 1);
/* Wait until transfer is successful */
while (I2C_DRV_SlaveGetReceiveStatus(BOARD_I2C_INSTANCE, NULL) != kStatus_I2C_Success);
// Clear receive buffer
for(i = 0; i < count; i++)
{
dataBuff[i] = 0;
}
// Slave receive buffer from master
I2C_DRV_SlaveReceiveData(BOARD_I2C_INSTANCE, dataBuff, count);
/* Wait until transfer is successful */
while (I2C_DRV_SlaveGetReceiveStatus(BOARD_I2C_INSTANCE, NULL) != kStatus_I2C_Success);
// Print receive data
PRINTF("\r\nSlave received:\r\n");
for (i = 0; i < count; i++)
{
// Print 16 numbers in a line.
if ((i & 0x0F) == 0)
{
PRINTF("\r\n ");
}
PRINTF(" %02X", dataBuff[i]);
}
// Slave send buffer received from master
I2C_DRV_SlaveSendData(BOARD_I2C_INSTANCE, dataBuff, count);
/* Wait until transfer is successful */
while (I2C_DRV_SlaveGetTransmitStatus(BOARD_I2C_INSTANCE, NULL) != kStatus_I2C_Success);
OSA_TimeDelay(1);
}
}
/*!
* @brief SPI master DMA non-blocking.
*
* Thid function uses SPI master to send an array to slave
* and receive the array back from slave,
* then compare whether the two buffers are the same.
*/
int main (void)
{
uint8_t loopCount = 0;
uint32_t j;
uint32_t failCount = 0;
uint32_t calculatedBaudRate;
spi_dma_master_state_t spiDmaMasterState;
dma_state_t state;
spi_dma_master_user_config_t userDmaConfig =
{
#if FSL_FEATURE_SPI_16BIT_TRANSFERS
.bitCount = kSpi8BitMode,
#endif
.polarity = kSpiClockPolarity_ActiveHigh,
.phase = kSpiClockPhase_FirstEdge,
.direction = kSpiMsbFirst,
.bitsPerSec = TRANSFER_BAUDRATE
};
// init the hardware, this also sets up up the SPI pins for each specific SoC
hardware_init();
// Init OSA layer.
OSA_Init();
PRINTF("\r\nSPI board to board dma-non-blocking example");
PRINTF("\r\nThis example run on instance %d", (uint32_t)SPI_MASTER_INSTANCE);
PRINTF("\r\nBe sure master's SPI%d and slave's SPI%d are connected\r\n",
(uint32_t)SPI_MASTER_INSTANCE, (uint32_t)SPI_MASTER_INSTANCE);
// Set up and init the master
DMA_DRV_Init(&state);
// Init the dspi module for eDMA operation
SPI_DRV_DmaMasterInit(SPI_MASTER_INSTANCE, &spiDmaMasterState);
SPI_DRV_DmaMasterConfigureBus(SPI_MASTER_INSTANCE,
&userDmaConfig,
&calculatedBaudRate);
if (calculatedBaudRate > userDmaConfig.bitsPerSec)
{
PRINTF("\r\n**Something failed in the master bus config \r\n");
return -1;
}
else
{
PRINTF("\r\nBaud rate in Hz is: %d\r\n", calculatedBaudRate);
}
while(1)
{
// Initialize the source buffer
for (j = 0; j < TRANSFER_SIZE; j++)
{
s_spiSourceBuffer[j] = j + loopCount;
}
// Reset the sink buffer
for (j = 0; j < TRANSFER_SIZE; j++)
{
s_spiSinkBuffer[j] = 0;
}
// Start the transfer
SPI_DRV_DmaMasterTransferBlocking(SPI_MASTER_INSTANCE, NULL, s_spiSourceBuffer,
NULL, TRANSFER_SIZE, MASTER_TRANSFER_TIMEOUT);
while (SPI_DRV_DmaMasterGetTransferStatus(SPI_MASTER_INSTANCE, NULL) == kStatus_SPI_Busy)
{
}
// Delay sometime to wait slave receive and send back data
OSA_TimeDelay(500U);
//Receive data from slave
SPI_DRV_DmaMasterTransfer(SPI_MASTER_INSTANCE, NULL, NULL,
s_spiSinkBuffer, TRANSFER_SIZE);
while (SPI_DRV_DmaMasterGetTransferStatus(SPI_MASTER_INSTANCE, NULL) == kStatus_SPI_Busy)
{
}
// Verify the contents of the master sink buffer
// refer to the slave driver for the expected data pattern
failCount = 0; // reset failCount variable
for (j = 0; j < TRANSFER_SIZE; j++)
{
if (s_spiSinkBuffer[j] != s_spiSourceBuffer[j])
{
failCount++;
}
}
// Print out transmit buffer.
PRINTF("\r\nMaster transmit:");
for (j = 0; j < TRANSFER_SIZE; j++)
{
// Print 16 numbers in a line.
if ((j & 0x0F) == 0)
{
PRINTF("\r\n ");
}
PRINTF(" %02X", s_spiSourceBuffer[j]);
}
// Print out receive buffer.
PRINTF("\r\nMaster receive:");
for (j = 0; j < TRANSFER_SIZE; j++)
{
// Print 16 numbers in a line.
if ((j & 0x0F) == 0)
{
PRINTF("\r\n ");
}
PRINTF(" %02X", s_spiSinkBuffer[j]);
}
if (failCount == 0)
{
PRINTF("\r\n Spi master transfer succeed! \r\n");
}
else
{
PRINTF("\r\n **failures detected in Spi master transfer! \r\n");
}
// Wait for press any key.
PRINTF("\r\nPress any key to run again\r\n");
GETCHAR();
loopCount++;
}
}
/*!
* @brief Main demo function.
*/
int main (void)
{
tpm_general_config_t driverInfo;
accel_dev_t accDev;
accel_dev_interface_t accDevice;
accel_sensor_data_t accelData;
accel_i2c_interface_t i2cInterface;
tpm_pwm_param_t yAxisParams;
tpm_pwm_param_t xAxisParams;
int16_t xData, yData;
int16_t xAngle, yAngle;
xAxisParams.mode = kTpmEdgeAlignedPWM;
xAxisParams.edgeMode = kTpmHighTrue;
xAxisParams.uFrequencyHZ = 100000u;
xAxisParams.uDutyCyclePercent = 0u;
yAxisParams.mode = kTpmEdgeAlignedPWM;
yAxisParams.edgeMode = kTpmHighTrue;
yAxisParams.uFrequencyHZ = 100000u;
yAxisParams.uDutyCyclePercent = 0u;
// Register callback func for I2C
i2cInterface.i2c_init = I2C_DRV_MasterInit;
i2cInterface.i2c_read = I2C_DRV_MasterReceiveDataBlocking;
i2cInterface.i2c_write = I2C_DRV_MasterSendDataBlocking;
accDev.i2c = &i2cInterface;
accDev.accel = &accDevice;
accDev.slave.baudRate_kbps = BOARD_ACCEL_BAUDRATE;
accDev.slave.address = BOARD_ACCEL_ADDR;
accDev.bus = BOARD_ACCEL_I2C_INSTANCE;
// Initialize standard SDK demo application pins.
hardware_init();
// Accel device driver utilizes the OSA, so initialize it.
OSA_Init();
// Print the initial banner.
PRINTF("Bubble Level Demo!\r\n\r\n");
// Initialize the Accel.
accel_init(&accDev);
// Prepare memory for initialization.
memset(&driverInfo, 0, sizeof(driverInfo));
// Init TPM.
TPM_DRV_Init(BOARD_BUBBLE_TPM_INSTANCE, &driverInfo);
// Set clock for TPM.
TPM_DRV_SetClock(BOARD_BUBBLE_TPM_INSTANCE, kTpmClockSourceModuleClk, kTpmDividedBy2);
// Main loop. Get sensor data and update duty cycle for the TPM timer.
while(1)
{
// Wait 5 ms in between samples (accelerometer updates at 200Hz).
OSA_TimeDelay(5);
// Get new accelerometer data.
accDev.accel->accel_read_sensor_data(&accDev,&accelData);
// Init PWM module with updated configuration.
TPM_DRV_PwmStart(BOARD_BUBBLE_TPM_INSTANCE, &xAxisParams, BOARD_TPM_X_CHANNEL);
TPM_DRV_PwmStart(BOARD_BUBBLE_TPM_INSTANCE, &yAxisParams, BOARD_TPM_Y_CHANNEL);
// Get the X and Y data from the sensor data structure.fxos_data
xData = (int16_t)((accelData.data.accelXMSB << 8) | accelData.data.accelXLSB);
yData = (int16_t)((accelData.data.accelYMSB << 8) | accelData.data.accelYLSB);
// Convert raw data to angle (normalize to 0-90 degrees). No negative angles.
xAngle = abs((int16_t)(xData * 0.011));
yAngle = abs((int16_t)(yData * 0.011));
// Update angles to turn on LEDs when angles ~ 90
if(xAngle > 85) xAngle = 100;
if(yAngle > 85) yAngle = 100;
// Update angles to turn off LEDs when angles ~ 0
if(xAngle < 5) xAngle = 0;
if(yAngle < 5) yAngle = 0;
// Update pwm duty cycle
xAxisParams.uDutyCyclePercent = 100 - xAngle ;
yAxisParams.uDutyCyclePercent = 100 - yAngle ;
// Print out the raw accelerometer data.
PRINTF("x= %d y = %d\r\n", xData, yData);
}
}
int main (void)
{
uint8_t msg;
uint32_t timeout = 0;
uint32_t var;
volatile uint16_t count;
OSA_Init();
hardware_init();
dbg_uart_init();
configure_spi_pins(HW_SPI0);
printf("dspi_edma_test_slave\r\n");
printf("\r\nDemo started...\r\n");
// Initialize configuration
edma_init();
edma_dspi_rx_setup(kEDMAChannel2, (uint32_t)&g_slaveRxBuffer);
dspi_slave_setup(HW_SPI0, SPI_BAUDRATE);
printf("Press space bar to begin.\r\n");
msg = 'A';
while(msg != ' ')
{
msg = getchar();
}
printf("\r\nDemo started...\r\n");
// Slave only have PCS0
PORT_HAL_SetMuxMode(PORTC_BASE, 0u, kPortMuxAlt7);
// Enable eDMA channels requests to initiate DSPI transfers.
EDMA_HAL_SetDmaRequestCmd(DMA_BASE, kEDMAChannel2, true);
DSPI_HAL_StartTransfer(SPI0_BASE);
// Waiting transfer complete
printf("waiting transfer complete...\r\n");
while((bReceivedFlag == false) & (timeout < 50))
{
OSA_TimeDelay(100);
timeout++;
}
if(bReceivedFlag == false)
{
printf("No date received, please check connections\r\n");
}
printf("received data:\r\n");
for(count = 0; count < TEST_DATA_LEN; count++)
{
var = g_slaveRxBuffer[count];
printf("%08X\t", (unsigned int)var);
if((count + 1) % 4 == 0)
{
printf("\r\n");
}
}
printf("\r\nEnd of demo.\r\n");
}
/*!
* @brief DSPI slave Polling.
*
* This function sends back received buffer from master through DSPI interface.
*/
int main(void)
{
uint32_t i;
SPI_Type * dspiBaseAddr = (SPI_Type*)SPI0_BASE;
dspi_slave_user_config_t slaveConfig;
// Init hardware
hardware_init();
// Init OSA layer, used in DSPI_DRV_MasterTransferBlocking.
OSA_Init();
// Call this function to initialize the console UART. This function
// enables the use of STDIO functions (printf, scanf, etc.)
dbg_uart_init();
// Configure SPI pins.
configure_spi_pins(DSPI_SLAVE_INSTANCE);
// Print a note.
printf("\r\n DSPI board to board polling example");
printf("\r\n This example run on instance 0 ");
printf("\r\n Be sure DSPI0-DSPI0 are connected ");
// Enable clock for DSPI
CLOCK_SYS_EnableSpiClock(DSPI_SLAVE_INSTANCE);
// Reset the DSPI module, which also disables the DSPI module
DSPI_HAL_Init(dspiBaseAddr);
// Set to slave mode.
DSPI_HAL_SetMasterSlaveMode(dspiBaseAddr, kDspiSlave);
// Set data format
slaveConfig.dataConfig.clkPhase = kDspiClockPhase_FirstEdge;
slaveConfig.dataConfig.clkPolarity = kDspiClockPolarity_ActiveHigh;
slaveConfig.dataConfig.bitsPerFrame = 8;
DSPI_HAL_SetDataFormat(dspiBaseAddr, kDspiCtar0, &(slaveConfig.dataConfig));
// DSPI system enable
DSPI_HAL_Enable(dspiBaseAddr);
// Disable FIFO operation.
DSPI_HAL_SetFifoCmd(dspiBaseAddr, false, false);
while(1)
{
printf("\r\n Slave example is running...");
// Reset the receive buffer.
for (i = 0; i < TRANSFER_SIZE; i++)
{
receiveBuffer[i] = 0;
}
// Restart the transfer by stop then start again, this will clear out the shift register
DSPI_HAL_StopTransfer(dspiBaseAddr);
// Flush the FIFOs
DSPI_HAL_SetFlushFifoCmd(dspiBaseAddr, true, true);
// Clear status flags that may have been set from previous transfers
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiTxComplete);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiEndOfQueue);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiTxFifoUnderflow);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiTxFifoFillRequest);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiRxFifoOverflow);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiRxFifoDrainRequest);
// Clear the transfer count
DSPI_HAL_PresetTransferCount(dspiBaseAddr, 0);
// Start the transfer process in the hardware
DSPI_HAL_StartTransfer(dspiBaseAddr);
for (i = 0; i < TRANSFER_SIZE; i++)
{
// Check RFDR flag
while (DSPI_HAL_GetStatusFlag(dspiBaseAddr, kDspiRxFifoDrainRequest)== false)
{}
// Read data from POPR
receiveBuffer[i] = DSPI_HAL_ReadData(dspiBaseAddr);
// Clear RFDR flag
DSPI_HAL_ClearStatusFlag(dspiBaseAddr,kDspiRxFifoDrainRequest);
}
// Restart the transfer by stop then start again, this will clear out the shift register
DSPI_HAL_StopTransfer(dspiBaseAddr);
// Flush the FIFOs
DSPI_HAL_SetFlushFifoCmd(dspiBaseAddr, true, true);
// Clear status flags that may have been set from previous transfers
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiTxComplete);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiEndOfQueue);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiTxFifoUnderflow);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiTxFifoFillRequest);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiRxFifoOverflow);
DSPI_HAL_ClearStatusFlag(dspiBaseAddr, kDspiRxFifoDrainRequest);
// Clear the transfer count
DSPI_HAL_PresetTransferCount(dspiBaseAddr, 0);
// Start the transfer process in the hardware
DSPI_HAL_StartTransfer(dspiBaseAddr);
// Send the data to slave.
for (i = 0; i < TRANSFER_SIZE; i++)
{
// Write data to PUSHR
DSPI_HAL_WriteDataSlavemodeBlocking(dspiBaseAddr, receiveBuffer[i]);
}
// 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]);
}
}
}
/*!
* @brief Watchdog main routine
* Run a simple application which enables watchdog, then
* continuously refreshes the watchdog to prevent CPU reset
* Upon SW1 button push, the watchdog will expire after
* approximately 2 seconds and issue reset
*/
void main(void)
{
// Configure watchdog.
const wdog_user_config_t wdogConfig =
{
.timeoutValue = 2048U,// Watchdog overflow time is about 2s
.windowValue = 0, // Watchdog window value, 0-disable window function
.clockPrescalerValue = kWdogClockPrescalerValueDevide1, // Watchdog clock prescaler
.updateRegisterEnable = true, // Update register enabled
.clockSource = kClockWdogSrcLpoClk, // Watchdog clock source is LPO 1KHz
.workInWaitModeEnable = true, // Enable watchdog in wait mode
.workInStopModeEnable = true, // Enable watchdog in stop mode
.workInDebugModeEnable = false,// Disable watchdog in debug mode
};
// Init hardware.
hardware_init();
// Init OSA layer.
OSA_Init();
// Call this function to initialize the console UART. This function
// enables the use of STDIO functions (printf, scanf, etc.)
dbg_uart_init();
// Init pinsfor switch and led.
GPIO_DRV_Init(switchPins, ledPins);
// Initialize wdog before the WDOG timer has a chance
//to reset the device
// Turn LED1 on;
LED1_ON;
WDOG_DRV_Init(&wdogConfig);
// If not wdog reset, clear reset count
if (!(RCM->SRS0 & RCM_SRS0_WDOG_MASK))
{
WDOG_DRV_ClearResetCount();
printf("\r\n WDOG example \r\n");
}
// Check if WDOG reset occurred , disable WDOG and turn off LED1.
if (WDOG_DRV_GetResetCount())
{
printf("\r\n WDOG reset count %ld",WDOG_DRV_GetResetCount());
}
printf("\r\n Press SW1 to expire watchdog ");
// Continue to run in loop to refresh watchdog until SW1 is pushed
while (1)
{
// Check for SW1 button push.Pin is grounded when button is pushed.
if (0 != is_key_pressed())
{
while (1)
{
// Button has been pushed,blink LED
// showing that the watchdog is about to expire.
LED1_TOGGLE;
OSA_TimeDelay(BLINK_TIME);
}
}
// Restart the watchdog so it doesn't reset.
WDOG_DRV_Refresh();
OSA_TimeDelay(100u);
}
}
