A linear actuator to open a lid

A linear actuator turns the rotation of a small motor into a push in a straight line: the rod extends, stops, retracts. With one of these you can open the lid of a box, a hatch, an air vent. Here we use the 6 V DFRobot actuators, which come with four different strokes, and we control them from an Arduino UNO with two buttons, OPEN and CLOSE. The most interesting part is the one you can't see: how to stop at the end without knowing how much current the motor draws, because DFRobot doesn't publish it.

// Linear actuator test: the rod extends, stops, retracts. Every 100 ms the
// Serial Monitor shows the current read on the AS pin of the DRV8833 driver.
#include <Arduino.h>

const byte AIN1 = 8;          // the two inputs of bridge A
const byte AIN2 = 9;
const byte SLP = 10;          // HIGH = driver awake, LOW = driver asleep
const byte SENSE = A0;        // AS pin: 0.2 V for every amp through the motor

const unsigned int STROKE_MM = 50;  // the stroke of your actuator: 10, 30, 50 or 100
// time for one stroke: stroke divided by 7 mm/s (DFRobot figure), plus a 30 % margin
const unsigned long TIME_MS = STROKE_MM * 1300UL / 7;

int currentMA() {
  long sum = 0;
  for (byte i = 0; i < 20; i++) sum += analogRead(SENSE);
  float mV = sum / 20.0 * 1100.0 / 1024.0;    // average in millivolts, 1.1 V scale
  return (int)(mV * 5);                       // 1 mV across 0.2 ohm = 5 mA
}

void drive(int dir) {         // 1 = out, -1 = in, 0 = stop
  digitalWrite(AIN1, dir > 0 ? HIGH : LOW);
  digitalWrite(AIN2, dir < 0 ? HIGH : LOW);
}

void stroke(int dir) {
  Serial.println(dir > 0 ? "OUT" : "IN");
  digitalWrite(SLP, HIGH);
  delay(2);                   // the DRV8833 wakes up within 1 ms
  drive(dir);
  unsigned long start = millis();
  while (millis() - start < TIME_MS) {
    char line[32];
    snprintf(line, sizeof line, "%5lu ms  %4d mA", millis() - start, currentMA());
    Serial.println(line);
    delay(100);
  }
  drive(0);
  digitalWrite(SLP, LOW);
}

void setup() {
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);
  pinMode(SLP, OUTPUT);
  Serial.begin(115200);
  analogReference(INTERNAL);                      // scale from 0 to 1.1 V, not 0 to 5 V
  for (byte i = 0; i < 5; i++) analogRead(SENSE);  // the first readings don't count
  stroke(1);
  delay(3000);
  stroke(-1);
  Serial.println("Done. To repeat, press RESET after a few minutes of rest.");
}

void loop() {
}

// The lid: OPEN and CLOSE with two buttons. The motor stops for three reasons:
// a press on a button, a current that is too high (rod at the end or against an
// obstacle) or the maximum time. After each stroke the actuator rests.
#include <Arduino.h>

const byte B_OPEN = 2;        // buttons to GND, with the internal pull-up
const byte B_CLOSE = 3;
const byte AIN1 = 8;
const byte AIN2 = 9;
const byte SLP = 10;
const byte SENSE = A0;        // AS pin of the driver: 0.2 V for every amp

const unsigned int STROKE_MM = 50;                       // the stroke of your actuator
const unsigned long MAX_TIME = STROKE_MM * 1300UL / 7;  // stroke / 7 mm/s, +30 %
const int THRESHOLD_MA = 800;        // above this current the rod is stalled
const unsigned long INRUSH_MS = 300; // at start-up the current is high: ignore it
const byte REST_X = 9;               // rest = 9 times the moving time (10 %)

struct Button {
  byte pin;
  bool pressed;               // stable state
  bool reading;               // last reading
  unsigned long changed;      // when the reading changed
};
Button openBtn = {B_OPEN, false, false, 0};
Button closeBtn = {B_CLOSE, false, false, 0};

enum State { IDLE, OPENING, CLOSING, RESTING };
State state = IDLE;
char position = '?';          // O open, C closed, M midway, ? unknown
unsigned long start;          // start of the movement or of the rest
unsigned long rest;           // how long the rest must last
unsigned long normal;         // last moment with the current below threshold
int peak;                     // highest current seen after the inrush

bool tapped(Button &b) {      // true only once, when the button is pressed
  bool now = digitalRead(b.pin) == LOW;
  if (now != b.reading) {
    b.reading = now;
    b.changed = millis();
  }
  if (millis() - b.changed > 30 && b.pressed != b.reading) {   // stable for 30 ms
    b.pressed = b.reading;
    return b.pressed;
  }
  return false;
}

int currentMA() {
  long sum = 0;
  for (byte i = 0; i < 20; i++) sum += analogRead(SENSE);
  float mV = sum / 20.0 * 1100.0 / 1024.0;
  return (int)(mV * 5);
}

void go(State s) {
  state = s;
  digitalWrite(SLP, HIGH);
  delay(2);
  digitalWrite(AIN1, s == OPENING ? HIGH : LOW);
  digitalWrite(AIN2, s == CLOSING ? HIGH : LOW);
  start = normal = millis();
  peak = 0;
  Serial.println(s == OPENING ? "Opening" : "Closing");
}

void halt(const char *reason, char where) {
  digitalWrite(AIN1, LOW);
  digitalWrite(AIN2, LOW);
  digitalWrite(SLP, LOW);
  unsigned long duration = millis() - start;
  position = where;
  rest = duration * REST_X;
  start = millis();
  state = RESTING;
  char line[72];
  snprintf(line, sizeof line, "Stopped (%s) after %lu ms, peak %d mA, rest %lu s",
           reason, duration, peak, rest / 1000);
  Serial.println(line);
}

void setup() {
  pinMode(B_OPEN, INPUT_PULLUP);
  pinMode(B_CLOSE, INPUT_PULLUP);
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);
  pinMode(SLP, OUTPUT);
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(115200);
  analogReference(INTERNAL);
  for (byte i = 0; i < 5; i++) analogRead(SENSE);
  Serial.println("Ready");
}

void loop() {
  bool o = tapped(openBtn);
  bool c = tapped(closeBtn);
  unsigned long now = millis();
  if (state == OPENING || state == CLOSING) {
    char endPos = state == OPENING ? 'O' : 'C';
    unsigned long t = now - start;
    int mA = currentMA();
    if (t > INRUSH_MS && mA > peak) peak = mA;
    if (t < INRUSH_MS || mA < THRESHOLD_MA) normal = now;
    if (o || c) halt("button", 'M');
    else if (now - normal > 150) halt("high current", endPos);
    else if (t > MAX_TIME) halt("max time", endPos);
  } else if (state == RESTING) {
    digitalWrite(LED_BUILTIN, (now / 250) % 2 ? HIGH : LOW);   // the L LED blinks
    if (now - start > rest) {
      state = IDLE;
      digitalWrite(LED_BUILTIN, LOW);
      Serial.println("Ready");
    }
  } else if (o && position != 'O') {
    go(OPENING);
  } else if (c && position != 'C') {
    go(CLOSING);
  }
}