Automatic curtain opener with a stepper motor on an Arduino Uno

// Automatic curtain opener: a NEMA 17 on an A4988 pulls the curtain along
// its rail on a GT2 belt. It opens at dawn and closes at dusk on its own, a
// button opens, closes or stops it at any time, and a knob sets how fast it
// travels. FastAccelStepper makes the steps from timer 1 in the background,
// with a smooth start and stop, so loop() is free to watch the light and
// the button while the curtain moves.
//
//   A4988   STEP -> 9 (timer 1's OC1A: FastAccelStepper needs 9 or 10 on an Uno)
//           DIR  -> 8    EN -> 7 (low = driving)    RST -> SLP
//           MS2 -> 5 V, MS1 and MS3 -> GND: quarter steps
//           VMOT -> 12 V with 100 uF across it, VDD -> 5 V, both grounds to GND
//   end switch (curtain closed)  NO -> 2, COM -> GND
//   button (open / close / stop) -> 3 and GND
//   LDR from 5 V to A0, 10 kohm from A0 to GND: brighter reads higher
//   10 kohm knob: ends on 5 V and GND, wiper -> A1 (travel speed)
//
// The numbers: a 200-step motor in quarter steps is 800 steps a turn, and a
// 20-tooth GT2 pulley moves the belt 20 x 2 mm = 40 mm a turn, so 20 steps a
// millimeter. The curtain travels TRAVEL_MM from closed (the switch) to open.
// Set the A4988's current limit for your motor before it pulls a load.
//
// Things to try. Drag the light on the LDR up to daylight and the curtain
// opens; drag it down to dusk and it closes. Press the button while it
// moves to stop it. Turn the knob to change the speed of the next move.

#include <FastAccelStepper.h>

const int STEP_PIN = 9;
const int DIR_PIN = 8;
const int ENABLE_PIN = 7;
const int HOME_PIN = 2;    // end switch, pressed when the curtain is closed
const int BUTTON_PIN = 3;
const int LIGHT_PIN = A0;
const int SPEED_PIN = A1;

const long STEPS_PER_MM = 20;     // 800 steps a turn / 40 mm a turn
const long TRAVEL_MM = 1000;      // closed to open
const long ACCEL_MM = 200;        // mm/s/s: half a second to full speed
const int SPEED_MIN_MM = 25;      // mm/s, knob fully anticlockwise
const int SPEED_MAX_MM = 150;     // mm/s, knob fully clockwise
const int HOMING_MM = 40;         // mm/s while it looks for the switch

// The light, as A0 reads it. Above DAY it is morning (about 70 lux on the
// LDR), below NIGHT it is evening (about 5 lux). The gap between the two
// keeps a cloud from opening and closing it over and over.
const int DAY = 700;
const int NIGHT = 300;
const int LIGHT_CHECKS = 5;       // readings in a row, half a second apart

FastAccelStepperEngine engine = FastAccelStepperEngine();
FastAccelStepper *stepper = NULL;

bool daytime = false;
int lightCount = 0;
unsigned long lastLight = 0;
unsigned long lastReport = 0;
bool lastButton = HIGH;
unsigned long buttonChanged = 0;
bool wasMoving = false;

long mm(long steps) { return steps / STEPS_PER_MM; }

int speedMm() {
  return map(analogRead(SPEED_PIN), 0, 1023, SPEED_MIN_MM, SPEED_MAX_MM);
}

void moveTo(long targetMm, const char *why) {
  int speed = speedMm();
  stepper->setSpeedInHz(speed * STEPS_PER_MM);
  stepper->moveTo(targetMm * STEPS_PER_MM);
  Serial.print(why);
  Serial.print(": to ");
  Serial.print(targetMm);
  Serial.print(" mm at ");
  Serial.print(speed);
  Serial.println(" mm/s");
}

void home() {
  if (digitalRead(HOME_PIN) == HIGH) {
    Serial.println("homing: closing until the end switch");
    stepper->setSpeedInHz(HOMING_MM * STEPS_PER_MM);
    stepper->runBackward();
    while (digitalRead(HOME_PIN) == HIGH) {
    }
  }
  stepper->forceStopAndNewPosition(0);
  Serial.println("homed: closed at 0 mm");
}

void setup() {
  Serial.begin(9600);
  pinMode(HOME_PIN, INPUT_PULLUP);
  pinMode(BUTTON_PIN, INPUT_PULLUP);

  engine.init();
  stepper = engine.stepperConnectToPin(STEP_PIN);
  if (!stepper) {
    Serial.println("STEP must be on pin 9 or 10");
    while (true) {
    }
  }
  stepper->setDirectionPin(DIR_PIN);     // DIR high opens
  stepper->setEnablePin(ENABLE_PIN);     // low enables the A4988
  stepper->setAutoEnable(true);          // the motor rests unpowered
  stepper->setAcceleration(ACCEL_MM * STEPS_PER_MM);

  home();
  Serial.println("curtain opener ready");
}

void loop() {
  long pos = stepper->getCurrentPosition();
  bool moving = stepper->isRunning();

  // Closing past the switch means the curtain slipped on the belt: stop
  // there and call it closed.
  if (moving && digitalRead(HOME_PIN) == LOW && stepper->targetPos() < pos) {
    stepper->forceStopAndNewPosition(0);
    Serial.println("end switch: closed at 0 mm");
    moving = false;
    pos = 0;
  }

  // The button: open when closed or part open, close when open, stop
  // while moving.
  bool button = digitalRead(BUTTON_PIN);
  if (button != lastButton && millis() - buttonChanged > 30) {
    buttonChanged = millis();
    lastButton = button;
    if (button == LOW) {
      if (moving) {
        stepper->stopMove();
        Serial.println("button: stop");
      } else if (mm(pos) >= TRAVEL_MM) {
        moveTo(0, "button: close");
      } else {
        moveTo(TRAVEL_MM, "button: open");
      }
    }
  }

  // The light, twice a second. Only a change from night to day or day to
  // night moves the curtain, so a button press holds until the next one.
  if (millis() - lastLight >= 500) {
    lastLight = millis();
    int light = analogRead(LIGHT_PIN);
    bool changed = daytime ? light < NIGHT : light > DAY;
    lightCount = changed ? lightCount + 1 : 0;
    if (lightCount >= LIGHT_CHECKS) {
      lightCount = 0;
      daytime = !daytime;
      if (daytime) {
        moveTo(TRAVEL_MM, "dawn: open");
      } else {
        moveTo(0, "dusk: close");
      }
    }
  }

  if (moving && millis() - lastReport >= 200) {
    lastReport = millis();
    Serial.print("at ");
    Serial.print(mm(pos));
    Serial.println(" mm");
  }
  if (wasMoving && !moving) {
    Serial.print("stopped at ");
    Serial.print(mm(pos));
    Serial.println(" mm");
  }
  wasMoving = moving;
}