void KPP_Init(KPP_Type *base, kpp_config_t *configure)
{
assert(configure);
uint32_t instance = KPP_GetInstance(base);
#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)
/* Un-gate sdram controller clock. */
CLOCK_EnableClock(s_kppClock[KPP_GetInstance(base)]);
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
/* Clear all. */
base->KPSR &= ~(KPP_KPSR_KRIE_MASK | KPP_KPSR_KDIE_MASK);
/* Enable the keypad row and set the column strobe output to open drain. */
base->KPCR = KPP_KPCR_KRE(configure->activeRow);
base->KPDR = KPP_KPDR_KCD((uint8_t)~(configure->activeColumn));
base->KPCR |= KPP_KPCR_KCO(configure->activeColumn);
/* Set the input direction for row and output direction for column. */
base->KDDR = KPP_KDDR_KCDD(configure->activeColumn) | KPP_KDDR_KRDD((uint8_t)~(configure->activeRow));
/* Clear the status flag and enable the interrupt. */
base->KPSR =
KPP_KPSR_KPKR_MASK | KPP_KPSR_KPKD_MASK | KPP_KPSR_KDSC_MASK | configure->interrupt;
if (configure->interrupt)
{
/* Enable at the Interrupt */
EnableIRQ(s_kppIrqs[instance]);
}
}
void __init s5c7375_init_irq(void)
{
int irq;
/* Disable all IRQs */
rINTMSK = 0xffffffff; /* all masked */
/****************
* All IRQs are IRQ, not FIQ
* Write only one register,
* 0 : IRQ mode
* 1 : FIQ mode
*******************************************/
rINTMOD = 0x00000000;
for (irq = 0; irq < NR_IRQS; irq++) {
set_irq_chip(irq, &s5c7375_chip);
set_irq_handler(irq, do_level_IRQ);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
}
rINTCON = 0x0; // all interrupt is disabled
// rINTCON = 0xD; // vectored mode
DisableFIQ(); // fiq is disabled
#ifndef CONFIG_S5C7375VM
EnableIRQ(); // irq is enabled
#else
DisableIRQ();
#endif
DisableGMask(); // global mask is disabled
}
/** Initialize the low power ticker
*
*/
void lp_ticker_init(void)
{
lptmr_config_t lptmrConfig;
if (lp_ticker_inited) {
return;
}
lp_ticker_inited = true;
/* Setup low resolution clock - RTC */
if (!rtc_isenabled()) {
rtc_init();
RTC_DisableInterrupts(RTC, kRTC_AlarmInterruptEnable | kRTC_SecondsInterruptEnable);
RTC_StartTimer(RTC);
}
RTC->TAR = 0; /* Write clears the IRQ flag */
NVIC_ClearPendingIRQ(RTC_IRQn);
NVIC_SetVector(RTC_IRQn, (uint32_t)rtc_isr);
NVIC_EnableIRQ(RTC_IRQn);
/* Setup high resolution clock - LPTMR */
LPTMR_GetDefaultConfig(&lptmrConfig);
/* Use 32kHz drive */
CLOCK_SetXtal32Freq(OSC32K_CLK_HZ);
lptmrConfig.prescalerClockSource = kLPTMR_PrescalerClock_2;
LPTMR_Init(LPTMR0, &lptmrConfig);
LPTMR_EnableInterrupts(LPTMR0, kLPTMR_TimerInterruptEnable);
NVIC_ClearPendingIRQ(LPTMR0_IRQn);
NVIC_SetVector(LPTMR0_IRQn, (uint32_t)lptmr_isr);
EnableIRQ(LPTMR0_IRQn);
}
static rt_err_t imxrt_control(struct rt_serial_device *serial, int cmd, void *arg)
{
struct imxrt_uart *uart;
RT_ASSERT(serial != RT_NULL);
uart = (struct imxrt_uart *)serial->parent.user_data;
switch (cmd)
{
case RT_DEVICE_CTRL_CLR_INT:
/* disable interrupt */
LPUART_DisableInterrupts(uart->uart_base, kLPUART_RxDataRegFullInterruptEnable);
/* disable rx irq */
DisableIRQ(uart->irqn);
break;
case RT_DEVICE_CTRL_SET_INT:
/* enable interrupt */
LPUART_EnableInterrupts(uart->uart_base, kLPUART_RxDataRegFullInterruptEnable);
/* enable rx irq */
EnableIRQ(uart->irqn);
break;
}
return RT_EOK;
}
status_t CSI_TransferCreateHandle(CSI_Type *base,
csi_handle_t *handle,
csi_transfer_callback_t callback,
void *userData)
{
assert(handle);
uint32_t instance;
memset(handle, 0, sizeof(*handle));
/* Set the callback and user data. */
handle->callback = callback;
handle->userData = userData;
/* Get instance from peripheral base address. */
instance = CSI_GetInstance(base);
/* Save the handle in global variables to support the double weak mechanism. */
s_csiHandle[instance] = handle;
s_csiIsr = CSI_TransferHandleIRQ;
/* Enable interrupt. */
EnableIRQ(s_csiIRQ[instance]);
return kStatus_Success;
}
void CTIMER_SetupMatch(CTIMER_Type *base, ctimer_match_t matchChannel, const ctimer_match_config_t *config)
{
uint32_t reg;
uint32_t index = CTIMER_GetInstance(base);
/* Set the counter operation when a match on this channel occurs */
reg = base->MCR;
reg &= ~((CTIMER_MCR_MR0R_MASK | CTIMER_MCR_MR0S_MASK | CTIMER_MCR_MR0I_MASK) << (matchChannel * 3));
reg |= (uint32_t)((uint32_t)(config->enableCounterReset) << (CTIMER_MCR_MR0R_SHIFT + (matchChannel * 3)));
reg |= (uint32_t)((uint32_t)(config->enableCounterStop) << (CTIMER_MCR_MR0S_SHIFT + (matchChannel * 3)));
reg |= (uint32_t)((uint32_t)(config->enableInterrupt) << (CTIMER_MCR_MR0I_SHIFT + (matchChannel * 3)));
base->MCR = reg;
reg = base->EMR;
/* Set the match output operation when a match on this channel occurs */
reg &= ~(CTIMER_EMR_EMC0_MASK << (matchChannel * 2));
reg |= (uint32_t)config->outControl << (CTIMER_EMR_EMC0_SHIFT + (matchChannel * 2));
/* Set the initial state of the EM bit/output */
reg &= ~(CTIMER_EMR_EM0_MASK << matchChannel);
reg |= (uint32_t)config->outPinInitState << matchChannel;
base->EMR = reg;
/* Set the match value */
base->MR[matchChannel] = config->matchValue;
/* Clear status flags */
CTIMER_ClearStatusFlags(base, CTIMER_IR_MR0INT_MASK << matchChannel);
/* If interrupt is enabled then enable interrupt and update the call back function */
if (config->enableInterrupt)
{
EnableIRQ(s_ctimerIRQ[index]);
}
}
void CInterruptSystem::ConnectIRQ (unsigned nIRQ, TIRQHandler *pHandler, void *pParam)
{
assert (nIRQ < IRQ_LINES);
assert (m_apIRQHandler[nIRQ] == 0);
m_apIRQHandler[nIRQ] = pHandler;
m_pParam[nIRQ] = pParam;
EnableIRQ (nIRQ);
}
void DMIC_EnableIntCallback(DMIC_Type *base, dmic_callback_t cb)
{
uint32_t instance;
instance = DMIC_GetInstance(base);
NVIC_ClearPendingIRQ(s_dmicIRQ[instance]);
/* Save callback pointer */
s_dmicCallback[instance] = cb;
EnableIRQ(s_dmicIRQ[instance]);
}
void DMIC_HwvadEnableIntCallback(DMIC_Type *base, dmic_hwvad_callback_t vadcb)
{
uint32_t instance;
instance = DMIC_GetInstance(base);
NVIC_ClearPendingIRQ(s_dmicHwvadIRQ[instance]);
/* Save callback pointer */
s_dmicHwvadCallback[instance] = vadcb;
EnableIRQ(s_dmicHwvadIRQ[instance]);
}
void GINT_EnableCallback(GINT_Type *base)
{
uint32_t instance;
instance = GINT_GetInstance(base);
/* If GINT is configured in "AND" mode a spurious interrupt is generated.
Clear status and pending interrupt before enabling the irq in NVIC. */
GINT_ClrStatus(base);
NVIC_ClearPendingIRQ(s_gintIRQ[instance]);
EnableIRQ(s_gintIRQ[instance]);
}
void EnableDeepSleepIRQ(IRQn_Type interrupt)
{
uint32_t index = 0;
uint32_t intNumber = (uint32_t)interrupt;
while (intNumber >= 32u)
{
index++;
intNumber -= 32u;
}
SYSCON->STARTERSET[index] = 1u << intNumber;
EnableIRQ(interrupt); /* also enable interrupt at NVIC */
}
void PINT_EnableCallback(PINT_Type *base)
{
uint32_t i;
assert(base);
PINT_PinInterruptClrStatusAll(base);
for (i = 0; i < FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS; i++)
{
NVIC_ClearPendingIRQ(s_pintIRQ[i]);
PINT_PinInterruptClrStatus(base, (pint_pin_int_t)i);
EnableIRQ(s_pintIRQ[i]);
}
}
/*!
* @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);
}
}
}
void modem_init() {
const gpio_pin_config_t OUTTRUE = {kGPIO_DigitalOutput, true};
const gpio_pin_config_t IN = {kGPIO_DigitalInput, false};
// initialize BOARD_CELL pins
CLOCK_EnableClock(BOARD_CELL_UART_PORT_CLOCK);
PORT_SetPinMux(BOARD_CELL_UART_PORT, BOARD_CELL_UART_TX_PIN, BOARD_CELL_UART_TX_ALT);
PORT_SetPinMux(BOARD_CELL_UART_PORT, BOARD_CELL_UART_RX_PIN, BOARD_CELL_UART_RX_ALT);
CLOCK_EnableClock(BOARD_CELL_PIN_PORT_CLOCK);
PORT_SetPinMux(BOARD_CELL_PIN_PORT, BOARD_CELL_STATUS_PIN, kPORT_MuxAsGpio);
GPIO_PinInit(BOARD_CELL_PIN_GPIO, BOARD_CELL_STATUS_PIN, &IN);
#if BOARD_CELL_RESET_PIN
PORT_SetPinMux(BOARD_CELL_PIN_PORT, BOARD_CELL_RESET_PIN, kPORT_MuxAsGpio);
GPIO_PinInit(BOARD_CELL_PIN_GPIO, BOARD_CELL_RESET_PIN, &OUTTRUE);
#endif
PORT_SetPinMux(BOARD_CELL_PIN_PORT, BOARD_CELL_PWRKEY_PIN, kPORT_MuxAsGpio);
GPIO_PinInit(BOARD_CELL_PIN_GPIO, BOARD_CELL_PWRKEY_PIN, &OUTTRUE);
// the ring identifier is optional, only use if a pin and port exists
#if BOARD_CELL_RI_PIN
PORT_SetPinMux(BOARD_CELL_PIN_PORT, BOARD_CELL_RI_PIN, kPORT_MuxAsGpio);
GPIO_PinInit(BOARD_CELL_PIN_GPIO, BOARD_CELL_RI_PIN, &IN);
#endif
#if BOARD_CELL_PWR_DOMAIN
const gpio_pin_config_t OUTFALSE = {kGPIO_DigitalOutput, false};
CLOCK_EnableClock(BOARD_CELL_PWR_EN_CLOCK);
PORT_SetPinMux(BOARD_CELL_PWR_EN_PORT, BOARD_CELL_PWR_EN_PIN, kPORT_MuxAsGpio);
GPIO_PinInit(BOARD_CELL_PWR_EN_GPIO, BOARD_CELL_PWR_EN_PIN, &OUTFALSE);
#endif
// configure uart driver connected to the SIM800H
lpuart_config_t lpuart_config;
LPUART_GetDefaultConfig(&lpuart_config);
lpuart_config.baudRate_Bps = 115200;
lpuart_config.parityMode = kLPUART_ParityDisabled;
lpuart_config.stopBitCount = kLPUART_OneStopBit;
LPUART_Init(BOARD_CELL_UART, &lpuart_config, BOARD_CELL_PORT_CLOCK_FREQ);
LPUART_EnableRx(BOARD_CELL_UART, true);
LPUART_EnableTx(BOARD_CELL_UART, true);
LPUART_EnableInterrupts(BOARD_CELL_UART, kLPUART_RxDataRegFullInterruptEnable);
EnableIRQ(BOARD_CELL_UART_IRQ);
}
status_t CTIMER_SetupPwmPeriod(CTIMER_Type *base,
ctimer_match_t matchChannel,
uint32_t pwmPeriod,
uint32_t pulsePeriod,
bool enableInt)
{
uint32_t reg;
uint32_t index = CTIMER_GetInstance(base);
if (matchChannel == kCTIMER_Match_3)
{
return kStatus_Fail;
}
/* Enable PWM mode on the channel */
base->PWMC |= (1U << matchChannel);
/* Clear the stop, reset and interrupt bits for this channel */
reg = base->MCR;
reg &= ~((CTIMER_MCR_MR0R_MASK | CTIMER_MCR_MR0S_MASK | CTIMER_MCR_MR0I_MASK) << (matchChannel * 3));
/* If call back function is valid then enable match interrupt for the channel */
if (enableInt)
{
reg |= (CTIMER_MCR_MR0I_MASK << (CTIMER_MCR_MR0I_SHIFT + (matchChannel * 3)));
}
/* Reset the counter when match on channel 3 */
reg |= CTIMER_MCR_MR3R_MASK;
base->MCR = reg;
/* Match on channel 3 will define the PWM period */
base->MR[kCTIMER_Match_3] = pwmPeriod;
/* This will define the PWM pulse period */
base->MR[matchChannel] = pulsePeriod;
/* Clear status flags */
CTIMER_ClearStatusFlags(base, CTIMER_IR_MR0INT_MASK << matchChannel);
/* If call back function is valid then enable interrupt and update the call back function */
if (enableInt)
{
EnableIRQ(s_ctimerIRQ[index]);
}
return kStatus_Success;
}
/*!
* @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;
}
}
}
/*!
* @brief Main function
*/
int main(void)
{
lpuart_config_t config;
BOARD_InitPins();
BOARD_BootClockRUN();
CLOCK_SetLpuart1Clock(1U);
/*
* config.baudRate_Bps = 115200U;
* config.parityMode = kLPUART_ParityDisabled;
* config.stopBitCount = kLPUART_OneStopBit;
* config.txFifoWatermark = 0;
* config.rxFifoWatermark = 0;
* config.enableTx = false;
* config.enableRx = false;
*/
LPUART_GetDefaultConfig(&config);
config.baudRate_Bps = BOARD_DEBUG_UART_BAUDRATE;
config.enableTx = true;
config.enableRx = true;
LPUART_Init(DEMO_LPUART, &config, CLOCK_GetFreq(DEMO_LPUART_CLKSRC));
/* Send g_tipString out. */
LPUART_WriteBlocking(DEMO_LPUART, g_tipString, sizeof(g_tipString) / sizeof(g_tipString[0]));
/* Enable RX interrupt. */
LPUART_EnableInterrupts(DEMO_LPUART, kLPUART_RxDataRegFullInterruptEnable);
EnableIRQ(DEMO_LPUART_IRQn);
while (1)
{
/* Send data only when LPUART TX register is empty and ring buffer has data to send out. */
while ((kLPUART_TxDataRegEmptyFlag & LPUART_GetStatusFlags(DEMO_LPUART)) && (rxIndex != txIndex))
{
LPUART_WriteByte(DEMO_LPUART, demoRingBuffer[txIndex]);
txIndex++;
txIndex %= DEMO_RING_BUFFER_SIZE;
}
}
}
void CTIMER_SetupCapture(CTIMER_Type *base,
ctimer_capture_channel_t capture,
ctimer_capture_edge_t edge,
bool enableInt)
{
uint32_t reg = base->CCR;
uint32_t index = CTIMER_GetInstance(base);
/* Set the capture edge */
reg &= ~((CTIMER_CCR_CAP0RE_MASK | CTIMER_CCR_CAP0FE_MASK | CTIMER_CCR_CAP0I_MASK) << (capture * 3));
reg |= (uint32_t)edge << (CTIMER_CCR_CAP0RE_SHIFT + (capture * 3));
/* Clear status flags */
CTIMER_ClearStatusFlags(base, (kCTIMER_Capture0Flag << capture));
/* If call back function is valid then enable capture interrupt for the channel and update the call back function */
if (enableInt)
{
reg |= CTIMER_CCR_CAP0I_MASK << (capture * 3);
EnableIRQ(s_ctimerIRQ[index]);
}
base->CCR = reg;
}
/*!
* @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;
}
}
}
/** Initialize the low power ticker
*
*/
void lp_ticker_init(void)
{
gpt_config_t gptConfig;
if (!lp_ticker_inited) {
/* Setup GPT */
GPT_GetDefaultConfig(&gptConfig);
/* Use 32kHz drive */
gptConfig.clockSource = kGPT_ClockSource_LowFreq;
gptConfig.enableFreeRun = true;
gptConfig.enableMode = false;
GPT_Init(GPT2, &gptConfig);
GPT_EnableInterrupts(GPT2, kGPT_OutputCompare1InterruptEnable);
NVIC_ClearPendingIRQ(GPT2_IRQn);
NVIC_SetVector(GPT2_IRQn, (uint32_t)gpt_isr);
EnableIRQ(GPT2_IRQn);
GPT_StartTimer(GPT2);
lp_ticker_inited = true;
} else {
GPT_DisableInterrupts(GPT2, kGPT_OutputCompare1InterruptEnable);
}
}
void InitializePIC()
{
outb(PIC_PRI_CMDR, 0x11); /* Initialize both PICs with ICW1 */
outb(PIC_SLAVE_CMDR, 0x11);
/* Map IRQ 0 to 0x20 and 8 to 0x28 */
outb(PIC_PRI_DATAR, PIC_PRI_CMDR); /* Send ICW2 immediately after ICW1 */
outb(PIC_SLAVE_DATAR, 0x28);
/* Now for ICW3 */
outb(PIC_PRI_DATAR, 0x4); /* Enable bit 2 which specifies that the slave is on IRQ 2 */
outb(PIC_SLAVE_DATAR, 0x2); /* Let the slave know it's on IRQ 2 (send binary number in bits 0-2) */
/* Finally ICW4 (needed since we set the bit in ICW1) */
outb(PIC_PRI_DATAR, 0x11); /* This enables x86 mode */
outb(PIC_SLAVE_DATAR, 0x11);
for (int i = 0; i < 16; i++)
EnableIRQ(i);
SetPriEOI();
SetSlaveEOI();
}
static void NVIC_Configuration(void)
{
EnableIRQ(GPT1_IRQn);
}
/*!
* @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);
}
}
static int BURNT_action(int argc, char *argv[])
{
UINT i;
UINT32 src_addr=0x100000;
UINT32 dest_addr=FLASH_BASE;
UINT32 src,dest;
UINT32 fileSize=0;
UINT32 blockSize=0;
INT flash_type;
if( !_net_init )
{
if( Net_Init(_dhcp) < 0 )
{
uprintf("ERROR: Network initialization failed!\n");
return -1;
}
_net_init=1;
}
uprintf("Waiting for download ...\n");
if( TFTP_Download((UCHAR *)src_addr,(ULONG *)&fileSize,_dhcp)==0 )
{
uprintf("\nFlash programming ");
if( _net_init )DisableIRQ();
flash_type=FindFlash();
if( _net_init )EnableIRQ();
if( flash_type < 0 )
{
uprintf("ERROR: Un-supported flash type !!\n");
return -1;
}
// Write program
if( (fileSize&0x3) )fileSize=((fileSize&(~0x3))+4);//word-aligment
i=fileSize;
src=src_addr;
dest=dest_addr;
while(i)
{
blockSize=flash[flash_type].BlockSize(dest);
if( _net_init )DisableIRQ();
flash[flash_type].BlockErase(dest, blockSize);
if( i < blockSize )
{
flash[flash_type].BlockWrite(dest, (UCHAR *)src, i);
blockSize=i;
}
else
{
flash[flash_type].BlockWrite(dest, (UCHAR *)src, blockSize);
}
if( _net_init )EnableIRQ();
src+=blockSize;
dest+=blockSize;
i-=blockSize;
uprintf(".");
}
uprintf(" OK!\n");
}
else
{
uprintf("\nDownload error!\n");
return -1;
}
// verify data
uprintf("Write data verifing ");
for(i=0;i<fileSize;i+=4)
{
if( (i&0xFFFF)== 0x0 )uprintf(".");
if( *((volatile unsigned int *)(src_addr+i))!=*((volatile unsigned int *)(dest_addr+i)) )
{
uprintf("ERROR: Data failed @ 0x%08x \n", dest_addr+i);
return -1;
}
}
uprintf(" OK!\n");
return 0;
}
int
hal_uart_config(int port, int32_t speed, uint8_t databits, uint8_t stopbits,
enum hal_uart_parity parity, enum hal_uart_flow_ctl flow_ctl)
{
struct hal_uart *u;
uart_config_t uconfig;
if (port >= FSL_FEATURE_SOC_UART_COUNT) {
return -1;
}
u = &uarts[port];
if (!u->u_configured || u->u_open) {
return -1;
}
/* PIN config (all UARTs use kPORT_MuxAlt3) */
CLOCK_EnableClock(u->p_clock);
PORT_SetPinMux(u->p_base, u->u_pin_rx, kPORT_MuxAlt3);
PORT_SetPinMux(u->p_base, u->u_pin_tx, kPORT_MuxAlt3);
/* UART CONFIG */
UART_GetDefaultConfig(&uconfig);
uconfig.baudRate_Bps = speed;
/* TODO: only handles 8 databits currently */
switch (stopbits) {
case 1:
uconfig.stopBitCount = kUART_OneStopBit;
break;
case 2:
uconfig.stopBitCount = kUART_TwoStopBit;
break;
default:
return -1;
}
switch (parity) {
case HAL_UART_PARITY_NONE:
uconfig.parityMode = kUART_ParityDisabled;
break;
case HAL_UART_PARITY_ODD:
uconfig.parityMode = kUART_ParityOdd;
break;
case HAL_UART_PARITY_EVEN:
uconfig.parityMode = kUART_ParityEven;
break;
}
/* TODO: HW flow control not supported */
assert(flow_ctl == HAL_UART_FLOW_CTL_NONE);
u->u_open = 1;
u->u_tx_started = 0;
NVIC_SetVector(u->u_irq, (uint32_t)s_uartirqs[port]);
/* Initialize UART device */
UART_Init(u->u_base, &uconfig, CLOCK_GetFreq(u->clk_src));
UART_EnableTx(u->u_base, true);
UART_EnableRx(u->u_base, true);
UART_EnableInterrupts(u->u_base,
kUART_RxDataRegFullInterruptEnable |
kUART_RxOverrunInterruptEnable);
EnableIRQ(u->u_irq);
return 0;
}
/*!
* @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);
}
}
}
status_t CTIMER_SetupPwm(CTIMER_Type *base,
ctimer_match_t matchChannel,
uint8_t dutyCyclePercent,
uint32_t pwmFreq_Hz,
uint32_t srcClock_Hz,
bool enableInt)
{
assert(pwmFreq_Hz > 0);
uint32_t reg;
uint32_t period, pulsePeriod = 0;
uint32_t timerClock = srcClock_Hz / (base->PR + 1);
uint32_t index = CTIMER_GetInstance(base);
if (matchChannel == kCTIMER_Match_3)
{
return kStatus_Fail;
}
/* Enable PWM mode on the channel */
base->PWMC |= (1U << matchChannel);
/* Clear the stop, reset and interrupt bits for this channel */
reg = base->MCR;
reg &= ~((CTIMER_MCR_MR0R_MASK | CTIMER_MCR_MR0S_MASK | CTIMER_MCR_MR0I_MASK) << (matchChannel * 3));
/* If call back function is valid then enable match interrupt for the channel */
if (enableInt)
{
reg |= (CTIMER_MCR_MR0I_MASK << (CTIMER_MCR_MR0I_SHIFT + (matchChannel * 3)));
}
/* Reset the counter when match on channel 3 */
reg |= CTIMER_MCR_MR3R_MASK;
base->MCR = reg;
/* Calculate PWM period match value */
period = (timerClock / pwmFreq_Hz) - 1;
/* Calculate pulse width match value */
if (dutyCyclePercent == 0)
{
pulsePeriod = period + 1;
}
else
{
pulsePeriod = (period * (100 - dutyCyclePercent)) / 100;
}
/* Match on channel 3 will define the PWM period */
base->MR[kCTIMER_Match_3] = period;
/* This will define the PWM pulse period */
base->MR[matchChannel] = pulsePeriod;
/* Clear status flags */
CTIMER_ClearStatusFlags(base, CTIMER_IR_MR0INT_MASK << matchChannel);
/* If call back function is valid then enable interrupt and update the call back function */
if (enableInt)
{
EnableIRQ(s_ctimerIRQ[index]);
}
return kStatus_Success;
}
/*!
* @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)
{
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);
}
}