ELEVADOR

OBJETIVO

Desarrollar un programa que simule el funcionamiento de un elevador haciendo uso de los micro switch  del micro controlador para los estados de planta baja, planta alta y paro de emergencia.

DESCRIPCIÓN DEL PROGRAMA

Se definen los tiempos de subida, bajada y flaseo, se enumeran los estados, se declara la variable volatile bool Boton que indicará el cambio de piso.

En la interrupción del PIT se verifica si hay un retardo, si lo hay este se va decrementando. La función de micro SW2, declara un retardo igual a cero y pasa al estado de paro de emergencia indicado por el flasheo del led rojo. Y la función del micro SW3 permite conmutar entre los estados de planta alta y planta baja, además pone la bandera de Boton en verdadero que es requerida para ingresar a las funciones de los estados anteriormente mencionados.

Cuando se ejecuta el programa, el primer estado es el de Planta Baja indicado por un led rojo, al presionar el SW3 cambia de estado, esta transición es caracterizada por un led ámbar, una vez llegado a planta alta el led será Verde y para hacer el cambio de piso se requiere nuevamente la señal de SW3, ahora la transición es indicada por un led Azul, una vez alcanzado el siguiente estado se encenderá el led rojo, si en cualquier momento es presionado el SW2 estrada el estado de paro de emergencia indicado por el parpadeo intermitente de led rojo.

DIAGRAMAS

CODIGO

#include "board.h"

#include "pin_mux.h"

#include "clock_config.h"

#include "fsl_pit.h"

#include "fsl_debug_console.h" //imprimir

#include "fsl_port.h"

#include "fsl_gpio.h"

#include "fsl_common.h"

#include "rgb.h"

#include "sw.h"

#define T_ROJO 5000        //TIEMPO DE SUBIDA

#define T_VERDE 5000      //TIEMPO DE BAJADA

#define T_V_F 250            //TIEMPO DE FLASH

//#define T_AMARILLO 5000

enum{EDO_ROJOF, EDO_PISO, EDO_PB};  //ENUMERA LOS ESTADOS

void Init_PIT(void);

void f_Pb();

void f_Piso();

void f_RojoF();

int color = BLUE;

/*!

* @brief Application entry point.

*/

volatile bool Boton = false;  //volatile

unsigned int delay;

int n_Flash=10;  //unsigned int n_Flash=10;

int next_Edo;

void PIT0_IRQHandler(void)

{

/* Clear interrupt flag.*/

PIT_ClearStatusFlags(PIT, kPIT_Chnl_0, PIT_TFLG_TIF_MASK);

if(delay)

delay--;

}

void BOARD_SW2_IRQ_HANDLER(void)

{

/* Clear external interrupt flag. */

GPIO_ClearPinsInterruptFlags(BOARD_SW2_GPIO, 1U << BOARD_SW2_GPIO_PIN);

/* Change state of button. */

delay=0;

next_Edo=EDO_ROJOF;

  }

void BOARD_SW3_IRQ_HANDLER(void)

{

/* Clear external interrupt flag. */

GPIO_ClearPinsInterruptFlags(BOARD_SW3_GPIO, 1U << BOARD_SW3_GPIO_PIN);

/* Change state of button. */

delay=0;

Boton = true;

  // next_Edo=EDO_ROJO;

}

int main(void) {

 /* Init board hardware. */

 BOARD_InitPins();

 BOARD_BootClockRUN();

 BOARD_InitDebugConsole();

 /* Add your code here */

 Ini_RGB();

 Ini_SW2_IRQ();

 Ini_SW3_IRQ();

 Init_PIT();

 delay=0;

 next_Edo=EDO_PB;

 while(1)

 {

 if(!delay){     //si no hay retardo

 switch(next_Edo)

 {

 case EDO_PISO:

 f_Piso();

  break;

 case EDO_ROJOF:

 f_RojoF();

  break;

default:

 case EDO_PB:

 f_Pb();

 break;

 }

 }

 }

 }

void Init_PIT(void)

{

/* Structure of initialize PIT */

pit_config_t pitConfig;

/*

* 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(1000U,CLOCK_GetFreq(kCLOCK_BusClk)));

/* Enable timer interrupts for channel 0 */

PIT_EnableInterrupts(PIT, kPIT_Chnl_0, kPIT_TimerInterruptEnable);

/* Enable at the NVIC */

EnableIRQ(PIT0_IRQn);

/* Start channel 0 */

PRINTF("\r\nStarting channel No.0 ...");

PIT_StartTimer(PIT, kPIT_Chnl_0);

}

void f_Pb()

{

LED_RGB(RED);

if(Boton){

LED_RGB(AMBAR);

delay=T_ROJO;

Boton=false;

next_Edo=EDO_PISO;

}

}

void f_Piso()

{

LED_RGB(GREEN);

if(Boton){

LED_RGB(BLUE);

delay=T_VERDE;

Boton=false;

next_Edo=EDO_PB;

}

}

void f_RojoF()

{

LED_TOGGLE(RED);

delay=T_V_F;

}

// "rgb.h"

#ifndef SOURCE_RGB_H_

#define SOURCE_RGB_H_

#include <string.h>

#include "board.h"

#include "pin_mux.h"

#include "clock_config.h"

#include "fsl_debug_console.h"

#include "fsl_device_registers.h"

#include "fsl_port.h"

enum {RED_BIT=1,GREEN_BIT=2,BLUE_BIT=4};

enum {BLACK,RED,GREEN,AMBAR,BLUE,MAGENTA,CYAN,WHITE};

void Ini_RGB(void);

void LED_RGB(int);

void Printf_Color( int cont);

void LED_TOGGLE(int color);

#endif /* SOURCE_RGB_H_ */

#include "rgb.h"

void Ini_RGB(void)

{

  // Enable the clock to the PORT module that the LED is on.

      CLOCK_EnableClock(kCLOCK_PortB);

      // Setup the red LED pin as GPIO

      PORT_SetPinMux(BOARD_LED_RED_GPIO_PORT,

              BOARD_LED_RED_GPIO_PIN,

              kPORT_MuxAsGpio);

      LED_RED_INIT(LOGIC_LED_OFF);

      // Setup the blue LED pin as GPIO

            PORT_SetPinMux(BOARD_LED_BLUE_GPIO_PORT,

                    BOARD_LED_BLUE_GPIO_PIN,

                    kPORT_MuxAsGpio);

      LED_BLUE_INIT(LOGIC_LED_OFF);

      CLOCK_EnableClock(kCLOCK_PortE);

       // Setup the green LED pin as GPIO

       PORT_SetPinMux(BOARD_LED_GREEN_GPIO_PORT,

               BOARD_LED_GREEN_GPIO_PIN,

               kPORT_MuxAsGpio);

       LED_GREEN_INIT(LOGIC_LED_OFF);

}

void LED_RGB(int color)

{

if(color&RED_BIT)

LED_RED_ON();

else

LED_RED_OFF();

if(color&GREEN_BIT)

LED_GREEN_ON();

else

LED_GREEN_OFF();

if(color&BLUE_BIT)

LED_BLUE_ON();

else

LED_BLUE_OFF();

}

void LED_TOGGLE(int color)

{

static bool toggle = true;

if(toggle)

{

//toggle=false;

LED_RGB(color);

}

else

{

//toggle=true;

LED_RGB(BLACK);

}

toggle=!toggle;

}

void Printf_Color( int color)

{

char *color_names[] = {"Black","Red","Green","Yellow","Blue","Magenta","Cyan","White"};

char *aux_pointer =color_names[color];

PRINTF("Color Led %s\r\n",aux_pointer);

}

/*

 * sw.h

 */

#ifndef SOURCE_SW_H_

#define SOURCE_SW_H_

#include "fsl_device_registers.h"

#include "fsl_port.h"

#include "board.h"

#include "pin_mux.h"

void Ini_SW2_IRQ(void);

void Ini_SW3_IRQ(void);

#endif /* SOURCE_SW_H_ */

#include "sw.h"

void Ini_SW2_IRQ(void)

{

    /* Define the init structure for the input switch pin */

    gpio_pin_config_t sw_config = {

        kGPIO_DigitalInput, 0,

    };

    CLOCK_EnableClock(kCLOCK_PortC);

    PORT_SetPinMux(BOARD_SW2_PORT,BOARD_SW2_GPIO_PIN,kPORT_MuxAsGpio);

PORT_SetPinInterruptConfig(BOARD_SW2_PORT, BOARD_SW2_GPIO_PIN, kPORT_InterruptFallingEdge);

EnableIRQ(BOARD_SW2_IRQ);

GPIO_PinInit(BOARD_SW2_GPIO, BOARD_SW2_GPIO_PIN, &sw_config);

}

void Ini_SW3_IRQ(void)

{

    /* Define the init structure for the input switch pin */

    gpio_pin_config_t sw_config = {

        kGPIO_DigitalInput, 0,

    };

    CLOCK_EnableClock(kCLOCK_PortA);

    PORT_SetPinMux(BOARD_SW3_PORT,BOARD_SW3_GPIO_PIN,kPORT_MuxAsGpio);

PORT_SetPinInterruptConfig(BOARD_SW3_PORT, BOARD_SW3_GPIO_PIN, kPORT_InterruptFallingEdge);

EnableIRQ(BOARD_SW3_IRQ);

GPIO_PinInit(BOARD_SW3_GPIO, BOARD_SW3_GPIO_PIN, &sw_config);

}