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

#include <Bridge.h>

#include <YunClient.h>
#include <YunServer.h>

#include <ArduinoJson.h>

#define MODE_AUTO HIGH
#define MODE_MANUAL LOW

#define RELAY_LEVEL_LOW HIGH
#define RELAY_LEVEL_HIGH LOW

#define PIN_RELAY_DOWN_1 2
#define PIN_RELAY_DOWN_2 3

#define PIN_RELAY_UP_1 4
#define PIN_RELAY_UP_2 5

#define PIN_SWITCH_MODE 6

#define PIN_BUTTON_UP 7
#define PIN_BUTTON_DOWN 8

#define PIN_LIMIT_SWITCH_UP 9

#define TIME_SCREEN_DOWN 8000

#define JSON_KEY_RESULT "result"

boolean _AutoDown;

boolean _PressedButtonDown;
boolean _PressedButtonUp;
boolean _PressedRemoteControl;

boolean _RunningRoutine;

int _LevelButtonDown;
int _LevelButtonUp;

int _LevelLimitSwitch;

int _LevelSwitchMode;

unsigned long _StopTime;

YunServer _Server;

void setup() {
  Bridge.begin();

  _Server.listenOnLocalhost();
  _Server.begin();

  digitalWrite(PIN_RELAY_DOWN_1, RELAY_LEVEL_LOW);
  digitalWrite(PIN_RELAY_DOWN_2, RELAY_LEVEL_LOW);
  digitalWrite(PIN_RELAY_UP_1, RELAY_LEVEL_LOW);
  digitalWrite(PIN_RELAY_UP_2, RELAY_LEVEL_LOW);

  pinMode(PIN_RELAY_DOWN_1, OUTPUT);
  pinMode(PIN_RELAY_DOWN_2, OUTPUT);
  pinMode(PIN_RELAY_UP_1, OUTPUT);
  pinMode(PIN_RELAY_UP_2, OUTPUT);

  pinMode(PIN_SWITCH_MODE, INPUT);
  pinMode(PIN_BUTTON_UP, INPUT);
  pinMode(PIN_BUTTON_DOWN, INPUT);
  pinMode(PIN_LIMIT_SWITCH_UP, INPUT);

  check();
}

void loop() {
  YunClient client = _Server.accept();

  if (client) {
    process(client);

    client.stop();
  }

  delay(50);

  if (!_RunningRoutine) {
    const int newLevelSwitchMode = digitalRead(PIN_SWITCH_MODE);

    const int newLevelButtonDown = digitalRead(PIN_BUTTON_DOWN);
    const int newLevelButtonUp = digitalRead(PIN_BUTTON_UP);

    if (_LevelSwitchMode != newLevelSwitchMode ||
        _LevelButtonDown != newLevelButtonDown ||
        _LevelButtonUp != newLevelButtonUp) {
      if (_PressedRemoteControl) {
        _PressedRemoteControl = false;
      }
    }

    if (_PressedRemoteControl) {
      if (digitalRead(PIN_LIMIT_SWITCH_UP) == HIGH &&
          digitalRead(PIN_RELAY_UP_1) == RELAY_LEVEL_HIGH &&
          digitalRead(PIN_RELAY_UP_2) == RELAY_LEVEL_HIGH) {
        verify();
      }
    } else {
      if (_LevelSwitchMode != newLevelSwitchMode) {
        _LevelSwitchMode = newLevelSwitchMode;

        switch (_LevelSwitchMode) {
          case MODE_MANUAL:
            if (_AutoDown) {
              _AutoDown = false;
            }
            break;

          case MODE_AUTO:
            if (_PressedButtonDown) {
              _PressedButtonDown = false;
            }

            if (_PressedButtonUp) {
              _PressedButtonUp = false;
            }
            break;

          default:
            verify();
            break;
        }

        check();
      }

      if (_LevelButtonUp != newLevelButtonUp) {
        _LevelButtonUp = newLevelButtonUp;

        if (newLevelSwitchMode == MODE_MANUAL) {
          switch (_LevelButtonUp) {
            case LOW:
              if (_PressedButtonUp) {
                _PressedButtonUp = false;
              }
              break;

            case HIGH:
              if (!_PressedButtonUp) {
                _PressedButtonUp = true;
              }
              break;

            default:
              verify();
              break;
          }
        }
      }

      if (_LevelButtonDown != newLevelButtonDown) {
        _LevelButtonDown = newLevelButtonDown;

        if (newLevelSwitchMode == MODE_MANUAL) {
          switch (_LevelButtonDown) {
            case LOW:
              if (_PressedButtonDown) {
                _PressedButtonDown = false;
              }
              break;

            case HIGH:
              if (!_PressedButtonDown) {
                _PressedButtonDown = true;
              }
              break;

            default:
              verify();
              break;
          }
        }
      }

      const int newLevelLimitSwitch = digitalRead(PIN_LIMIT_SWITCH_UP);

      if (_LevelLimitSwitch != newLevelLimitSwitch) {
        _LevelLimitSwitch = newLevelLimitSwitch;
      }

      switch (_LevelSwitchMode) {
        case MODE_MANUAL:
          if (_LevelLimitSwitch == LOW && _LevelButtonUp == HIGH &&
              _LevelButtonDown == LOW && !_PressedButtonDown) {
            if (!_PressedButtonUp) {
              _PressedButtonUp = true;
            }

            startUp();
          } else if (_LevelLimitSwitch == HIGH && _LevelButtonUp == HIGH &&
                     _LevelButtonDown == LOW && !_PressedButtonDown) {
            if (!_PressedButtonUp) {
              _PressedButtonUp = true;
            }

            verify();
          } else if (_LevelButtonUp == LOW && _LevelButtonDown == HIGH &&
                     !_PressedButtonUp) {
            if (!_PressedButtonDown) {
              _PressedButtonDown = true;
            }

            startDown();
          } else if (!_PressedButtonDown && !_PressedButtonUp) {
            verify();
          }
          break;

        case MODE_AUTO:
          if (_AutoDown && _LevelLimitSwitch == LOW && _LevelButtonUp == HIGH &&
              _LevelButtonDown == LOW) {
            _AutoDown = false;

            check();
          } else if (!_AutoDown && _LevelLimitSwitch == HIGH &&
                     _LevelButtonUp == LOW && _LevelButtonDown == HIGH) {
            startAutoDown();
          } else {
            verify();
          }
          break;

        default:
          verify();
          break;
      }
    }
  } else if (_RunningRoutine && millis() >= _StopTime) {
    _RunningRoutine = false;

    verify();
  }
}

void process(YunClient client) {
  const String command = client.readStringUntil('/');

  if (command == "control") {
    controlCommand(client);
  }
}

void controlCommand(YunClient client) {
  const int value = client.parseInt();

  if (_RunningRoutine) {
    printClientResult(client, false);
  } else {
    if (!_PressedRemoteControl) {
      _PressedRemoteControl = true;
    }

    switch (value) {
      case 0:
      default:
        check();

        printClientResult(client, true);
        break;

      case 1:
        verify();

        printClientResult(client, true);
        break;

      case 2:
        if (digitalRead(PIN_LIMIT_SWITCH_UP) == LOW) {
          startUp();

          printClientResult(client, true);
        } else {
          printClientResult(client, false);
        }
        break;

      case 3:
        startDown();

        printClientResult(client, true);
        break;

      case 4:
        if (_AutoDown && digitalRead(PIN_LIMIT_SWITCH_UP) == LOW) {
          _AutoDown = false;

          check();

          printClientResult(client, true);
        } else {
          printClientResult(client, false);
        }
        break;

      case 5:
        if (!_AutoDown) {
          startAutoDown();

          printClientResult(client, true);
        } else {
          printClientResult(client, false);
        }
        break;
    }
  }
}

void check() {
  const int levelLimitSwitch = digitalRead(PIN_LIMIT_SWITCH_UP);

  if (levelLimitSwitch == LOW) {
    setDigitalLevel(PIN_RELAY_DOWN_1, RELAY_LEVEL_LOW);
    setDigitalLevel(PIN_RELAY_DOWN_2, RELAY_LEVEL_LOW);
    setDigitalLevel(PIN_RELAY_UP_1, RELAY_LEVEL_HIGH);
    setDigitalLevel(PIN_RELAY_UP_2, RELAY_LEVEL_HIGH);

    while (digitalRead(PIN_LIMIT_SWITCH_UP) == LOW) {
      delay(50);
    }

    setDigitalLevel(PIN_RELAY_UP_1, RELAY_LEVEL_LOW);
    setDigitalLevel(PIN_RELAY_UP_2, RELAY_LEVEL_LOW);
  }
}

void verify() {
  setDigitalLevel(PIN_RELAY_DOWN_1, RELAY_LEVEL_LOW);
  setDigitalLevel(PIN_RELAY_DOWN_2, RELAY_LEVEL_LOW);
  setDigitalLevel(PIN_RELAY_UP_1, RELAY_LEVEL_LOW);
  setDigitalLevel(PIN_RELAY_UP_2, RELAY_LEVEL_LOW);

  if (!_PressedRemoteControl && _LevelButtonUp == HIGH &&
      _LevelButtonDown == HIGH) {
    check();
  }
}

void startAutoDown() {
  _AutoDown = true;

  _RunningRoutine = true;

  _StopTime = millis() + TIME_SCREEN_DOWN;

  startDown();
}

void startDown() {
  setDigitalLevel(PIN_RELAY_DOWN_1, RELAY_LEVEL_HIGH);
  setDigitalLevel(PIN_RELAY_DOWN_2, RELAY_LEVEL_HIGH);
  setDigitalLevel(PIN_RELAY_UP_1, RELAY_LEVEL_LOW);
  setDigitalLevel(PIN_RELAY_UP_2, RELAY_LEVEL_LOW);
}

void startUp() {
  setDigitalLevel(PIN_RELAY_DOWN_1, RELAY_LEVEL_LOW);
  setDigitalLevel(PIN_RELAY_DOWN_2, RELAY_LEVEL_LOW);
  setDigitalLevel(PIN_RELAY_UP_1, RELAY_LEVEL_HIGH);
  setDigitalLevel(PIN_RELAY_UP_2, RELAY_LEVEL_HIGH);
}

void printClientResult(YunClient client, boolean completed) {
  StaticJsonBuffer<200> jsonBuffer;

  JsonObject& root = jsonBuffer.createObject();

  root[JSON_KEY_RESULT] = completed;

  root.prettyPrintTo(client);
}

void setDigitalLevel(const int pin, const int level) {
  if (digitalRead(pin) != level) {
    digitalWrite(pin, level);
  }
}