/**
* *brief init trig pin as input, install interrupt handler on event 1
* IO pins on lpc11xx can be configured for hysteresis ~0.4V, we enable this to avoid
* multiple interrupts when optocoupler input is fired from a potential noisy and slow input
* */
void trigInputInit(void)
{
/* init timers */
/* avoid triggerning after reset, and allow inputs to settle */
timeLast1 = 0;
timeLast2 = 0;
timeEdge1 = 0;
timeEdge2 = 0;
/* allow interrupts on GPIO 1 & 2 */
NVIC_EnableIRQ(EINT1_IRQn);
NVIC_EnableIRQ(EINT2_IRQn);
/* hard coded pins set pullups and hysteresis TODO*/
LPC_IOCON->PIO2_2 = 0x00000030;
LPC_IOCON->PIO1_10 = 0x000000B0;
GPIOSetDir( TRIG_IN_PORT_1, TRIG_IN_PIN_1, 0);
GPIOSetDir( TRIG_IN_PORT_2, TRIG_IN_PIN_2, 0);
/* attach pin to falling edge Interrupt */
GPIOSetInterrupt(TRIG_IN_PORT_1, TRIG_IN_PIN_1, 0, 0, 0);
GPIOSetInterrupt(TRIG_IN_PORT_2, TRIG_IN_PIN_2, 0, 0, 0);
/*enable interrupts*/
GPIOIntEnable( TRIG_IN_PORT_1, TRIG_IN_PIN_1);
GPIOIntEnable( TRIG_IN_PORT_2, TRIG_IN_PIN_2);
}
/*****************************************************************************
** Main Function main()
******************************************************************************/
int main (void)
{
SystemInit();
GPIOInit();
/* use port0_1 as input event, interrupt test. */
GPIOSetDir( PORT0, 1, 0 );
/* port0_1, single trigger, active high. */
GPIOSetInterrupt( PORT0, 1, 0, 0, 0 );
GPIOIntEnable( PORT0, 1 );
/* use port1_1 as input event, interrupt test. */
GPIOSetDir( PORT1, 1, 0 );
/* port0_1, single edge trigger, active high. */
GPIOSetInterrupt( PORT1, 1, 0, 0, 0 );
GPIOIntEnable( PORT1, 1 );
/* use port2_1 as input event, interrupt test. */
GPIOSetDir( PORT2, 1, 0 );
/* port0_1, single edge trigger, active high. */
GPIOSetInterrupt( PORT2, 1, 0, 0, 0 );
GPIOIntEnable( PORT2, 1 );
/* use port3_1 as input event, interrupt test. */
GPIOSetDir( PORT3, 1, 0 );
/* port0_1, single edge trigger, active high. */
GPIOSetInterrupt( PORT3, 1, 0, 0, 0 );
GPIOIntEnable( PORT3, 1 );
while( 1 );
}
void Input_Init(void) {
// Mo clock cho ngoai vi
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
// Cau hinh la ngo vao cho port F
GPIODirModeSet(GPIO_PORTF_BASE, 0x1F,
GPIO_DIR_MODE_IN);
// Cau hinh la ngo vao cho port E
GPIODirModeSet(GPIO_PORTE_BASE, 0x0F,
GPIO_DIR_MODE_IN);
// Cau hinh tro keo len cho port F
GPIOPadConfigSet(GPIO_PORTF_BASE, 0x1F,
GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
GPIOPadConfigSet(GPIO_PORTE_BASE, 0x0F,
GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
// Cau hinh va enable ngat cho port F
GPIOIntTypeSet(GPIO_PORTF_BASE, 0x1F, GPIO_RISING_EDGE);
IntEnable(INT_GPIOF);
GPIOIntEnable(GPIO_PORTF_BASE, 0x1F);
GPIOIntTypeSet(GPIO_PORTE_BASE, 0x0F, GPIO_RISING_EDGE);
IntEnable(INT_GPIOE);
GPIOIntEnable(GPIO_PORTE_BASE, 0x0F);
}
void spi_gpio_init(uint8_t int_flag)
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//F0-----MISO ----- INPUT
ROM_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0);
//F1，F2，F3：MOSI,CLK，CSN ----- OUTPUT
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);
//CE-----PA6 ----- OUTPUT
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_6);
//IRQ-----PA7 ----- INPUT
ROM_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_7);
if(int_flag == 1) //开引脚外部中断
{
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_7,GPIO_FALLING_EDGE);
GPIOIntEnable(GPIO_PORTA_BASE,GPIO_INT_PIN_7); //打开PA7外部中断进行数据读取
GPIOIntRegister(GPIO_PORTA_BASE, PA7_int_hander);//指定外部中断处理函数
}
else
{
GPIOIntDisable(GPIO_PORTA_BASE,GPIO_INT_PIN_7);
}
}
void confGPIO(){
//Inicializa el puerto F (LEDs) --> No hace falta si usamos la libreria RGB
// ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
// ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
//ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 0); //LEDS APAGADOS
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOE);
//Inicializa los LEDs usando libreria RGB
RGBInit(1);
SysCtlPeripheralSleepEnable(GREEN_TIMER_PERIPH);
SysCtlPeripheralSleepEnable(BLUE_TIMER_PERIPH);
RGBEnable();
//Inicializamos los botones y su interrupción
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ButtonsInit();
GPIOIntClear(GPIO_PORTF_BASE, GPIO_INT_PIN_0|GPIO_INT_PIN_4);
GPIOIntRegister(GPIO_PORTF_BASE,ButtonHandler);
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_INT_PIN_0|GPIO_INT_PIN_4, GPIO_BOTH_EDGES);
GPIOIntEnable(GPIO_PORTF_BASE, GPIO_INT_PIN_0|GPIO_INT_PIN_4);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOF);
}
void setup_buttonInterrupts(){
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_4);
GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_0);
GPIOIntEnable(GPIO_PORTF_BASE, (GPIO_INT_PIN_1 | GPIO_INT_PIN_2 | GPIO_INT_PIN_4));
GPIOIntRegister(GPIO_PORTF_BASE, bHandler);
GPIOIntTypeSet(GPIO_PORTF_BASE, (GPIO_PIN_1 | GPIO_PIN_2 | GPIO_INT_PIN_4) , GPIO_FALLING_EDGE);
GPIOIntEnable(GPIO_PORTB_BASE, GPIO_INT_PIN_0);
GPIOIntRegister(GPIO_PORTB_BASE, brakeHandler);
GPIOIntTypeSet(GPIO_PORTB_BASE, GPIO_PIN_0, GPIO_FALLING_EDGE);
}
int main(void) {
SysCtlClockSet(SYSCTL_SYSDIV_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN);
IntMasterEnable();
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5);
GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);
GPIOPadConfigSet(GPIO_PORTC_BASE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7, 0, GPIO_PIN_TYPE_STD_WPU);
GPIOIntRegister(GPIO_PORTC_BASE, decodeMatrixInput);
GPIOIntTypeSet(GPIO_PORTC_BASE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7, GPIO_FALLING_EDGE);
GPIOIntEnable(GPIO_PORTC_BASE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);
GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5, 0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_0);
srand(time(NULL));
initLEDStrip();
activePattern = 15; // init active pattern to blank
while (1)
activatePattern(activePattern);
}
/*****************************************************
* Function: init_BtnHandler
* Description: Initializes button interrupt
* Initializes timer for button counter
* Input: NONE
* Output: NONE
*****************************************************/
void init_BtnHandler(void)
{
// Unlock un-maskable pin
HWREG(BTN_OVERRIDE_REG + GPIO_O_LOCK) = GPIO_LOCK_KEY;
// Set up our interrupt for button presses
IntMasterDisable(); // Disable all interrupts
GPIOIntDisable(BTN_OVERRIDE_REG, BTN_OVERRIDE);
GPIOPinTypeGPIOInput(BTN_OVERRIDE_REG, BTN_OVERRIDE);
GPIOPadConfigSet(BTN_OVERRIDE_REG, BTN_OVERRIDE, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU); // Set Pull-up
GPIOIntTypeSet(BTN_OVERRIDE_REG, BTN_OVERRIDE, GPIO_BOTH_EDGES); // Set edge to trigger on
GPIOIntClear(BTN_OVERRIDE_REG, BTN_OVERRIDE); // Clear the interrupt bit
GPIOIntEnable(BTN_OVERRIDE_REG, BTN_OVERRIDE); // Enable the interrupt
IntEnable(INT_GPIOE);
// Lock un-maskable pin
HWREG(BTN_OVERRIDE_REG + GPIO_O_LOCK) = 0;
// Setup timer interrupt for button pressing
// This timer will run up and when it is released we will check how long it was running
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
TimerConfigure(BTN_OVERRIDE_TIM_BASE, TIMER_CFG_PERIODIC); // Setup interrupt as 32 bit timer counting up
TimerLoadSet(BTN_OVERRIDE_TIM_BASE, BTN_OVERRIDE_TIM, clockTime/1000); // Load Timer
IntEnable(INT_TIMER0A);
TimerIntEnable(BTN_OVERRIDE_TIM_BASE, TIMER_TIMA_TIMEOUT);
// Turn the input pin to the button high
GPIOPinTypeGPIOOutput(BTN_OVERRIDE_CONTROL_REG, BTN_OVERRIDE_CONTROL);
GPIOPinWrite(BTN_OVERRIDE_CONTROL_REG, BTN_OVERRIDE_CONTROL, BTN_OVERRIDE_CONTROL);
}
void CC3100_InterruptEnable()
{
GPIOIntEnable(CC3100_IRQBASE,CC3100_IRQPIN);
#ifdef SL_IF_TYPE_UART
ROM_UARTIntEnable(CC3100_UARTBASE, UART_INT_RX);
#endif
}
void mode2set()
{
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4); //Clear any existing interrupts
GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_4); //Enable the GPIO Interrupts on Port F
TimerLoadSet(TIMER1_BASE, TIMER_A,SysCtlClockGet()/3); //Set the Max Value of the timer
IntEnable(INT_TIMER1A);
TimerIntEnable(TIMER1_BASE,TIMER_TIMA_TIMEOUT); //Enable Timer1 Interrupt
}
/**
* @brief calculate time between sucessive AC trigger pulses, or read a DC signal,
* depending on configuration, return trigger status if signal is valid
*
* @return TRIGGER_ACTIVE or NO_TRIGGER
* */
int trigInputRead(void)
{
int ret = NO_TRIGGER;
#ifdef TRIG_ON_AC
/* atomic section, no IRQ's while calculating */
GPIOIntDisable( TRIG_IN_PORT_1, TRIG_IN_PIN_1);
GPIOIntDisable( TRIG_IN_PORT_2, TRIG_IN_PIN_2);
/* any changes wich is not noise ?*/
if ((timeEdge1 - timeLast1) > TRIG_TIME_MS_MIN)
{
//GPIOSetValue( 1, 11, 1);
ret |= TRIGGER1_ACTIVE;
/* allign timers */
timeEdge1 = millis();
timeLast1 =timeEdge1;
//GPIOSetValue( 1, 11, 0);
}
/* any changes wich is not noise ?*/
if ((timeEdge2 - timeLast2) > TRIG_TIME_MS_MAX)
{
ret |= TRIGGER2_ACTIVE;
timeEdge2 = millis();
timeLast2 =timeEdge2;
}
GPIOIntEnable( TRIG_IN_PORT_1, TRIG_IN_PIN_1);
GPIOIntEnable( TRIG_IN_PORT_2, TRIG_IN_PIN_2);
/* atomic section ends here */
#endif
//#ifdef TRIG_ON_DC
#if 0
/* if trigger is low, we have DC*/
if (!(LPC_GPIO_PORT->PIN0 & TRIG_IN_PIN))
{
return TRIGGER_ACTIVE;
}
#endif
return ret;
}
void GPIOIntInit(){
//Enables GPIO interrupt
MAP_IntEnable(INT_GPIOA1);
//Register GPIO interrup with the function GIOPIntHandler()
GPIOIntRegister(GPIOA1_BASE, GPIOIntHandler);
//Enables the GPIO interrupt
GPIOIntEnable(GPIOA1_BASE, 0x10);
//Set type to falling edge
GPIOIntTypeSet(GPIOA1_BASE, 0x10, GPIO_FALLING_EDGE);
}
// interrupter in PIO
void init_eint(void)
{
//P0.7
GPIO_SetIOCONFunc(PORT0, 7);
/* 使用Port0.7作为外部中断输入测试 */
GPIOSetDir( PORT0, 7, 0 );
/* P0.7外部中断单端触发、高电平有效 */
GPIOSetInterrupt( PORT0, 1, 7, 0, 0 );
GPIOIntEnable( PORT0, 7 );
}
/*
* ======== WiFiCC3100_open ========
*/
WiFi_Handle WiFiCC3100_open(WiFi_Handle handle, unsigned int spiIndex,
WiFi_evntCallback evntCallback, WiFi_Params *params)
{
unsigned int key;
WiFiCC3100_Object *object = handle->object;
WiFiCC3100_HWAttrs const *hwAttrs = handle->hwAttrs;
union {
#if !defined(MSP430WARE)
Hwi_Params hwiParams;
#endif
Semaphore_Params semParams;
} paramsUnion;
key = Hwi_disable();
if (object->isOpen) {
Hwi_restore(key);
Log_warning0("WiFi Hwi already in use.");
return (NULL);
}
object->isOpen = true;
Hwi_restore(key);
/* Construct semaphores to block read/write transactions. */
Semaphore_Params_init(&(paramsUnion.semParams));
paramsUnion.semParams.mode = Semaphore_Mode_BINARY;
paramsUnion.semParams.instance->name = "WiFi.writeSemaphore";
Semaphore_construct(&(object->writeSemaphore), 0, &(paramsUnion.semParams));
paramsUnion.semParams.instance->name = "WiFi.readSemaphore";
Semaphore_construct(&(object->readSemaphore), 0, &(paramsUnion.semParams));
#if !defined(MSP430WARE)
Hwi_Params_init(&(paramsUnion.hwiParams));
paramsUnion.hwiParams.arg = (UArg) handle;
paramsUnion.hwiParams.enableInt = false;
/* Hwi_construct cannot fail, use NULL instead of an Error Block */
Hwi_construct(&(object->wifiHwi), hwAttrs->irqIntNum,
WiFiCC3100_hostIntHandler, &(paramsUnion.hwiParams), NULL);
#endif
#if defined(MSP430WARE) || defined(MSP432WARE)
MAP_GPIO_clearInterruptFlag(hwAttrs->irqPort, hwAttrs->irqPin);
MAP_GPIO_enableInterrupt(hwAttrs->irqPort, hwAttrs->irqPin);
#else
GPIOIntClear(hwAttrs->irqPort, hwAttrs->irqPin);
GPIOIntEnable(hwAttrs->irqPort, hwAttrs->irqPin);
#endif
/* Store SPI interface parameters */
object->spiIndex = spiIndex;
object->bitRate = params->bitRate;
return (handle);
}
extern "C" int main(void) {
unsigned long ir_period;
// 40 MHz system clock
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|
SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
ConfigureUART();
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//
// Unlock PF0 so we can change it to a GPIO input
// Once we have enabled (unlocked) the commit register then re-lock it
// to prevent further changes. PF0 is muxed with NMI thus a special case.
//
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= 0x01;
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0;
// Interrupt on sw1
GPIODirModeSet(IR_PORT, IR_PIN, GPIO_DIR_MODE_IN);
GPIOPadConfigSet(IR_PORT, IR_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD);
GPIOPinTypeGPIOInput(IR_PORT, IR_PIN);
GPIOIntTypeSet(IR_PORT, IR_PIN, GPIO_FALLING_EDGE);
GPIOIntRegister(IR_PORT, ir_input_isr);
GPIOIntEnable(IR_PORT, IR_PIN );
IntMasterEnable();
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0);
GPIOPinConfigure(GPIO_PF1_T0CCP1);
GPIOPinTypeTimer(GPIO_PORTF_BASE, GPIO_PIN_1);
// Configure timer
ir_period = SysCtlClockGet() / (IR_CARRIER / 2);
UARTprintf("ir_period:%d\n", ir_period);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_B_PWM);
TimerLoadSet(TIMER0_BASE, TIMER_B, ir_period);
TimerMatchSet(TIMER0_BASE, TIMER_B, ir_period / 2); // PWM
TimerEnable(TIMER0_BASE, TIMER_B);
unsigned long m = 0;
while(1) {
TimerMatchSet(TIMER0_BASE, TIMER_B, m++); // PWM
if (m > ir_period) m = 0;
int i = 0;
while (i++ < 5000)
if (!ir.empty())
UARTprintf("%u", ir.pop_front());
}
}
void GPIO_Init() {
//INPUTS: PB2 - ENABLE READ / PD1 - COUNT
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_2);
GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_1);
//CONFIGURE GPIO INTERRUPT (PD1 RISE AND DOWN)
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_1,GPIO_BOTH_EDGES);
GPIOIntRegister(GPIO_PORTD_BASE,GPIODIntHandler);
GPIOIntEnable(GPIO_PORTD_BASE, GPIO_INT_PIN_1);
}
void interrupt_setup(void)
{
// Interrupt setuü
GPIOIntDisable(GPIO_PORTF_BASE, GPIO_PIN_4); // Disable interrupt for PF4 (in case it was enabled)
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4); // Clear pending interrupts for PF4
GPIOIntRegister(GPIO_PORTF_BASE, onButtonDown); // Register our handler function for port F
GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4,
GPIO_FALLING_EDGE); // Configure PF4 for falling edge trigger
GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_4); // Enable interrupt for PF4
}
/*********************************************************************************************************
** Function name: ConfigureFanFb
** Descriptions:
** input parameters:
**
** Output parameters:: 无
** Returned value:
**
** Created by: zhangwen
** Created Date:
**--------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
**--------------------------------------------------------------------------------------------------------
*********************************************************************************************************/
void ConfigureFanFb()
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
//
// Reset the error indicator.
GPIOPinTypeGPIOInput(GPIO_PORTD_BASE,GPIO_PIN_2);
GPIOIntTypeSet(GPIO_PORTD_BASE, GPIO_PIN_2, GPIO_RISING_EDGE);
ROM_GPIODirModeSet(GPIO_PORTD_BASE, GPIO_PIN_2, GPIO_DIR_MODE_IN);
//GPIOPadConfigSet(GPIO_PORTD_BASE, GPIO_PIN_2,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_OD);
GPIOIntEnable(GPIO_PORTD_BASE,GPIO_PIN_2);
IntEnable(INT_GPIOD); // 使能GPIOD端口中断
}
void Keyboard_Handler(void)
{
// task setup
INT8U key = NO_KEY;
INT32U read = 0;
ButtonsInit();
if (OSSemCreate(0,&sKeyboard) != ALLOC_EVENT_OK)
{
// Oh Oh
// Não deveria entrar aqui !!!
while(1){};
};
if (OSQueueCreate(64, &qKeyboard) != ALLOC_EVENT_OK)
{
// Oh Oh
// Não deveria entrar aqui !!!
while(1){};
};
// task main loop
for (;;)
{
// Wait for a keyboard interrupt
OSSemPend (sKeyboard,0);
DelayTask(50);
read = GPIOPinRead(BUTTONS_GPIO_BASE, ALL_BUTTONS);
// Find out which key was pressed
key = (INT8U)read;
// Copy the key to the keyboard buffer
if(key != NO_KEY)
{
if (OSQueuePost(qKeyboard, key) == BUFFER_UNDERRUN)
{
// Buffer overflow
OSQueueClean(qKeyboard);
}
}
key = NO_KEY;
DelayTask(200);
// Enable interrupt to the next key detection
GPIOIntEnable(BUTTONS_GPIO_BASE, ALL_BUTTONS);
}
}
int main() {
//SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
//Enable Peripherals
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//Start specific Pin Ports
GPIOPinTypeGPIOOutput(port_A, GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4);
GPIOPinTypeGPIOOutput(port_C, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);
GPIOPinTypeGPIOOutput(port_D, GPIO_PIN_6);
GPIOPinTypeGPIOOutput(port_E, GPIO_PIN_0);
GPIOPinTypeGPIOOutput(port_F, GPIO_PIN_4 | GPIO_PIN_1);
//Input Pins
GPIOPinTypeGPIOInput(port_F, GPIO_PIN_2 | GPIO_PIN_3);
//Enable pin for interrupt
GPIOIntEnable(GPIO_PORTF_BASE, (GPIO_INT_PIN_2 | GPIO_INT_PIN_3));
//Set ISR
GPIOIntRegister(GPIO_PORTF_BASE, scroll_button_isr);
//Set interrupt type
GPIOIntTypeSet(GPIO_PORTF_BASE, (GPIO_PIN_2 | GPIO_PIN_3) , GPIO_FALLING_EDGE);
ROM_SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_GPIOC);
ROM_SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_GPIOD);
ROM_SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_GPIOE);
ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOF);
ROM_SysCtlPeripheralClockGating(true);
//Initialize the display
initializeDisplay();
//Write phrases
write_phrases();
}
int main() {
//Enable Peripherals
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
//Start specific Pin Ports
GPIOPinTypeGPIOOutput(port_A, GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4);
GPIOPinTypeGPIOOutput(port_C, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);
GPIOPinTypeGPIOOutput(port_D, GPIO_PIN_6);
GPIOPinTypeGPIOOutput(port_E, GPIO_PIN_0);
GPIOPinTypeGPIOOutput(port_F, GPIO_PIN_4);
GPIOPinTypeGPIOInput(port_F, GPIO_PIN_2 | GPIO_PIN_3);
//Timer Configuration
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
TimerLoadSet(TIMER0_BASE, TIMER_A, frequency);
TimerControlEvent(TIMER0_BASE, TIMER_A, TIMER_EVENT_POS_EDGE);
TimerEnable(TIMER0_BASE, TIMER_A);
//Enable pin for interrupt
GPIOIntEnable(GPIO_PORTF_BASE, (GPIO_INT_PIN_2 | GPIO_INT_PIN_3));
//Set ISR
GPIOIntRegister(GPIO_PORTF_BASE, the_taco_meter);
//Set interrupt type
GPIOIntTypeSet(GPIO_PORTF_BASE, (GPIO_PIN_2 | GPIO_PIN_3) , GPIO_BOTH_EDGES);
//Initialize the display
initializeDisplay();
//RS High
GPIOPinWrite(port_C, GPIO_PIN_5, pin_5);
write_string("Speed = #### RPM");
while(1) {
taco_display();
}
}
void Button_init(void)
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) = 0x01;
HWREG(GPIO_PORTF_BASE + GPIO_O_AFSEL) &= ~0x01;
ROM_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4);
ROM_GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, GPIO_STRENGTH_8MA_SC, GPIO_PIN_TYPE_STD_WPU);
ROM_GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, GPIO_FALLING_EDGE);
GPIOIntRegister(GPIO_PORTF_BASE, &ButtonsISR);
ROM_IntEnable(INT_GPIOF);
GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4);
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4);
}
int main(){
SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlDelay(3);
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_1);
GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_1,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_1,GPIO_BOTH_EDGES);
GPIOIntRegister(GPIO_PORTF_BASE,PortFIntHandler);
GPIOIntEnable(GPIO_PORTF_BASE, GPIO_INT_PIN_1);
int i;
for( i=0; i < size; i++)
values[i] = 0;
SysTickbegin();
SPIInit();
SendData(values,size);
Wait(1000);
while(1){
int i;
Policia();
PadraoInit=0;
MudaPadrao = 0;
for(i=0; i < 3 && MudaPadrao==0; i++)
Pattern3();
PadraoInit=0;
MudaPadrao = 0;
Ambulancia();
PadraoInit=0;
MudaPadrao = 0;
for(i=0; i < 3 && MudaPadrao==0; i++)
Pattern2();
PadraoInit=0;
MudaPadrao = 0;
Pattern4();
PadraoInit=0;
MudaPadrao = 0;
}
}
// Main
void main(void) {
mainSetup();
IntMasterEnable();
GPIOIntRegister(GPIO_PORTJ_BASE, interruptHandler);
GPIOIntTypeSet(GPIO_PORTJ_BASE, GPIO_PIN_0, GPIO_FALLING_EDGE);
GPIOIntEnable(GPIO_PORTJ_BASE, GPIO_PIN_0);
//GPIOIntTypeSet(GPIO_PORTJ_BASE, GPIO_PIN_1, GPIO_FALLING_EDGE);
//GPIOIntEnable(GPIO_PORTJ_BASE, GPIO_PIN_1);
SysTickEnable();
SysTickPeriodSet(currentFreq);
SysTickIntRegister(timerstep);
SysTickIntEnable();
while (true);
}
void gpiob_ini(void)
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
//GPIOPinTypeGPIOInput(GPIO_PORTB_BASE,GPIO_PIN_1);
GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_1, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPD);
GPIOIntTypeSet(GPIO_PORTB_BASE, GPIO_PIN_1,
GPIO_BOTH_EDGES);
IntMasterEnable(); //全局中断使能
IntEnable(INT_GPIOB); //使能串口0中断
GPIOIntEnable(GPIO_PORTB_BASE, GPIO_INT_PIN_1); //使能串口0接收中断和接收超时中断
}
//jykim_080730_default_interrupt_disable_head++
void InterruptControl(void) {
/*Timer Interrupt Setting*/
if (TIMER_INT_ENABLE) {
OpenRiscEnableTimerInt(TIMER_INT_PERIOD_VALUE);//(0xfff : 4096 clk)
} else {
OpenRiscDisableTimerInt();
}
/*Extenal Interrupt Setting*/
IntDisable(0xffffffff);
IntEnable(INTERRUPT_CONTROL_VALUE);
//090408_jykim_dvp_handshaking_head+
//GPIO Interrupt Enable
if (INTERRUPT_CONTROL_VALUE & AHB2APB_GPIO_INT_BIT) {
GPIOIntEnable(GPIO14 | GPIO15);
}
//090408_jykim_dvp_handshaking_tail+
}
/**
* /fn InitializeLedUserSwitch
* /brief Initialize led D1 und USR SW1.
* /return void.
*/
static void InitializeLedUserSwitch() {
uint32_t strength;
uint32_t pinType;
Hwi_Params buttonHWIParams;
Hwi_Handle buttonHwi;
Error_Block eb;
// enable port N
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
// LED2
GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
/* set pin gpio port to output */
GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);
/*configure pad as standard pin with default output current*/
GPIOPadConfigGet(GPIO_PORTN_BASE, GPIO_PIN_1, &strength, &pinType);
GPIOPadConfigSet(GPIO_PORTN_BASE, GPIO_PIN_1, strength, GPIO_PIN_TYPE_STD);
/* turn off led 1 */
GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, 0);
/* configure switch 1 with pull up as input on GPIO_PIN_0 as pull-up pin */
GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_0);
GPIOPadConfigGet(GPIO_PORTJ_BASE, GPIO_PIN_0, &strength, &pinType);
GPIOPadConfigSet(GPIO_PORTJ_BASE, GPIO_PIN_0, strength,
GPIO_PIN_TYPE_STD_WPU);
Error_init(&eb);
Hwi_Params_init(&buttonHWIParams);
buttonHWIParams.arg = 0;
buttonHWIParams.enableInt = false;
buttonHwi = Hwi_create(INT_GPIOJ_TM4C129, ButtonFunction, &buttonHWIParams,
&eb);
if (buttonHwi == NULL) {
System_abort("Button Hardware interrupt create failed.");
}
Hwi_enableInterrupt(INT_GPIOJ_TM4C129);
GPIOIntEnable(GPIO_PORTJ_BASE, GPIO_INT_PIN_0);
}
void SystickIntHandler(){
//Samples the voltage on pin 3
if (GPIOPinRead(GPIOA1_BASE, 0x10)){
//modify the bitsequence using logic AND
//Use bitwise operation here to save memory. Another option is to use an aray
bitsequence = bitsequence | (1LL << (64-index));
}
//Increments the next index of the bit in bitsequence to be modified
index++;
//Clear the GPIO interrupt
GPIOIntClear(GPIOA1_BASE, 0x10);
//Enables the GPIO interrupt
GPIOIntEnable(GPIOA1_BASE, 0x10);
if(index == 60)
{
//If 60 bits have been written, it's time to check what number on the remote the bit sequence reprensent.
SysTickDisable();
GPIOIntDisable(GPIOA1_BASE, 0x10);
}
}
/*****************************************************************************
** Function name: SetRemoteWakeupSource
**
** Descriptions: Set Remote Wakeup Source
**
** parameters: None
** Returned value: None
**
*****************************************************************************/
void SetRemoteWakeupSource (void)
{
/* Enable AHB clock to the GPIO domain. */
LPC_SYSCON->SYSAHBCLKCTRL |= (1<<6);
/* Enable AHB clock to the FlexInt, GroupedInt domain. */
LPC_SYSCON->SYSAHBCLKCTRL |= ((1<<19) | (1<<23) | (1<<24));
/* Route p0.1 to FLEX0 */
LPC_SYSCON->PINTSEL[0] = 1; /* P0.1 */
/* use port0_1 as input event, interrupt test. */
GPIOSetDir( PORT0, 1, 0 );
/* INT0, edge trigger, falling edge. */
GPIOSetInterrupt( 0, 0, 0 );
GPIOIntEnable( 0, 0 );
NVIC_EnableIRQ(FLEX_INT0_IRQn);
return;
}
int main(void) {
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
//Set up the general purpose I/Os
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);//1024hz = 15625
//Set up the input/output pins
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_1);
GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_5 | GPIO_PIN_6);
//Set up the interrupt pins
GPIOIntEnable(GPIO_PORTC_BASE, GPIO_INT_PIN_5 | GPIO_INT_PIN_6);
GPIOIntRegister(GPIO_PORTC_BASE, interrupt_handler);
GPIOIntTypeSet(GPIO_PORTC_BASE, (GPIO_PIN_5 | GPIO_PIN_6), GPIO_RISING_EDGE);
//Just a quick toggle to make sure code is working
toggle();
//Timer Configuration
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
TimerLoadSet(TIMER0_BASE, TIMER_A, frequency);
TimerControlEvent(TIMER0_BASE, TIMER_A, TIMER_EVENT_POS_EDGE);
TimerEnable(TIMER0_BASE, TIMER_A);
//Timer Interrupt Enable
TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
TimerIntRegister(TIMER0_BASE, TIMER_A, timer_interrupt);
//Loop forever
while(1){
// if(TimerValueGet(TIMER0_BASE, TIMER_A) == 0){
// GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, pin_data);
// pin_data^=0x04;
// }
}
}
