kevin2458

Control - Arduino - v1 (UTH/Circuitos Integrados/2016-1)

Apr 22nd, 2016
175
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <Bridge.h>
  2.  
  3. #include <YunClient.h>
  4. #include <YunServer.h>
  5.  
  6. #include <ArduinoJson.h>
  7.  
  8. #define MODE_AUTO HIGH
  9. #define MODE_MANUAL LOW
  10.  
  11. #define RELAY_LEVEL_LOW HIGH
  12. #define RELAY_LEVEL_HIGH LOW
  13.  
  14. #define PIN_RELAY_DOWN_1 2
  15. #define PIN_RELAY_DOWN_2 3
  16.  
  17. #define PIN_RELAY_UP_1 4
  18. #define PIN_RELAY_UP_2 5
  19.  
  20. #define PIN_SWITCH_MODE 6
  21.  
  22. #define PIN_BUTTON_UP 7
  23. #define PIN_BUTTON_DOWN 8
  24.  
  25. #define PIN_LIMIT_SWITCH_UP 9
  26.  
  27. #define TIME_SCREEN_DOWN 8000
  28.  
  29. #define JSON_KEY_RESULT "result"
  30.  
  31. boolean _AutoDown;
  32.  
  33. boolean _PressedButtonDown;
  34. boolean _PressedButtonUp;
  35. boolean _PressedRemoteControl;
  36.  
  37. boolean _RunningRoutine;
  38.  
  39. int _LevelButtonDown;
  40. int _LevelButtonUp;
  41.  
  42. int _LevelLimitSwitch;
  43.  
  44. int _LevelSwitchMode;
  45.  
  46. unsigned long _StopTime;
  47.  
  48. YunServer _Server;
  49.  
  50. void setup() {
  51.   Bridge.begin();
  52.  
  53.   _Server.listenOnLocalhost();
  54.   _Server.begin();
  55.  
  56.   digitalWrite(PIN_RELAY_DOWN_1, RELAY_LEVEL_LOW);
  57.   digitalWrite(PIN_RELAY_DOWN_2, RELAY_LEVEL_LOW);
  58.   digitalWrite(PIN_RELAY_UP_1, RELAY_LEVEL_LOW);
  59.   digitalWrite(PIN_RELAY_UP_2, RELAY_LEVEL_LOW);
  60.  
  61.   pinMode(PIN_RELAY_DOWN_1, OUTPUT);
  62.   pinMode(PIN_RELAY_DOWN_2, OUTPUT);
  63.   pinMode(PIN_RELAY_UP_1, OUTPUT);
  64.   pinMode(PIN_RELAY_UP_2, OUTPUT);
  65.  
  66.   pinMode(PIN_SWITCH_MODE, INPUT);
  67.   pinMode(PIN_BUTTON_UP, INPUT);
  68.   pinMode(PIN_BUTTON_DOWN, INPUT);
  69.   pinMode(PIN_LIMIT_SWITCH_UP, INPUT);
  70.  
  71.   check();
  72. }
  73.  
  74. void loop() {
  75.   YunClient client = _Server.accept();
  76.  
  77.   if (client) {
  78.     process(client);
  79.  
  80.     client.stop();
  81.   }
  82.  
  83.   delay(50);
  84.  
  85.   if (!_RunningRoutine) {
  86.     const int newLevelSwitchMode = digitalRead(PIN_SWITCH_MODE);
  87.  
  88.     const int newLevelButtonDown = digitalRead(PIN_BUTTON_DOWN);
  89.     const int newLevelButtonUp = digitalRead(PIN_BUTTON_UP);
  90.  
  91.     if (_LevelSwitchMode != newLevelSwitchMode ||
  92.         _LevelButtonDown != newLevelButtonDown ||
  93.         _LevelButtonUp != newLevelButtonUp) {
  94.       if (_PressedRemoteControl) {
  95.         _PressedRemoteControl = false;
  96.       }
  97.     }
  98.  
  99.     if (_PressedRemoteControl) {
  100.       if (digitalRead(PIN_LIMIT_SWITCH_UP) == HIGH &&
  101.           digitalRead(PIN_RELAY_UP_1) == RELAY_LEVEL_HIGH &&
  102.           digitalRead(PIN_RELAY_UP_2) == RELAY_LEVEL_HIGH) {
  103.         verify();
  104.       }
  105.     } else {
  106.       if (_LevelSwitchMode != newLevelSwitchMode) {
  107.         _LevelSwitchMode = newLevelSwitchMode;
  108.  
  109.         switch (_LevelSwitchMode) {
  110.           case MODE_MANUAL:
  111.             if (_AutoDown) {
  112.               _AutoDown = false;
  113.             }
  114.             break;
  115.  
  116.           case MODE_AUTO:
  117.             if (_PressedButtonDown) {
  118.               _PressedButtonDown = false;
  119.             }
  120.  
  121.             if (_PressedButtonUp) {
  122.               _PressedButtonUp = false;
  123.             }
  124.             break;
  125.  
  126.           default:
  127.             verify();
  128.             break;
  129.         }
  130.  
  131.         check();
  132.       }
  133.  
  134.       if (_LevelButtonUp != newLevelButtonUp) {
  135.         _LevelButtonUp = newLevelButtonUp;
  136.  
  137.         if (newLevelSwitchMode == MODE_MANUAL) {
  138.           switch (_LevelButtonUp) {
  139.             case LOW:
  140.               if (_PressedButtonUp) {
  141.                 _PressedButtonUp = false;
  142.               }
  143.               break;
  144.  
  145.             case HIGH:
  146.               if (!_PressedButtonUp) {
  147.                 _PressedButtonUp = true;
  148.               }
  149.               break;
  150.  
  151.             default:
  152.               verify();
  153.               break;
  154.           }
  155.         }
  156.       }
  157.  
  158.       if (_LevelButtonDown != newLevelButtonDown) {
  159.         _LevelButtonDown = newLevelButtonDown;
  160.  
  161.         if (newLevelSwitchMode == MODE_MANUAL) {
  162.           switch (_LevelButtonDown) {
  163.             case LOW:
  164.               if (_PressedButtonDown) {
  165.                 _PressedButtonDown = false;
  166.               }
  167.               break;
  168.  
  169.             case HIGH:
  170.               if (!_PressedButtonDown) {
  171.                 _PressedButtonDown = true;
  172.               }
  173.               break;
  174.  
  175.             default:
  176.               verify();
  177.               break;
  178.           }
  179.         }
  180.       }
  181.  
  182.       const int newLevelLimitSwitch = digitalRead(PIN_LIMIT_SWITCH_UP);
  183.  
  184.       if (_LevelLimitSwitch != newLevelLimitSwitch) {
  185.         _LevelLimitSwitch = newLevelLimitSwitch;
  186.       }
  187.  
  188.       switch (_LevelSwitchMode) {
  189.         case MODE_MANUAL:
  190.           if (_LevelLimitSwitch == LOW && _LevelButtonUp == HIGH &&
  191.               _LevelButtonDown == LOW && !_PressedButtonDown) {
  192.             if (!_PressedButtonUp) {
  193.               _PressedButtonUp = true;
  194.             }
  195.  
  196.             startUp();
  197.           } else if (_LevelLimitSwitch == HIGH && _LevelButtonUp == HIGH &&
  198.                      _LevelButtonDown == LOW && !_PressedButtonDown) {
  199.             if (!_PressedButtonUp) {
  200.               _PressedButtonUp = true;
  201.             }
  202.  
  203.             verify();
  204.           } else if (_LevelButtonUp == LOW && _LevelButtonDown == HIGH &&
  205.                      !_PressedButtonUp) {
  206.             if (!_PressedButtonDown) {
  207.               _PressedButtonDown = true;
  208.             }
  209.  
  210.             startDown();
  211.           } else if (!_PressedButtonDown && !_PressedButtonUp) {
  212.             verify();
  213.           }
  214.           break;
  215.  
  216.         case MODE_AUTO:
  217.           if (_AutoDown && _LevelLimitSwitch == LOW && _LevelButtonUp == HIGH &&
  218.               _LevelButtonDown == LOW) {
  219.             _AutoDown = false;
  220.  
  221.             check();
  222.           } else if (!_AutoDown && _LevelLimitSwitch == HIGH &&
  223.                      _LevelButtonUp == LOW && _LevelButtonDown == HIGH) {
  224.             startAutoDown();
  225.           } else {
  226.             verify();
  227.           }
  228.           break;
  229.  
  230.         default:
  231.           verify();
  232.           break;
  233.       }
  234.     }
  235.   } else if (_RunningRoutine && millis() >= _StopTime) {
  236.     _RunningRoutine = false;
  237.  
  238.     verify();
  239.   }
  240. }
  241.  
  242. void process(YunClient client) {
  243.   const String command = client.readStringUntil('/');
  244.  
  245.   if (command == "control") {
  246.     controlCommand(client);
  247.   }
  248. }
  249.  
  250. void controlCommand(YunClient client) {
  251.   const int value = client.parseInt();
  252.  
  253.   if (_RunningRoutine) {
  254.     printClientResult(client, false);
  255.   } else {
  256.     if (!_PressedRemoteControl) {
  257.       _PressedRemoteControl = true;
  258.     }
  259.  
  260.     switch (value) {
  261.       case 0:
  262.       default:
  263.         check();
  264.  
  265.         printClientResult(client, true);
  266.         break;
  267.  
  268.       case 1:
  269.         verify();
  270.  
  271.         printClientResult(client, true);
  272.         break;
  273.  
  274.       case 2:
  275.         if (digitalRead(PIN_LIMIT_SWITCH_UP) == LOW) {
  276.           startUp();
  277.  
  278.           printClientResult(client, true);
  279.         } else {
  280.           printClientResult(client, false);
  281.         }
  282.         break;
  283.  
  284.       case 3:
  285.         startDown();
  286.  
  287.         printClientResult(client, true);
  288.         break;
  289.  
  290.       case 4:
  291.         if (_AutoDown && digitalRead(PIN_LIMIT_SWITCH_UP) == LOW) {
  292.           _AutoDown = false;
  293.  
  294.           check();
  295.  
  296.           printClientResult(client, true);
  297.         } else {
  298.           printClientResult(client, false);
  299.         }
  300.         break;
  301.  
  302.       case 5:
  303.         if (!_AutoDown) {
  304.           startAutoDown();
  305.  
  306.           printClientResult(client, true);
  307.         } else {
  308.           printClientResult(client, false);
  309.         }
  310.         break;
  311.     }
  312.   }
  313. }
  314.  
  315. void check() {
  316.   const int levelLimitSwitch = digitalRead(PIN_LIMIT_SWITCH_UP);
  317.  
  318.   if (levelLimitSwitch == LOW) {
  319.     setDigitalLevel(PIN_RELAY_DOWN_1, RELAY_LEVEL_LOW);
  320.     setDigitalLevel(PIN_RELAY_DOWN_2, RELAY_LEVEL_LOW);
  321.     setDigitalLevel(PIN_RELAY_UP_1, RELAY_LEVEL_HIGH);
  322.     setDigitalLevel(PIN_RELAY_UP_2, RELAY_LEVEL_HIGH);
  323.  
  324.     while (digitalRead(PIN_LIMIT_SWITCH_UP) == LOW) {
  325.       delay(50);
  326.     }
  327.  
  328.     setDigitalLevel(PIN_RELAY_UP_1, RELAY_LEVEL_LOW);
  329.     setDigitalLevel(PIN_RELAY_UP_2, RELAY_LEVEL_LOW);
  330.   }
  331. }
  332.  
  333. void verify() {
  334.   setDigitalLevel(PIN_RELAY_DOWN_1, RELAY_LEVEL_LOW);
  335.   setDigitalLevel(PIN_RELAY_DOWN_2, RELAY_LEVEL_LOW);
  336.   setDigitalLevel(PIN_RELAY_UP_1, RELAY_LEVEL_LOW);
  337.   setDigitalLevel(PIN_RELAY_UP_2, RELAY_LEVEL_LOW);
  338.  
  339.   if (!_PressedRemoteControl && _LevelButtonUp == HIGH &&
  340.       _LevelButtonDown == HIGH) {
  341.     check();
  342.   }
  343. }
  344.  
  345. void startAutoDown() {
  346.   _AutoDown = true;
  347.  
  348.   _RunningRoutine = true;
  349.  
  350.   _StopTime = millis() + TIME_SCREEN_DOWN;
  351.  
  352.   startDown();
  353. }
  354.  
  355. void startDown() {
  356.   setDigitalLevel(PIN_RELAY_DOWN_1, RELAY_LEVEL_HIGH);
  357.   setDigitalLevel(PIN_RELAY_DOWN_2, RELAY_LEVEL_HIGH);
  358.   setDigitalLevel(PIN_RELAY_UP_1, RELAY_LEVEL_LOW);
  359.   setDigitalLevel(PIN_RELAY_UP_2, RELAY_LEVEL_LOW);
  360. }
  361.  
  362. void startUp() {
  363.   setDigitalLevel(PIN_RELAY_DOWN_1, RELAY_LEVEL_LOW);
  364.   setDigitalLevel(PIN_RELAY_DOWN_2, RELAY_LEVEL_LOW);
  365.   setDigitalLevel(PIN_RELAY_UP_1, RELAY_LEVEL_HIGH);
  366.   setDigitalLevel(PIN_RELAY_UP_2, RELAY_LEVEL_HIGH);
  367. }
  368.  
  369. void printClientResult(YunClient client, boolean completed) {
  370.   StaticJsonBuffer<200> jsonBuffer;
  371.  
  372.   JsonObject& root = jsonBuffer.createObject();
  373.  
  374.   root[JSON_KEY_RESULT] = completed;
  375.  
  376.   root.prettyPrintTo(client);
  377. }
  378.  
  379. void setDigitalLevel(const int pin, const int level) {
  380.   if (digitalRead(pin) != level) {
  381.     digitalWrite(pin, level);
  382.   }
  383. }
RAW Paste Data