kevin2458

Kevin Lara - 201110510072 - Microcontroladores - 11/06/2016

Jun 11th, 2016
181
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // Kevin Lara - 201110510072 - Microcontroladores - 11/06/2016
  2.  
  3. #define BUTTON_1_2_PRESSED 0
  4. #define BUTTON_1_PRESSED 4
  5. #define BUTTON_2_PRESSED 8
  6.  
  7. #define LED_1 LATA.F0
  8. #define LED_2 LATA.F1
  9.  
  10. #define EVERLOOP while (1)
  11.  
  12. #define FALSE 0
  13. #define TRUE 1
  14.  
  15. #define STATE_LOW 0
  16. #define STATE_HIGH 1
  17.  
  18. #define MILLIS_UPDATE 5
  19. #define MILLIS_DEFAULT 500
  20. #define MILLIS_DEFAULT_BUTTON_A_B_PRESSED 2000
  21. #define MILLIS_EXIT_EXERCISE 2000
  22.  
  23. #define DELAY_EVERLOOP delay_ms(MILLIS_UPDATE)
  24. #define DELAY_EVERLOOP_EXIT delay_ms(100)
  25. #define DELAY_DEFAULT delay_ms(MILLIS_DEFAULT)
  26.  
  27. unsigned int _MillisButtonPressed;
  28.  
  29. void initMCU() {
  30.   ANCON0 = ANCON1 = 0;
  31.  
  32.   TRISA = 0;
  33.  
  34.   TRISD = 12;
  35.  
  36.   LATA = LATD = 0;
  37.  
  38.   PORTA = PORTD = 0;
  39.  
  40.   _MillisButtonPressed = 0;
  41. }
  42.  
  43. void exer_sel(const int exer) {
  44.   const int millis = 50;
  45.  
  46.   int i = 0;
  47.  
  48.   switch (exer) {
  49.     case 0:
  50.       for (i = 1; i <= 2; i++) {
  51.         LED_1 = LED_2 = STATE_HIGH;
  52.  
  53.         delay_ms(millis);
  54.  
  55.         LED_1 = LED_2 = STATE_LOW;
  56.  
  57.         delay_ms(millis);
  58.       }
  59.       break;
  60.  
  61.     case 1:
  62.       for (i = 1; i <= 2; i++) {
  63.         LED_1 = STATE_HIGH;
  64.  
  65.         delay_ms(millis);
  66.  
  67.         LED_1 = STATE_LOW;
  68.  
  69.         delay_ms(millis);
  70.       }
  71.       break;
  72.  
  73.     case 2:
  74.       for (i = 1; i <= 2; i++) {
  75.         LED_2 = STATE_HIGH;
  76.  
  77.         delay_ms(millis);
  78.  
  79.         LED_2 = STATE_LOW;
  80.  
  81.         delay_ms(millis);
  82.       }
  83.       break;
  84.  
  85.     default:
  86.       break;
  87.   }
  88. }
  89.  
  90. int exer_delay(const int buttonPressed,
  91.                const int millisDelay,
  92.                const int millisMax) {
  93.   int millisCount = MILLIS_UPDATE;
  94.  
  95.   do {
  96.     DELAY_EVERLOOP;
  97.  
  98.     millisCount += MILLIS_UPDATE;
  99.  
  100.     if (PORTD == buttonPressed) {
  101.       _MillisButtonPressed += MILLIS_UPDATE;
  102.  
  103.       if (_MillisButtonPressed >= millisMax) {
  104.         _MillisButtonPressed = 0;
  105.  
  106.         return TRUE;
  107.       }
  108.     } else {
  109.       _MillisButtonPressed = 0;
  110.     }
  111.   } while (millisCount < millisDelay);
  112.  
  113.   return FALSE;
  114. }
  115.  
  116. int exer_interrump(const int buttonPressed, const int millisMax) {
  117.   if (_MillisButtonPressed != 0) {
  118.     _MillisButtonPressed = 0;
  119.   }
  120.  
  121.   while (PORTD == buttonPressed) {
  122.     DELAY_EVERLOOP;
  123.  
  124.     _MillisButtonPressed += MILLIS_UPDATE;
  125.  
  126.     if (_MillisButtonPressed >= millisMax) {
  127.       _MillisButtonPressed = 0;
  128.  
  129.       return TRUE;
  130.     }
  131.   }
  132.  
  133.   _MillisButtonPressed = 0;
  134.  
  135.   return FALSE;
  136. }
  137.  
  138. void exer_1() {
  139.   int stateLed1 = STATE_LOW;
  140.   int stateLed2 = STATE_LOW;
  141.  
  142.   exer_sel(1);
  143.  
  144.   while (PORTD == BUTTON_1_PRESSED) {
  145.     DELAY_EVERLOOP;
  146.   }
  147.  
  148.   EVERLOOP {
  149.     switch (PORTD) {
  150.       case BUTTON_1_2_PRESSED:
  151.         EVERLOOP {
  152.           LED_1 = LED_2 = STATE_HIGH;
  153.  
  154.           if (exer_delay(BUTTON_1_2_PRESSED, MILLIS_DEFAULT,
  155.                          MILLIS_DEFAULT_BUTTON_A_B_PRESSED)) {
  156.             LED_1 = LED_2 = STATE_LOW;
  157.  
  158.             break;
  159.           }
  160.  
  161.           LED_1 = LED_2 = STATE_LOW;
  162.  
  163.           if (exer_delay(BUTTON_1_2_PRESSED, MILLIS_DEFAULT,
  164.                          MILLIS_DEFAULT_BUTTON_A_B_PRESSED)) {
  165.             break;
  166.           }
  167.         }
  168.  
  169.         while (PORTD == BUTTON_1_2_PRESSED) {
  170.           DELAY_EVERLOOP;
  171.         }
  172.  
  173.         DELAY_EVERLOOP_EXIT;
  174.         break;
  175.  
  176.       case BUTTON_1_PRESSED:
  177.         if (stateLed1 == STATE_LOW && LED_1 == STATE_LOW) {
  178.           LED_1 = STATE_HIGH;
  179.         } else if (stateLed1 == STATE_HIGH && LED_1 == STATE_HIGH) {
  180.           LED_1 = STATE_LOW;
  181.         }
  182.         break;
  183.  
  184.       case BUTTON_2_PRESSED:
  185.         if (stateLed2 == STATE_LOW && LED_2 == STATE_LOW) {
  186.           LED_2 = STATE_HIGH;
  187.         } else if (stateLed2 == STATE_HIGH && LED_2 == STATE_HIGH) {
  188.           LED_2 = STATE_LOW;
  189.         }
  190.         break;
  191.  
  192.       default:
  193.         if (stateLed1 == STATE_LOW && LED_1 == STATE_HIGH) {
  194.           stateLed1 = STATE_HIGH;
  195.         } else if (stateLed1 == STATE_HIGH && LED_1 == STATE_LOW) {
  196.           stateLed1 = STATE_LOW;
  197.         }
  198.  
  199.         if (stateLed2 == STATE_LOW && LED_2 == STATE_HIGH) {
  200.           stateLed2 = STATE_HIGH;
  201.         } else if (stateLed2 == STATE_HIGH && LED_2 == STATE_LOW) {
  202.           stateLed2 = STATE_LOW;
  203.         }
  204.         break;
  205.     }
  206.  
  207.     if (exer_interrump(BUTTON_1_PRESSED, MILLIS_EXIT_EXERCISE)) {
  208.       break;
  209.     }
  210.  
  211.     DELAY_EVERLOOP;
  212.   }
  213.  
  214.   exer_sel(1);
  215.  
  216.   while (PORTD == BUTTON_1_PRESSED) {
  217.     DELAY_EVERLOOP;
  218.   }
  219.  
  220.   DELAY_EVERLOOP_EXIT;
  221. }
  222.  
  223. void exer_2() {
  224.   int buttonAPressedCount = 0;
  225.  
  226.   exer_sel(2);
  227.  
  228.   while (PORTD == BUTTON_2_PRESSED) {
  229.     DELAY_EVERLOOP;
  230.   }
  231.  
  232.   EVERLOOP {
  233.     switch (PORTD) {
  234.       case BUTTON_1_2_PRESSED:
  235.         if (exer_interrump(BUTTON_1_2_PRESSED,
  236.                            MILLIS_DEFAULT_BUTTON_A_B_PRESSED)) {
  237.           EVERLOOP {
  238.             LED_1 = STATE_HIGH;
  239.             LED_2 = STATE_LOW;
  240.  
  241.             if (exer_delay(BUTTON_1_2_PRESSED, MILLIS_DEFAULT,
  242.                            MILLIS_DEFAULT_BUTTON_A_B_PRESSED)) {
  243.               LED_1 = STATE_LOW;
  244.  
  245.               break;
  246.             }
  247.  
  248.             LED_1 = STATE_LOW;
  249.             LED_2 = STATE_HIGH;
  250.  
  251.             if (exer_delay(BUTTON_1_2_PRESSED, MILLIS_DEFAULT,
  252.                            MILLIS_DEFAULT_BUTTON_A_B_PRESSED)) {
  253.               LED_2 = STATE_LOW;
  254.  
  255.               break;
  256.             }
  257.           }
  258.  
  259.           while (PORTD == BUTTON_1_2_PRESSED) {
  260.             DELAY_EVERLOOP;
  261.           }
  262.         }
  263.         break;
  264.  
  265.       case BUTTON_1_PRESSED:
  266.         if (LED_1 == STATE_LOW) {
  267.           LED_1 = STATE_HIGH;
  268.  
  269.           buttonAPressedCount++;
  270.         }
  271.         break;
  272.  
  273.       case BUTTON_2_PRESSED: {
  274.         int i = 0;
  275.  
  276.         if (buttonAPressedCount > 20) {
  277.           buttonAPressedCount = 20;
  278.         }
  279.  
  280.         for (i = 1; i <= buttonAPressedCount; i++) {
  281.           LED_1 = LED_2 = 1;
  282.  
  283.           DELAY_DEFAULT;
  284.  
  285.           LED_1 = LED_2 = 0;
  286.  
  287.           DELAY_DEFAULT;
  288.         }
  289.  
  290.         buttonAPressedCount = 0;
  291.         break;
  292.       }
  293.  
  294.       default:
  295.         if (LED_1 == STATE_HIGH) {
  296.           LED_1 = STATE_LOW;
  297.         }
  298.         break;
  299.     }
  300.  
  301.     if (exer_interrump(BUTTON_2_PRESSED, MILLIS_EXIT_EXERCISE)) {
  302.       break;
  303.     }
  304.  
  305.     DELAY_EVERLOOP_EXIT;
  306.   }
  307.  
  308.   exer_sel(2);
  309.  
  310.   while (PORTD == BUTTON_2_PRESSED) {
  311.     DELAY_EVERLOOP;
  312.   }
  313.  
  314.   DELAY_EVERLOOP_EXIT;
  315. }
  316.  
  317. void main() {
  318.   initMCU();
  319.  
  320.   exer_sel(0);
  321.  
  322.   EVERLOOP {
  323.     switch (PORTD) {
  324.       case BUTTON_1_PRESSED:
  325.         exer_1();
  326.         break;
  327.  
  328.       case BUTTON_2_PRESSED:
  329.         exer_2();
  330.         break;
  331.  
  332.       default:
  333.         break;
  334.     }
  335.  
  336.     DELAY_EVERLOOP;
  337.   }
  338. }
RAW Paste Data