//*****************************************************************************
//
// Called by the NVIC as a result of GPIO port M interrupt event. For this
// application GPIO port M pin 3 is the interrupt line for the MPU9150
//
// For BoosterPack 2 Interface use Port M pin 7.
//
//*****************************************************************************
void
GPIOPortMIntHandler(void)
{
unsigned long ulStatus;
//
// Get the status flags to see which pin(s) caused the interrupt.
//
ulStatus = GPIOIntStatus(GPIO_PORTM_BASE, true);
//
// Clear all the pin interrupts that are set
//
GPIOIntClear(GPIO_PORTM_BASE, ulStatus);
//
// Check if this is an interrupt on the MPU9150 interrupt line.
//
// For BoosterPack 2 use Pin 7 instead.
//
if(ulStatus & GPIO_PIN_3) {
//
// Turn on the LED to show that transaction is starting.
//
LEDWrite(CLP_D3 | CLP_D4, CLP_D3);
//
// MPU9150 Data is ready for retrieval and processing.
//
MPU9150DataRead(&g_sMPU9150Inst, MPU9150AppCallback, &g_sMPU9150Inst);
}
}
//*****************************************************************************
//
//! This is the Pulse Per Second (PPS) interrupt handler.
//! The updateCounter is incremented on each Pulse per second call, if equal to
//! the update rate, the GPS data is parsed and logged.
//
//*****************************************************************************
void PortKIntHandler(void) {
uint32_t intStatus = 0;
//
// Get the current interrupt status for Port K
//
intStatus = GPIOIntStatus(GPIO_PORTK_BASE,true);
//
// Clear the set interrupts for Port K
//
GPIOIntClear(GPIO_PORTK_BASE,intStatus);
//
// Execute code for PK2 interrupt
//
if((intStatus & GPIO_INT_PIN_2) == GPIO_INT_PIN_2){
if (updateRate == updateCounter++) {
GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, 0x02);
gpsData();
GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, 0x00);
updateCounter = 0;
//
// Disable PPS interrupt after one read if in low power mode
//
if (lowPowerOn == 1) {
IntDisable(INT_GPIOK);
logComplete = 1;
}
}
}
} // End function PortKIntHandler
//*****************************************************************************
//
// Called by the NVIC as a result of GPIO port E interrupt event. For this
// application GPIO port E pin 5 is the interrupt line for the ISL29023
//
// Notifies the application that light is outside of threshold limits.
// Task will poll the semaphore and adjust the ranges accordingly.
//
//*****************************************************************************
void
IntHandlerGPIOPortE(void)
{
unsigned long ulStatus;
portBASE_TYPE xHigherPriorityTaskWoken;
ulStatus = GPIOIntStatus(GPIO_PORTE_BASE, true);
//
// Clear all the pin interrupts that are set
//
GPIOIntClear(GPIO_PORTE_BASE, ulStatus);
if(ulStatus & GPIO_PIN_5)
{
//
// ISL29023 has indicated that the light level has crossed outside of
// the intensity threshold levels set in INT_LT and INT_HT registers.
//
xSemaphoreGiveFromISR(g_xISL29023AdjustRangeSemaphore,
&xHigherPriorityTaskWoken);
//
// If the give of this semaphore causes a task to be ready then
// make sure it has opportunity to run immediately upon return from
// this ISR.
//
if(xHigherPriorityTaskWoken == pdTRUE)
{
portYIELD_FROM_ISR(true);
}
}
}
void ButtonHandler(){
uint32_t mask=GPIOIntStatus(GPIO_PORTF_BASE,false);
uint8_t value=0;
if(mask & GPIO_PIN_4){
//Boton izquierdo
value= GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4);
if(value==0){
//boton pulsado
// Activa el Timer4A (empezara a funcionar)
TimerEnable(TIMER4_BASE, TIMER_A);
pulsacionLarga=true;
}else{
TimerDisable(TIMER4_BASE,TIMER_A);
if(pulsacionLarga){
xEventGroupSetBits(xEventGroup, PilotoAutomaticoBit);
if((xTaskCreate(PilAuto, (signed portCHAR *)"Piloto Auto", LED1TASKSTACKSIZE,NULL,tskIDLE_PRIORITY + 1, &PilautTaskHandle) != pdTRUE))
{
while(1);
}
}
}
}
if(mask & GPIO_PIN_0){
//boton derecho
xEventGroupClearBits( xEventGroup, PilotoAutomaticoBit );
}
GPIOIntClear(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4);
}
void onButtonUp(void) {
if (GPIOIntStatus(GPIO_PORTF_BASE, false) & GPIO_PIN_4) {
// PF4 was interrupt cause
printf("Button Up\n");
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
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4); // Clear interrupt flag
}
}
//*****************************************************************************
//
//! GPIO Interrupt Handler for S2 button
//!
//! \param None
//!
//! \return None
//
//*****************************************************************************
void GPIOs2IntHandler()
{
unsigned long ulPinState = GPIOIntStatus(GPIOA2_BASE,1);
if(ulPinState & GPIO_PIN_6)
{
Button_IF_DisableInterrupt(SW2);
g_S2InterruptHdl();
}
}
void onButtonDown(void) {
if (GPIOIntStatus(GPIO_PORTF_BASE, false) & GPIO_PIN_4) {
/*The GPIOIntStatus returns the value of the GPIORIS register and in this case,
AND's it with the Pin 4 mask. So if the condition for the interrupt has occurred for the Pin then the if statement is true.*/
// PF4 was interrupt cause
printf("Button Down\n");
GPIOIntRegister(GPIO_PORTF_BASE, onButtonUp); // Register our handler function for port F
GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_RISING_EDGE); // Configure PF4 for rising edge trigger
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4); // Clear interrupt flag
}
}
void PIOINT0_IRQHandler(void)
{
uint32_t regVal;
regVal = GPIOIntStatus( PORT0, 7 );
if ( regVal )
{
SingleResponseIsr();
GPIOIntClear( PORT0, 7 );
}
return;
}
/*****************************************************************************
** Function name: PIOINT2_IRQHandler
**
** Descriptions: Use one GPIO pin(port2 pin1) as interrupt source
**
** parameters: None
** Returned value: None
**
*****************************************************************************/
void PIOINT2_IRQHandler(void)
{
uint32_t regVal;
gpio2_counter++;
regVal = GPIOIntStatus( PORT2, 1 );
if ( regVal )
{
p2_1_counter++;
GPIOIntClear( PORT2, 1 );
}
return;
}
/*****************************************************************************
** Function name: PIOINT1_IRQHandler
**
** Descriptions: Use one GPIO pin(port1 pin1) as interrupt source
**
** parameters: None
** Returned value: None
**
*****************************************************************************/
void PIOINT1_IRQHandler(void)
{
uint32_t regVal;
gpio1_counter++;
regVal = GPIOIntStatus( PORT1, 4 );
if ( regVal )
{
p1_1_counter++;
GPIOIntClear( PORT1, 4 );
}
return;
}
/************ FUNCTION DEFINITIONS ****************/
void modeselect(void)
{
if(GPIOIntStatus(GPIO_PORTF_BASE,false) & GPIO_INT_PIN_0)
{
GPIOIntClear(GPIO_PORTF_BASE,GPIO_PIN_0);
for(i=0;i<2000;i++);
if (GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0)
{
mode++;
if (mode==6)
mode = 1;
switch(mode) //According to mode, initialize peripherals and disable other peripherals
{
case 1: mode2unset(); mode3unset(); mode4unset(); mode5unset(); mode1set(); break;
case 2: mode1unset(); mode3unset(); mode4unset(); mode5unset(); mode2set(); break;
case 3: mode2unset(); mode1unset(); mode4unset(); mode5unset(); mode3set(); break;
case 4: mode2unset(); mode1unset(); mode3unset(); mode5unset(); mode4set(); break;
case 5: mode2unset(); mode1unset(); mode4unset(); mode3unset(); mode5set(); break;
}
}
}
if((GPIOIntStatus(GPIO_PORTF_BASE,false)&GPIO_INT_PIN_4)&& (mode==2||mode==5))
{
GPIOIntClear(GPIO_PORTF_BASE,GPIO_PIN_4);
if(!GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4))
{
mode2();
TimerLoadSet(TIMER1_BASE, TIMER_A,SysCtlClockGet()/3); //Set the Max Value of the timer
TimerEnable(TIMER1_BASE,TIMER_A); //Start the timer
}
else
{
TimerDisable(TIMER1_BASE,TIMER_A);
fast_flag=0;
}
}
}
/*****************************************************************************
** Function name: PIOINT3_IRQHandler
**
** Descriptions: Use one GPIO pin(port3 pin1) as interrupt source
**
** parameters: None
** Returned value: None
**
*****************************************************************************/
void PIOINT3_IRQHandler(void)
{
uint32_t regVal;
gpio3_counter++;
regVal = GPIOIntStatus( PORT3, 1 );
if ( regVal )
{
p3_1_counter++;
GPIOIntClear( PORT3, 1 );
intPin = 3;
}
return;
}
void GPIOM_intHandler()
{
unsigned long intStatus;
intStatus = GPIOIntStatus(GPIO_PORTM_BASE, 0);
GPIOIntClear(GPIO_PORTM_BASE,intStatus);
if(intStatus & GPIO_PIN_7)
{
if(pIrqEventHandler)
{
pIrqEventHandler(0);
}
}
}
void Interrupt_PortE(void) {
if (GPIOIntStatus(GPIO_PORTE_BASE, false) == GPIO_PIN_1) {
GPIOIntClear(GPIO_PORTE_BASE, GPIO_PIN_1);
min_alarm <= 0 ? min_alarm = 0 : min_alarm--;
}
if (GPIOIntStatus(GPIO_PORTE_BASE, false) == GPIO_PIN_3) {
GPIOIntClear(GPIO_PORTE_BASE, GPIO_PIN_3);
sec_alarm <= 0 ? sec_alarm = 0 : sec_alarm--;
}
if (GPIOIntStatus(GPIO_PORTE_BASE, false) == GPIO_PIN_2) {
GPIOIntClear(GPIO_PORTE_BASE, GPIO_PIN_2);
sec_alarm > 59 ? sec_alarm = 0 : sec_alarm++;
}
if (GPIOIntStatus(GPIO_PORTE_BASE, false) == GPIO_PIN_0) {
GPIOIntClear(GPIO_PORTE_BASE, GPIO_PIN_0);
min_alarm > 59 ? min_alarm = 0 : min_alarm++;
}
// Delay 10ms de han che nhieu tu nut nhan
SysCtlDelay(40000000/300);
}
/*
* This is the interrupt handler for the button that changes the LEDs brightness
*/
void PortFIntHandler(){
uint32_t status=0;
status = GPIOIntStatus(GPIO_PORTF_BASE,true);
GPIOIntClear(GPIO_PORTF_BASE,status);
if( GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_1) == 0)
Maxbrilho = 255;
else
Maxbrilho = 50;
MudaPadrao = 1;
}
void GPIOXIntHandler(uint32_t base, void (**funcs)(void))
{
uint32_t i;
uint32_t isr = GPIOIntStatus(base, true);
GPIOIntClear(base, isr);
for (i=0; i<8; i++, isr>>=1) {
if ((isr & 0x1) == 0)
continue;
if (funcs[i])
funcs[i]();
}
}
/*****************************************************************************
** Function name: PIOINT3_IRQHandler
**
** Descriptions: Use one GPIO pin(port3 pin1) as interrupt source
**
** parameters: None
** Returned value: None
**
*****************************************************************************/
void PIOINT3_IRQHandler(void)
{
uint32_t regVal;
GPIOSetValue( 2, 7, LED_ON );
GPIOSetValue( 2, 8, LED_ON );
gpio3_counter++;
regVal = GPIOIntStatus( PORT3, 1 );
if ( regVal )
{
p3_1_counter++;
GPIOIntClear( PORT3, 1 );
}
return;
}
void IRQ_intHandler()
{
unsigned long intStatus;
intStatus = GPIOIntStatus(CC3100_IRQBASE, 0);
GPIOIntClear(CC3100_IRQBASE,intStatus);
if(intStatus & CC3100_IRQPIN)
{
#ifndef SL_IF_TYPE_UART
if(pIrqEventHandler)
{
pIrqEventHandler(0);
}
#endif
}
}
static void ButtonsISR(void)
{
uint32_t ui32_IntStatus;
ui32_IntStatus = GPIOIntStatus(GPIO_PORTF_BASE, true);
GPIOIntClear(GPIO_PORTF_BASE, ui32_IntStatus);
if (ui32_IntStatus & GPIO_PIN_0)
{
Button_pressed |= 0x01 << BUTTON_RIGHT;
}
if (ui32_IntStatus & GPIO_PIN_4)
{
Button_pressed |= 0x01 << BUTTON_LEFT;
}
button_Runtimeout(&ButtonDebounceCallback, BUTTON_DEBOUNCE_MS);
}
//*****************************************************************************
//
// Called by the NVIC as a result of GPIO port F interrupt event. For this
// application GPIO port F pin 0 corresponds to calibration button
//
//*****************************************************************************
void IntGPIOF(void) {
unsigned long ulStatus;
ulStatus = GPIOIntStatus(GPIO_PORTF_BASE, true);
//
// Clear all the pin interrupts that are set
//
GPIOIntClear(GPIO_PORTF_BASE, ulStatus);
if (ulStatus & GPIO_PIN_4) {
if (g_calibrationState == 0 || g_calibrationState == 1
|| g_calibrationState == 3 || g_calibrationState == 5)
Calibration();
}
}
//*****************************************************************************
//
//! GPIO Interrupt Handler for S2 button
//!
//! \param None
//!
//! \return None
//
//*****************************************************************************
static void SpeakerButtonHandler()
{
unsigned long ulPinState = GPIOIntStatus(GPIOA2_BASE,1);
if(ulPinState & GPIO_PIN_6)
{
//Clear and Disable GPIO Interrupt
MAP_GPIOIntDisable(GPIOA2_BASE,GPIO_PIN_6);
MAP_GPIOIntClear(GPIOA2_BASE,GPIO_PIN_6);
MAP_IntDisable(INT_GPIOA2);
//Call Speaker Handler
if(g_pAudioOutControlHdl)
{
g_pAudioOutControlHdl();
}
}
}
//*****************************************************************************
//
// Called by the NVIC as a result of GPIO port E interrupt event. For this
// application GPIO port E pin 2 is the interrupt line for the MPU9150
//
//*****************************************************************************
void IntGPIOE(void) {
unsigned long ulStatus;
ulStatus = GPIOIntStatus(GPIO_PORTE_BASE, true);
//
// Clear all the pin interrupts that are set
//
GPIOIntClear(GPIO_PORTE_BASE, ulStatus);
if (ulStatus & GPIO_PIN_2) {
//
// MPU9150 Data is ready for retrieval and processing.
//
MPU9150DataRead(&g_sMPU9150Inst, MPU9150AppCallback, &g_sMPU9150Inst);
}
}
void FanFbHandler(void)
{
unsigned long ulStatus;
ulStatus = GPIOIntStatus(GPIO_PORTD_BASE, true);
GPIOIntClear(GPIO_PORTD_BASE, ulStatus);
switch(ulStatus)
{
case GPIO_PIN_2: //
g_u32FanFbSpeed++;
break;
case GPIO_PIN_6: //
UARTprintf("HV ERR !\n");
break;
case GPIO_PIN_7: //
UARTprintf("HV LAHU\n");
break;
}
}
//*****************************************************************************
//
// Called by the NVIC as a result of GPIO port E interrupt event. For this
// application GPIO port E pin 0 is the interrupt line for the TMP006
//
//*****************************************************************************
void
IntGPIOe(void)
{
uint32_t ui32Status;
ui32Status = GPIOIntStatus(GPIO_PORTE_BASE, true);
//
// Clear all the pin interrupts that are set
//
GPIOIntClear(GPIO_PORTE_BASE, ui32Status);
if(ui32Status & GPIO_PIN_0)
{
//
// This interrupt indicates a conversion is complete and ready to be
// fetched. So we start the process of getting the data.
//
TMP006DataRead(&g_sTMP006Inst, TMP006AppCallback, &g_sTMP006Inst);
}
}
void
GPIOPortEIntHandler(void)
{
unsigned long ulStatus;
ulStatus = GPIOIntStatus(GPIO_PORTE_BASE, 1);
//
// Clear all the pin interrupts that are set
//
GPIOIntClear(GPIO_PORTE_BASE, ulStatus);
if(ulStatus & GPIO_PIN_5)
{
//
// ISL29023 has indicated that the light level has crossed outside of
// the intensity threshold levels set in INT_LT and INT_HT registers.
//
g_vui8IntensityFlag = 1;
}
}
//*****************************************************************************
//
// Called by the NVIC as a result of GPIO port B interrupt event. For this
// application GPIO port B pin 2 is the interrupt line for the MPU9150
//
//*****************************************************************************
void
IntGPIOb(void)
{
uint32_t ui32Status;
ui32Status = GPIOIntStatus(GPIO_PORTB_BASE, true);
//
// Clear all the pin interrupts that are set
//
GPIOIntClear(GPIO_PORTB_BASE, ui32Status);
//
// Check which GPIO caused the interrupt event.
//
if(ui32Status & GPIO_PIN_2)
{
//
// The MPU9150 data ready pin was asserted so start an I2C transfer
// to go get the latest data from the device.
//
MPU9150DataRead(&g_sMPU9150Inst, MotionCallback, &g_sMPU9150Inst);
}
}
//*****************************************************************************
//
//! This is the handle for the GPIO ports.
//!
//! This handle, first interruption collects, save the time and value changes
//! following interruption.Second, if the interruption is for low level,
//! save the valor of time clock and the difference is the TOF in this pin.
//!
//! \return none.
//
//*****************************************************************************
void
TOFProcess(){
//nada mas llegar nos da igual que pin sea,
uint64_t temporal = micros();
//Ahora aqui revisamos las interrupciones y deducimos el puerto en cuestion y su pin
int32_t interrupts;
#ifdef USEPORTA
interrupts = GPIOIntStatus(GPIO_PORTA_BASE,true);
#ifdef USEPORTAPIN0
if(interrupts &&GPIO_INT_PIN_0 ){
if(GPIOIntTypeGet(GPIO_PORTA_BASE,GPIO_PIN_0) == GPIO_HIGH_LEVEL){
ValorA[0] = temporal;
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_0,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorAResultado[0] = ((float)(temporal / ValorA[0])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTAPIN1
interrupts = Mask[1];
if((interrupts &&GPIO_INT_PIN_1) >>1 ){
if(GPIOIntTypeGet(GPIO_PORTA_BASE,GPIO_PIN_1) == GPIO_HIGH_LEVEL){
ValorA[1] = temporal;
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_1,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorAResultado[0] = ((float)(temporal / ValorA[1])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTAPIN2
if((interrupts &&GPIO_INT_PIN_2) >>2 ){
if(GPIOIntTypeGet(GPIO_PORTA_BASE,GPIO_PIN_2) == GPIO_HIGH_LEVEL){
ValorA[2] = temporal;
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_2,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorAResultado[2] = ((float)(temporal / ValorA[2])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTAPIN3
if((interrupts &&GPIO_INT_PIN_3) >>3 ){
if(GPIOIntTypeGet(GPIO_PORTA_BASE,GPIO_PIN_3) == GPIO_HIGH_LEVEL){
ValorA[3] = temporal;
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_3,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorAResultado[3] = ((float)(temporal / ValorA[3])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTAPIN4
if((interrupts &&GPIO_INT_PIN_4) >>4 ){
if(GPIOIntTypeGet(GPIO_PORTA_BASE,GPIO_PIN_0) == GPIO_HIGH_LEVEL){
ValorA[4] = temporal;
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_0,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorAResultado[4] = ((float)(temporal / ValorA[4])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTAPIN5
if((interrupts &&GPIO_INT_PIN_5) >>5 ){
if(GPIOIntTypeGet(GPIO_PORTA_BASE,GPIO_PIN_5) == GPIO_HIGH_LEVEL){
ValorA[5] = temporal;
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_5,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorAResultado[5] = ((float)(temporal / ValorA[5])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTAPIN6
if((interrupts &&GPIO_INT_PIN_6) >>6 ){
if(GPIOIntTypeGet(GPIO_PORTA_BASE,GPIO_PIN_6) == GPIO_HIGH_LEVEL){
ValorA[6] = temporal;
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_6,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorAResultado[6] = ((float)(temporal / ValorA[6])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTAPIN7
if((interrupts &&GPIO_INT_PIN_7) >>7 ){
if(GPIOIntTypeGet(GPIO_PORTA_BASE,GPIO_PIN_7) == GPIO_HIGH_LEVEL){
ValorA[7] = temporal;
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_7,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorAResultado[7] = ((float)(temporal / ValorA[7])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL);
}
}
#endif
//Limpiamos las interrupciones antes de salir
GPIOIntClear(GPIO_PORTA_BASE,interrupts);
#endif
#ifdef USEPORTB
interrupts = 0;
interrupts= GPIOIntStatus(GPIO_PORTB_BASE,true);
#ifdef USEPORTBPIN0
if(interrupts &&GPIO_INT_PIN_0 ){
if(GPIOIntTypeGet(GPIO_PORTB_BASE,GPIO_PIN_0) == GPIO_HIGH_LEVEL){
ValorB[0] = temporal;
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_0,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorBResultado[0] = ((float)(temporal / ValorB[0])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTBPIN1
if((interrupts &&GPIO_INT_PIN_1) >>1 ){
if(GPIOIntTypeGet(GPIO_PORTB_BASE,GPIO_PIN_1) == GPIO_HIGH_LEVEL){
ValorB[1] = temporal;
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_1,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorBResultado[0] = ((float)(temporal / ValorB[1])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTBPIN2
if((interrupts &&GPIO_INT_PIN_2) >>2 ){
if(GPIOIntTypeGet(GPIO_PORTB_BASE,GPIO_PIN_2) == GPIO_HIGH_LEVEL){
ValorB[2] = temporal;
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_2,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorBResultado[2] = ((float)(temporal / ValorB[2])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTBPIN3
if((interrupts &&GPIO_INT_PIN_3) >>3 ){
if(GPIOIntTypeGet(GPIO_PORTB_BASE,GPIO_PIN_3) == GPIO_HIGH_LEVEL){
ValorB[3] = temporal;
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_3,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorBResultado[3] = ((float)(temporal / ValorB[3])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTBPIN4
if((interrupts &&GPIO_INT_PIN_4) >>4 ){
if(GPIOIntTypeGet(GPIO_PORTB_BASE,GPIO_PIN_0) == GPIO_HIGH_LEVEL){
ValorB[4] = temporal;
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_0,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorBResultado[4] = ((float)(temporal / ValorB[4])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTBPIN5
if((interrupts &&GPIO_INT_PIN_5) >>5 ){
if(GPIOIntTypeGet(GPIO_PORTB_BASE,GPIO_PIN_5) == GPIO_HIGH_LEVEL){
ValorB[5] = temporal;
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_5,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorBResultado[5] = ((float)(temporal / ValorB[5])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTBPIN6
if((interrupts &&GPIO_INT_PIN_6) >>6 ){
if(GPIOIntTypeGet(GPIO_PORTB_BASE,GPIO_PIN_6) == GPIO_HIGH_LEVEL){
ValorB[6] = temporal;
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_6,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorBResultado[6] = ((float)(temporal / ValorB[6])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTBPIN7
if((interrupts &&GPIO_INT_PIN_7) >>7 ){
if(GPIOIntTypeGet(GPIO_PORTB_BASE,GPIO_PIN_7) == GPIO_HIGH_LEVEL){
ValorB[7] = temporal;
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_7,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorBResultado[7] = ((float)(temporal / ValorB[7])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL);
}
}
#endif
GPIOIntClear(GPIO_PORTB_BASE,interrupts);
#endif
#ifdef USEPORTC
interrupts = 0;
interrupts= GPIOIntStatus(GPIO_PORTC_BASE,true);
/*
* Estos pines no son validos
if(interrupts &&GPIO_INT_PIN_0 ){
if(GPIOIntTypeGet(GPIO_PORTC_BASE,GPIO_PIN_0) == GPIO_HIGH_LEVEL){
ValorC[0] = temporal;
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_0,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorCResultado[0] = ((float)(temporal / ValorC[0])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL);
}
}
if((interrupts &&GPIO_INT_PIN_1) >>1 ){
if(GPIOIntTypeGet(GPIO_PORTC_BASE,GPIO_PIN_1) == GPIO_HIGH_LEVEL){
ValorC[1] = temporal;
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_1,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorCResultado[0] = ((float)(temporal / ValorC[1])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL);
}
}
if((interrupts &&GPIO_INT_PIN_2) >>2 ){
if(GPIOIntTypeGet(GPIO_PORTC_BASE,GPIO_PIN_2) == GPIO_HIGH_LEVEL){
ValorC[2] = temporal;
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_2,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorCResultado[2] = ((float)(temporal / ValorC[2])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL);
}
}
if((interrupts &&GPIO_INT_PIN_3) >>3 ){
if(GPIOIntTypeGet(GPIO_PORTC_BASE,GPIO_PIN_3) == GPIO_HIGH_LEVEL){
ValorC[3] = temporal;
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_3,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorCResultado[3] = ((float)(temporal / ValorC[3])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL);
}
}*/
#ifdef USEPORTCPIN4
if((interrupts &&GPIO_INT_PIN_4) >>4 ){
if(GPIOIntTypeGet(GPIO_PORTC_BASE,GPIO_PIN_0) == GPIO_HIGH_LEVEL){
ValorC[4] = temporal;
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_0,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorCResultado[4] = ((float)(temporal / ValorC[4])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTCPIN5
if((interrupts &&GPIO_INT_PIN_5) >>5 ){
if(GPIOIntTypeGet(GPIO_PORTC_BASE,GPIO_PIN_5) == GPIO_HIGH_LEVEL){
ValorC[5] = temporal;
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_5,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorCResultado[5] = ((float)(temporal / ValorC[5])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTCPIN6
if((interrupts &&GPIO_INT_PIN_6) >>6 ){
if(GPIOIntTypeGet(GPIO_PORTC_BASE,GPIO_PIN_6) == GPIO_HIGH_LEVEL){
ValorC[6] = temporal;
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_6,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorCResultado[6] = ((float)(temporal / ValorC[6])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTCPIN7
if((interrupts &&GPIO_INT_PIN_7) >>7 ){
if(GPIOIntTypeGet(GPIO_PORTC_BASE,GPIO_PIN_7) == GPIO_HIGH_LEVEL){
ValorC[7] = temporal;
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_7,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorCResultado[7] = ((float)(temporal / ValorC[7])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL);
}
}
#endif
GPIOIntClear(GPIO_PORTC_BASE,interrupts);
#endif
#ifdef USEPORTD
interrupts = 0;
interrupts= GPIOIntStatus(GPIO_PORTD_BASE,true);
#ifdef USEPORTDPIN0
if(interrupts &&GPIO_INT_PIN_0 ){
if(GPIOIntTypeGet(GPIO_PORTD_BASE,GPIO_PIN_0) == GPIO_HIGH_LEVEL){
ValorD[0] = temporal;
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_0,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorDResultado[0] = ((float)(temporal / ValorD[0])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTDPIN1
if((interrupts &&GPIO_INT_PIN_1) >>1 ){
if(GPIOIntTypeGet(GPIO_PORTD_BASE,GPIO_PIN_1) == GPIO_HIGH_LEVEL){
ValorD[1] = temporal;
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_1,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorDResultado[0] = ((float)(temporal / ValorD[1])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTDPIN2
if((interrupts &&GPIO_INT_PIN_2) >>2 ){
if(GPIOIntTypeGet(GPIO_PORTD_BASE,GPIO_PIN_2) == GPIO_HIGH_LEVEL){
ValorD[2] = temporal;
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_2,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorDResultado[2] = ((float)(temporal / ValorD[2])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTDPIN3
if((interrupts &&GPIO_INT_PIN_3) >>3 ){
if(GPIOIntTypeGet(GPIO_PORTD_BASE,GPIO_PIN_3) == GPIO_HIGH_LEVEL){
ValorD[3] = temporal;
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_3,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorDResultado[3] = ((float)(temporal / ValorD[3])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTDPIN4
if((interrupts &&GPIO_INT_PIN_4) >>4 ){
if(GPIOIntTypeGet(GPIO_PORTD_BASE,GPIO_PIN_0) == GPIO_HIGH_LEVEL){
ValorD[4] = temporal;
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_0,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorDResultado[4] = ((float)(temporal / ValorD[4])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTDPIN5
if((interrupts &&GPIO_INT_PIN_5) >>5 ){
if(GPIOIntTypeGet(GPIO_PORTD_BASE,GPIO_PIN_5) == GPIO_HIGH_LEVEL){
ValorD[5] = temporal;
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_5,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorDResultado[5] = ((float)(temporal / ValorD[5])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTDPIN6
if((interrupts &&GPIO_INT_PIN_6) >>6 ){
if(GPIOIntTypeGet(GPIO_PORTD_BASE,GPIO_PIN_6) == GPIO_HIGH_LEVEL){
ValorD[6] = temporal;
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_6,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorDResultado[6] = ((float)(temporal / ValorD[6])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTDPIN7
if((interrupts &&GPIO_INT_PIN_7) >>7 ){
if(GPIOIntTypeGet(GPIO_PORTD_BASE,GPIO_PIN_7) == GPIO_HIGH_LEVEL){
ValorD[7] = temporal;
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_7,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorDResultado[7] = ((float)(temporal / ValorD[7])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL);
}
}
#endif
GPIOIntClear(GPIO_PORTD_BASE,interrupts);
#endif
#ifdef USEPORTE
interrupts = 0;
interrupts= GPIOIntStatus(GPIO_PORTE_BASE,true);
#ifdef USEPORTEPIN0
if(interrupts &&GPIO_INT_PIN_0 ){
if(GPIOIntTypeGet(GPIO_PORTE_BASE,GPIO_PIN_0) == GPIO_HIGH_LEVEL){
ValorE[0] = temporal;
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_0,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorEResultado[0] = ((float)(temporal / ValorE[0])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTEPIN1
if((interrupts &&GPIO_INT_PIN_1) >>1 ){
if(GPIOIntTypeGet(GPIO_PORTE_BASE,GPIO_PIN_1) == GPIO_HIGH_LEVEL){
ValorE[1] = temporal;
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_1,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorEResultado[0] = ((float)(temporal / ValorE[1])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTEPIN2
if((interrupts &&GPIO_INT_PIN_2) >>2 ){
if(GPIOIntTypeGet(GPIO_PORTE_BASE,GPIO_PIN_2) == GPIO_HIGH_LEVEL){
ValorE[2] = temporal;
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_2,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorEResultado[2] = ((float)(temporal / ValorE[2])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTEPIN3
if((interrupts &&GPIO_INT_PIN_3) >>3 ){
if(GPIOIntTypeGet(GPIO_PORTE_BASE,GPIO_PIN_3) == GPIO_HIGH_LEVEL){
ValorE[3] = temporal;
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_3,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorEResultado[3] = ((float)(temporal / ValorE[3])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTEPIN4
if((interrupts &&GPIO_INT_PIN_4) >>4 ){
if(GPIOIntTypeGet(GPIO_PORTE_BASE,GPIO_PIN_0) == GPIO_HIGH_LEVEL){
ValorE[4] = temporal;
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_0,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorEResultado[4] = ((float)(temporal / ValorE[4])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTEPIN5
if((interrupts &&GPIO_INT_PIN_5) >>5 ){
if(GPIOIntTypeGet(GPIO_PORTE_BASE,GPIO_PIN_5) == GPIO_HIGH_LEVEL){
ValorE[5] = temporal;
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_5,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorEResultado[5] = ((float)(temporal / ValorE[5])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL);
}
}
#endif
/*
* Estos pines no son validos
if((interrupts &&GPIO_INT_PIN_6) >>6 ){
if(GPIOIntTypeGet(GPIO_PORTE_BASE,GPIO_PIN_6) == GPIO_HIGH_LEVEL){
ValorE[6] = temporal;
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_6,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorEResultado[6] = ((float)(temporal / ValorE[6])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL);
}
}
if((interrupts &&GPIO_INT_PIN_7) >>7 ){
if(GPIOIntTypeGet(GPIO_PORTE_BASE,GPIO_PIN_7) == GPIO_HIGH_LEVEL){
ValorE[7] = temporal;
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_7,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorEResultado[7] = ((float)(temporal / ValorE[7])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL);
}
}*/
GPIOIntClear(GPIO_PORTE_BASE,interrupts);
#endif
#ifdef USEPORTF
interrupts = 0;
interrupts= GPIOIntStatus(GPIO_PORTF_BASE,true);
#ifdef USEPORTFPIN0
if(interrupts &&GPIO_INT_PIN_0 ){
if(GPIOIntTypeGet(GPIO_PORTF_BASE,GPIO_PIN_0) == GPIO_HIGH_LEVEL){
ValorF[0] = temporal;
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_0,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorFResultado[0] = ((float)(temporal / ValorF[0])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTFPIN1
if((interrupts &&GPIO_INT_PIN_1) >>1 ){
if(GPIOIntTypeGet(GPIO_PORTF_BASE,GPIO_PIN_1) == GPIO_HIGH_LEVEL){
ValorF[1] = temporal;
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_1,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorFResultado[0] = ((float)(temporal / ValorF[1])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTFPIN2
if((interrupts &&GPIO_INT_PIN_2) >>2 ){
if(GPIOIntTypeGet(GPIO_PORTF_BASE,GPIO_PIN_2) == GPIO_HIGH_LEVEL){
ValorF[2] = temporal;
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_2,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorFResultado[2] = ((float)(temporal / ValorF[2])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTFPIN3
if((interrupts &&GPIO_INT_PIN_3) >>3 ){
if(GPIOIntTypeGet(GPIO_PORTF_BASE,GPIO_PIN_3) == GPIO_HIGH_LEVEL){
ValorF[3] = temporal;
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_3,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorFResultado[3] = ((float)(temporal / ValorF[3])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL);
}
}
#endif
#ifdef USEPORTFPIN4
if((interrupts &&GPIO_INT_PIN_4) >>4 ){
if(GPIOIntTypeGet(GPIO_PORTF_BASE,GPIO_PIN_0) == GPIO_HIGH_LEVEL){
ValorF[4] = temporal;
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_0,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorFResultado[4] = ((float)(temporal / ValorF[4])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL);
}
}
#endif
/*Estos Pines no son validos
* */
/* if((interrupts &&GPIO_INT_PIN_5) >>5 ){
if(GPIOIntTypeGet(GPIO_PORTF_BASE,GPIO_PIN_5) == GPIO_HIGH_LEVEL){
ValorF[5] = temporal;
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_5,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorFResultado[5] = ((float)(temporal / ValorF[5])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL);
}
}
if((interrupts &&GPIO_INT_PIN_6) >>6 ){
if(GPIOIntTypeGet(GPIO_PORTF_BASE,GPIO_PIN_6) == GPIO_HIGH_LEVEL){
ValorF[6] = temporal;
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_6,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorFResultado[6] = ((float)(temporal / ValorF[6])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL);
}
}
if((interrupts &&GPIO_INT_PIN_7) >>7 ){
if(GPIOIntTypeGet(GPIO_PORTF_BASE,GPIO_PIN_7) == GPIO_HIGH_LEVEL){
ValorF[7] = temporal;
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_7,GPIO_LOW_LEVEL);
}else{
//Aqui es la bajada y ya podemos hacer la diferencia de tiempos para obtener el valor
ValorFResultado[7] = ((float)(temporal / ValorF[7])) / CteVuelo; //Resultado en cm
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL);
}
}*/
GPIOIntClear(GPIO_PORTF_BASE,interrupts);
#endif
}
void Interrupt_PortF(void) {
if (GPIOIntStatus(GPIO_PORTF_BASE, false) == GPIO_PIN_1) {
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_1);
}
if (GPIOIntStatus(GPIO_PORTF_BASE, false) == GPIO_PIN_4) {
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4);
}
if (GPIOIntStatus(GPIO_PORTF_BASE, false) == GPIO_PIN_3) {
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_3);
if (!is_active) mode > MODE_GRILL ? mode = MODE_MICRO : mode++;
}
if (GPIOIntStatus(GPIO_PORTF_BASE, false) == GPIO_PIN_2) {
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_2);
}
if (GPIOIntStatus(GPIO_PORTF_BASE, false) == GPIO_PIN_0) {
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_0);
if (start_stop) {
start_stop = false;
} else {
start_stop = true;
}
if (start_stop) {
is_active = true;
time_val = min_alarm * 60 + sec_alarm;
if (time_val <= 9) {
Write_Str("Error! Time is small", 3, 0);
} else {
// kiem tra neu cua dong moi bat dau nuong
if (door_is_close) {
// hien thi trang thai cho nguoi dung
Write_Str("Running:", 2, 0);
// hien thi mode hien tai
Write_Str(mode_def[mode], 2, 10);
// bat dau dem nguoc thoi gian
TimerEnable(TIMER0_BASE, TIMER_A);
// lua chon mode la micro hay grill
if (mode == MODE_GRILL) {
GPIOPinWrite(GPIO_PORTB_BASE, GRILL_PIN, GRILL_PIN);
} else {
GPIOPinWrite(GPIO_PORTB_BASE, MICRO_PIN, MICRO_PIN);
}
}
}
} else {
// Xoa man hinh
Write_Command(0x01);
// Hien thi che do
Write_Str("Stoped!", 2, 0);
// Reset bien
min_alarm = sec_alarm = time_val = 0;
// Tat timer
TimerDisable(TIMER0_BASE, TIMER_A);
}
}
SysCtlDelay(40000000 / 300);
}
/*
* PA7外部中断处理函数
*/
void PA7_int_hander(void)
{
uint32_t int_status;
int8_t result=0;
static int16_t NRF_recv_16[16]; //中断接收到对方发来的数据
static int16_t key_coding;
static float powerVal = 0;
int_status = GPIOIntStatus(GPIO_PORTA_BASE, true);
GPIOIntClear(GPIO_PORTA_BASE, int_status);
result = NRF_IQR_hander_RX_16(NRF_recv_16,4); //NRF24L01 IRQ 中断处理函数(接收4通道遥控数据）
//result = TX_RX_NRF_IQR_hander_RX_16(NRF_recv_16,4);//NRF24L01 IRQ 中断处理函数(模式转换，数据接收)
if(result == 2)//接收中断(发送成功或者重发中断也会进这个函数！)
{
#if 1
#if 1
Attitude.ideal_Rol = (-1 * (float)NRF_recv_16[0] / 2) * cos(myYawVal / 180 * PI) - (-1 * (float)NRF_recv_16[1] / 2) * sin(myYawVal / 180 * PI);
Attitude.ideal_Pit = (-1 * (float)NRF_recv_16[1] / 2) * cos(myYawVal / 180 * PI) + (-1 * (float)NRF_recv_16[0] / 2) * sin(myYawVal / 180 * PI); //倾角(deg)
//Attitude.ideal_Yaw = (float)NRF_recv_16[2] / 10; //角度
#else
Attitude.ideal_Rol = -1 * (float)NRF_recv_16[0] / 2;
Attitude.ideal_Pit = -1 * (float)NRF_recv_16[1] / 2; //倾角(deg)
//Attitude.ideal_Yaw = (float)NRF_recv_16[2] / 10; //角度
#endif
key_coding = NRF_recv_16[3]; //按键编码值throttle_high
#if 1
sendLineX(MCU1, 0X0F, Attitude.ideal_Rol);
sendLineX(MCU1, 0X2F, Attitude.ideal_Pit);
//sendLineX(MCU1, 0X6F, Attitude.ideal_Yaw);
#endif
#else
g_RC_Position.x = (float)NRF_recv_16[0]*0.02f;
g_RC_Position.y = (float)NRF_recv_16[1]*0.02f; //水平位置(m)
g_RC_Position.yaw_rate = (float)NRF_recv_16[2]/10;//角速度
key_coding = NRF_recv_16[3]; //按键编码值throttle_high
#endif
switch(key_coding) //辨认按键编码值(对按键编码值进行解码)
{
case 100://关机
{
g_key_decode = 0;
stopFlag = 1;
startFlag = 0;
powerVal = 0;
delayTimes = 0;
Attitude.Throttle_Hight = Motor_Closed;
clearIntegration(1);
break;
}
case 103://关机
{
g_key_decode = 1;
stopFlag = 1;
startFlag = 0;
powerVal = 0;
delayTimes = 0;
Attitude.Throttle_Hight = Motor_Closed;
clearIntegration(1);
break;
}
case 101://加油门
{
g_key_decode = 2;
stopFlag = 0;
powerVal += 1;
if(powerVal >= 110)
{
powerVal = 110;
}
#ifndef SIDE_DOWN
Attitude.Throttle_Hight = Throttle_START + powerVal * 15;
#else
Attitude.Throttle_Hight = Throttle_START + powerVal * 15;
#endif
break;
}
case 102://减油门
{
g_key_decode = 3;
stopFlag = 0;
powerVal = powerVal - 1;
if(powerVal < -50)
{
powerVal = -50;
}
#ifndef SIDE_DOWN
Attitude.Throttle_Hight = Throttle_START + powerVal * 15;
#else
Attitude.Throttle_Hight = Throttle_START + powerVal * 15;
#endif
break;
}
case 104://开机
{
if(startFlag != 1)
{
g_key_decode = 50;
startFlag = 1;
stopFlag = 1;
}
break;
}
}
#if 0
sendLineX(MCU1, 0X3F, powerVal);
sendLineX(MCU1, 0X4F, Attitude.Throttle_Hight);
#endif
}
}
void ir_in_recive_handler(void)
{
uint32 status;
uint32 time_cnt;
uint32 time_cur;
status = GPIOIntStatus(IR_IN_PORT, 1);
GPIOIntClear(IR_IN_PORT, status);
if(GPIO_ReadSinglePin(IR_IN_PORT, IR_IN_PIN)){
SET_IR_OUT(1);
}else{
SET_IR_OUT(0);
return;
}
time_cur = bsp_timer0_get_time();
time_cnt = time_cur - ir_jack.last_time;
ir_jack.last_time = time_cur;
gIr_timeout = 0;
switch(ir_jack.state){
case NEC_IDLE:
ir_jack.state = NEC_LEADER;
break;
case NEC_LEADER:
if(time_cnt < LEADER_TIME_MAX && time_cnt > LEADER_TIME_MIN){
ir_jack.code.val = 0;
ir_jack.bitcnt = 0;
ir_jack.state = NEC_CODE;
}else{
ir_jack.state = NEC_IDLE;
}
break;
case NEC_CODE:
if(time_cnt < ONE_TIME_MAX && time_cnt > ZERO_TIME_MIN){
ir_jack.bitcnt++;
ir_jack.code.val >>= 1;
if(time_cnt >= MEDIAN_BIT_TIME){
ir_jack.code.val |= 0x80000000;
}
}
if(ir_jack.bitcnt == 32){
SYS_TRACE("jack ir code =[%x],LB=%2x, HB=%2x, UB=%2x, MB=%2x \r\n", ir_jack.code.val, ir_jack.code.byte.LB, ir_jack.code.byte.HB, ir_jack.code.byte.UB, ir_jack.code.byte.MB);
if((ir_jack.code.byte.LB == CUSTMER_CODE_LB) && (ir_jack.code.byte.HB == CUSTMET_CODE_HB)){
if((ir_jack.code.byte.MB & ir_jack.code.byte.UB) == 0){
ring_buffer_write(IR_BACK_IN, ir_jack.code.byte.UB);
ir_jack.bitcnt = 0;
ir_jack.state = NEC_REPEATE1;
if((ir_commond[IR_VOL_UP] == ir_jack.code.byte.UB) || (ir_commond[IR_LFET] == ir_jack.code.byte.UB) || (ir_commond[IR_RIGHT]== ir_jack.code.byte.UB) || (ir_commond[IR_VOL_DOWN] == ir_jack.code.byte.UB)){
repeat_thres = 5;
repeat_commond = ir_jack.code.byte.UB;
}else{
repeat_thres = 0;
repeat_commond = 0;
}
ir_jack.code.val = 0;
}else{
ir_jack.state = NEC_IDLE;
}
}else{
ir_jack.state = NEC_IDLE;
}
}
break;
case NEC_REPEATE1:
ir_jack.state = NEC_REPEATE2;
break;
case NEC_REPEATE2:
if(time_cnt <= REPEAT_TIME_MAX && time_cnt >= REPEAT_TIME_MIN){
if(repeat_commond){
ir_jack.state = NEC_REPEATE1;
if(repeat_thres){
repeat_thres--;
}else{
ring_buffer_write(IR_BACK_IN, repeat_commond);
}
}else{
ir_jack.state = NEC_IDLE;
}
}
break;
default:
break;
}