// ================================
// Motorsteuerung mit
// Poti + Taster + Serieller Steuerung
// PWM: Pin 5
// Richtung: Pin 4
// Poti: A1
// Richtungstaster: Pin 6
// Ein/Aus: Pin 7
// Geschwindigkeit + : Pin 8
// Geschwindigkeit - : Pin 9
// ================================

const int pwmPin = 5;
const int dirPin = 4;
const int potiPin = A1;

const int richtungsTaster = 6;
const int einAusTaster = 7;
const int plusTaster = 8;
const int minusTaster = 9;

bool motorEin = false;
bool richtung = true;      // true = Vorwärts

bool altRichtung = HIGH;
bool altEinAus = HIGH;

bool potiModus = true;

int pwm = 0;
int letzterPoti = 0;
int letzterPWM = -1;

void statusAusgeben()
{
  Serial.print("Motor: ");
  Serial.print(motorEin ? "EIN" : "AUS");

  Serial.print("   Richtung: ");
  Serial.print(richtung ? "Vorwaerts" : "Rueckwaerts");

  Serial.print("   PWM(Byte): ");
  Serial.print(pwm);

  Serial.print("   Prozent: ");
  Serial.print((pwm * 100) / 255);
  Serial.println("%");
}

void setup()
{
  pinMode(pwmPin, OUTPUT);
  pinMode(dirPin, OUTPUT);

  pinMode(richtungsTaster, INPUT_PULLUP);
  pinMode(einAusTaster, INPUT_PULLUP);
  pinMode(plusTaster, INPUT_PULLUP);
  pinMode(minusTaster, INPUT_PULLUP);

  digitalWrite(dirPin, HIGH);

  Serial.begin(115200);
  Serial.println();
  Serial.println("Motorsteuerung gestartet");
  Serial.println("Befehle:");
  Serial.println("E = EIN");
  Serial.println("A = AUS");
  Serial.println("V = Vorwaerts");
  Serial.println("R = Rueckwaerts");
  Serial.println("+ = Schneller");
  Serial.println("- = Langsamer");
  Serial.println();

  letzterPoti = analogRead(potiPin);
  pwm = map(letzterPoti, 0, 1023, 0, 255);

  statusAusgeben();
}

void loop()
{
  // -------------------------
  // Serielle Befehle
  // -------------------------
  if (Serial.available())
  {
    char cmd = toupper(Serial.read());

    switch (cmd)
    {
      case 'E':
        motorEin = true;
        statusAusgeben();
        break;

      case 'A':
        motorEin = false;
        statusAusgeben();
        break;

      case 'V':
        richtung = true;
        digitalWrite(dirPin, richtung);
        statusAusgeben();
        break;

      case 'R':
        richtung = false;
        digitalWrite(dirPin, richtung);
        statusAusgeben();
        break;

      case '+':
        potiModus = false;
        pwm += 5;
        if (pwm > 255) pwm = 255;
        statusAusgeben();
        break;

      case '-':
        potiModus = false;
        pwm -= 5;
        if (pwm < 0) pwm = 0;
        statusAusgeben();
        break;
    }
  }

  // -------------------------
  // Ein/Aus-Taster
  // -------------------------
  bool neuEinAus = digitalRead(einAusTaster);

  if (altEinAus == HIGH && neuEinAus == LOW)
  {
    motorEin = !motorEin;
    delay(50);
    statusAusgeben();
  }

  altEinAus = neuEinAus;

  // -------------------------
  // Richtungs-Taster
  // -------------------------
  bool neuRichtung = digitalRead(richtungsTaster);

  if (altRichtung == HIGH && neuRichtung == LOW)
  {
    richtung = !richtung;
    digitalWrite(dirPin, richtung);
    delay(50);
    statusAusgeben();
  }

  altRichtung = neuRichtung;

  // -------------------------
  // Poti überwachen
  // -------------------------
  int poti = analogRead(potiPin);

  if (abs(poti - letzterPoti) > 8)
  {
    potiModus = true;
    letzterPoti = poti;

    pwm = map(poti, 0, 1023, 0, 255);
    pwm = constrain(pwm, 0, 255);
  }

  // -------------------------
  // Plus-Taster
  // -------------------------
  if (digitalRead(plusTaster) == LOW)
  {
    potiModus = false;
    pwm += 5;
    if (pwm > 255) pwm = 255;
    delay(50);
  }

  // -------------------------
  // Minus-Taster
  // -------------------------
  if (digitalRead(minusTaster) == LOW)
  {
    potiModus = false;
    pwm -= 5;
    if (pwm < 0) pwm = 0;
    delay(50);
  }

  // PWM nur bei Änderung ausgeben
  if (pwm != letzterPWM)
  {
    letzterPWM = pwm;
    statusAusgeben();
  }

  // -------------------------
  // PWM ausgeben
  // -------------------------
  if (motorEin)
    analogWrite(pwmPin, pwm);
  else
    analogWrite(pwmPin, 0);
}