Un attuatore lineare per aprire uno sportello

Un attuatore lineare trasforma il giro di un motorino in una spinta in linea retta: lo stelo esce, si ferma, rientra. Con uno di questi apri lo sportello di una scatola, una botola, una presa d'aria. Qui usiamo gli attuatori DFRobot da 6 V, che esistono con quattro corse diverse, e li comandiamo da Arduino UNO con due pulsanti, APRI e CHIUDI. La parte più interessante è quella che non si vede: come fermarsi in fondo senza sapere quanta corrente assorbe il motore, perché DFRobot non lo scrive.

// Prova dell'attuatore lineare: lo stelo esce, si ferma, rientra. Ogni 100 ms il
// monitor seriale mostra la corrente letta sul pin AS del driver DRV8833.
#include <Arduino.h>

const byte AIN1 = 8;          // i due ingressi del ponte A
const byte AIN2 = 9;
const byte SLP = 10;          // HIGH = driver acceso, LOW = driver a riposo
const byte SENSE = A0;        // pin AS: 0,2 V per ogni ampere che passa nel motore

const unsigned int CORSA_MM = 50;   // la corsa del tuo attuatore: 10, 30, 50 o 100
// durata di una corsa: corsa diviso 7 mm/s (dato DFRobot), con il 30 % in più di margine
const unsigned long TEMPO_MS = CORSA_MM * 1300UL / 7;

int correnteMA() {
  long somma = 0;
  for (byte i = 0; i < 20; i++) somma += analogRead(SENSE);
  float mV = somma / 20.0 * 1100.0 / 1024.0;   // media in millivolt, scala da 1,1 V
  return (int)(mV * 5);                        // 1 mV su 0,2 ohm = 5 mA
}

void muovi(int verso) {       // 1 = fuori, -1 = dentro, 0 = fermo
  digitalWrite(AIN1, verso > 0 ? HIGH : LOW);
  digitalWrite(AIN2, verso < 0 ? HIGH : LOW);
}

void corsa(int verso) {
  Serial.println(verso > 0 ? "FUORI" : "DENTRO");
  digitalWrite(SLP, HIGH);
  delay(2);                   // il DRV8833 si sveglia entro 1 ms
  muovi(verso);
  unsigned long inizio = millis();
  while (millis() - inizio < TEMPO_MS) {
    char riga[32];
    snprintf(riga, sizeof riga, "%5lu ms  %4d mA", millis() - inizio, correnteMA());
    Serial.println(riga);
    delay(100);
  }
  muovi(0);
  digitalWrite(SLP, LOW);
}

void setup() {
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);
  pinMode(SLP, OUTPUT);
  Serial.begin(115200);
  analogReference(INTERNAL);                      // scala da 0 a 1,1 V, non da 0 a 5 V
  for (byte i = 0; i < 5; i++) analogRead(SENSE);  // le prime letture non valgono
  corsa(1);
  delay(3000);
  corsa(-1);
  Serial.println("Fine. Per ripetere premi RESET, dopo qualche minuto di riposo.");
}

void loop() {
}

// Lo sportello: APRI e CHIUDI con due pulsanti. Il motore si ferma per tre motivi:
// un tocco su un pulsante, la corrente troppo alta (stelo in fondo o contro un
// ostacolo) o il tempo massimo. Dopo ogni corsa l'attuatore riposa.
#include <Arduino.h>

const byte P_APRI = 2;        // pulsanti verso GND, con il pull-up interno
const byte P_CHIUDI = 3;
const byte AIN1 = 8;
const byte AIN2 = 9;
const byte SLP = 10;
const byte SENSE = A0;        // pin AS del driver: 0,2 V per ogni ampere

const unsigned int CORSA_MM = 50;                        // la corsa del tuo attuatore
const unsigned long TEMPO_MAX = CORSA_MM * 1300UL / 7;  // corsa / 7 mm/s, +30 %
const int SOGLIA_MA = 800;           // oltre questa corrente lo stelo è bloccato
const unsigned long SPUNTO_MS = 300; // alla partenza la corrente è alta: non conta
const byte RIPOSO_X = 9;             // riposo = 9 volte il tempo di moto (10 %)

struct Pulsante {
  byte pin;
  bool premuto;               // stato stabile
  bool letto;                 // ultima lettura
  unsigned long cambio;       // quando la lettura è cambiata
};
Pulsante apri = {P_APRI, false, false, 0};
Pulsante chiudi = {P_CHIUDI, false, false, 0};

enum Stato { FERMO, APRE, CHIUDE, RIPOSA };
Stato stato = FERMO;
char posizione = '?';         // A aperto, C chiuso, M a metà, ? non si sa
unsigned long inizio;         // partenza del movimento o del riposo
unsigned long riposo;         // quanto deve durare il riposo
unsigned long normale;        // ultimo istante con la corrente sotto soglia
int picco;                    // corrente più alta vista dopo lo spunto

bool tocco(Pulsante &p) {     // vero una volta sola, quando il pulsante viene premuto
  bool ora = digitalRead(p.pin) == LOW;
  if (ora != p.letto) {
    p.letto = ora;
    p.cambio = millis();
  }
  if (millis() - p.cambio > 30 && p.premuto != p.letto) {   // stabile da 30 ms
    p.premuto = p.letto;
    return p.premuto;
  }
  return false;
}

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

void parti(Stato s) {
  stato = s;
  digitalWrite(SLP, HIGH);
  delay(2);
  digitalWrite(AIN1, s == APRE ? HIGH : LOW);
  digitalWrite(AIN2, s == CHIUDE ? HIGH : LOW);
  inizio = normale = millis();
  picco = 0;
  Serial.println(s == APRE ? "Apro" : "Chiudo");
}

void ferma(const char *motivo, char dove) {
  digitalWrite(AIN1, LOW);
  digitalWrite(AIN2, LOW);
  digitalWrite(SLP, LOW);
  unsigned long durata = millis() - inizio;
  posizione = dove;
  riposo = durata * RIPOSO_X;
  inizio = millis();
  stato = RIPOSA;
  char riga[72];
  snprintf(riga, sizeof riga, "Fermo (%s) dopo %lu ms, picco %d mA, riposo %lu s",
           motivo, durata, picco, riposo / 1000);
  Serial.println(riga);
}

void setup() {
  pinMode(P_APRI, INPUT_PULLUP);
  pinMode(P_CHIUDI, 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("Pronto");
}

void loop() {
  bool a = tocco(apri);
  bool c = tocco(chiudi);
  unsigned long adesso = millis();
  if (stato == APRE || stato == CHIUDE) {
    char fine = stato == APRE ? 'A' : 'C';
    unsigned long t = adesso - inizio;
    int mA = correnteMA();
    if (t > SPUNTO_MS && mA > picco) picco = mA;
    if (t < SPUNTO_MS || mA < SOGLIA_MA) normale = adesso;
    if (a || c) ferma("pulsante", 'M');
    else if (adesso - normale > 150) ferma("corrente alta", fine);
    else if (t > TEMPO_MAX) ferma("tempo massimo", fine);
  } else if (stato == RIPOSA) {
    digitalWrite(LED_BUILTIN, (adesso / 250) % 2 ? HIGH : LOW);   // il LED L lampeggia
    if (adesso - inizio > riposo) {
      stato = FERMO;
      digitalWrite(LED_BUILTIN, LOW);
      Serial.println("Pronto");
    }
  } else if (a && posizione != 'A') {
    parti(APRE);
  } else if (c && posizione != 'C') {
    parti(CHIUDE);
  }
}