Stepper e Arduino

[hellfire39]

Hai il manuale di quello specifico modello di driver?

[hellfire39]

Prendendo il drive da solo, scollegato da tutto, puoi provare a collegare solamente l'enable, direttamente ai 5V, se ti si accende il le ddi allarme, significa che quel led si accende anche quando il driver viene disabilitato.

Va notato che il segnale EN dei driver è tipicamente attivo basso. Significa che il driver è abilitato quando non c'è segnale.
Per questa ragione, se ti va bene avere il driver sempre abilitato, puoi anche evitare di collegare l'enable ad arduino.

Hai due controindicazioni:
- il motore sarà sempre in coppia e non potrai muovere l'asse a mano.
- consumerai inutilmente corrente e scalderai inutilmente il motore.

[leomonti]

- Il manuale ce l'ho, come lo mando?
- Giusto per precisazione, anche se siamo nell'ovvietà, il collegamento è a catodo comune. Credo che con Arduino non si possa fare diversamente.
- A me, di vedere la spia dell'allarme accesa col motore fermo non importa nulla, l'importante è che questo non determini anomalie più importanti

- Riesci a modificare lo sketch (o a indicarmi cosa modificare) perchè il potenziometro lavori anche durante il moto?

[MauPre75]

Domanda per Hellfire, con l'enable disabilitato il motore può essere mosso a mano senza rischi per il driver? È un dubbio che ho sempre avuto ma mai sperimentato, potrebbe servirmi anche nel mio accrocchio che ho finito di costruire.

[hellfire39]

@maupre75
domanda più che logica.
Non ti so rispondere con certezza perché non so come sono fatti i circuiti interni dei driver.

Di sicuro lo stepper si comporta come un generatore, quando lo muovi a mano. C'entra anche la velocità con cui riesci a muoverlo.
Muovendolo lentamente non penso si riesca a generare tensioni pericolose per il driver.

@leomonti
Il manuale è scaricabile online? Nel caso metti il link

[leomonti]

I miei non sono leadshine originali, ma credo siano uguali https://www.leadshine.com/legacys/DM556.html
Anche questi sono DM556 https://www.omc-stepperonline.com/it/az ... sso-dm556t

[leomonti]

A proposito di stepper come generatori, i driver con ingressi optoisolati non dovrebbero teoricamente prevenire il ritorno di tensione?

[MauPre75]

Leomonti sono gli ingressi optoisolati non le uscite, comunque gli stepper per quello che ho potuto constatare producono tensioni relativamente basse, per arrivare a 12V bisogna girarli veramente velocemente e bassa corrente, da un motore da 1,1A al massimo sono riuscito a tirare fuori tra i 150 ed i 200 mA

[leomonti]

Hai ragione, ho detto una c...ta

La butto lì....Diodi di protezione??

[MauPre75]

Guardando il datasheet di un L298 l'enable fornisce una condizione alle porte logiche che pilotano il ponte H costituito dai transistori, al centro sono collegate le bobine del motore, un ragionamento che faccio è se collego una fonte di alimentazione a monte del collettore di un transistor la corrente non può circolare se non saturo la base, non dovrebbe essere diverso se la fonte è il motore, forse sarebbe dannoso se i transistor sono in conduzione ed il motore anziché assorbire corrente la produce e forza il transistor, quindi con enable alto abbiamo ponte H disabitato e circuito non in conduzione, la corrente del motore non può circolare dentro il driver, ho detto caxxate?

Ps
Guardando l'immagine forse la corrente arriverebbe tramite i diodi di ricircolo all'alimentazione del ponte

[hellfire39]

Ho provato a modificare la velocità al volo.
Funziona ma se abbassi repentinamente la velocità, lo stepper non decellera in rampa.
Vicecersa, se aumenti la velocità, il motore accelera in rampa.

Riguardo all'allarme, non so che dire. Purtroppo non ho un driver di questo tipo.
Magari posso provare con DM542 per vedere come si comporta (attualmente sto provando con un driverino di quelli piccini, da stampante 3d).
Leggendo il manuale vedo che il led rosso è associato a differenti codici di errore in base al numero di lampeggi.
Nel tuo caso il led rimane fisso o lampeggia?

Potrei provare a fare un paio di ipotesi, ma sono un po' alla cieca.
Il driver potrebbe incavolarsi se gli viene disabilitato l'enable troppo presto (a ridosso degli impulsi).
In questo caso si può agire sui comandi seguenti per aumentare il ritardo del segnale enable (il valore dovrebbe essere espresso in microsecondi).

Codice: Seleziona tutto

    
    stepperX->setDelayToEnable(100);
    stepperX->setDelayToDisable(100);
 

Oppure, come prima prova, si può tenere il drive sempre abilitato non collegando l'ingresso EN.

Codice: Seleziona tutto

#include "FastAccelStepper.h"
#include <Bounce2.h>

#define dirPinStepperX 2
#define enablePinStepperX 4
#define stepPinStepperX 9
#define avantiX 7
#define indietroX 6
#define pinFinecorsaX 8

/*
#define dirPinStepperY 2
#define enablePinStepperY 4
#define stepPinStepperY 9
#define avantiY 7
#define indietroY 6
#define pinFinecorsaY 8

#define dirPinStepperZ 2
#define enablePinStepperZ 4
#define stepPinStepperZ 9
#define avantiZ 7
#define indietroZ 6
#define pinFinecorsaZ 8
*/



enum direzione {avanti, indietro, nessuna};

// memorizza lo stato di un asse
typedef struct DatiAsse {
  direzione ultimaDirezione;      // direzione in cui si sta muovendo l'asse  
  direzione finecorsaImpegnato;   // finecorsa impegato
  bool comandoAttivo;             // c'è un comando attivo
};

// class factory per gli stepper
FastAccelStepperEngine engine = FastAccelStepperEngine();

// creazione di uno stepper (da configurare in setup())
FastAccelStepper *stepperX = NULL;
//FastAccelStepper *stepperY = NULL;
//FastAccelStepper *stepperZ = NULL;


// antirimbalzo software per pulsanti e finecorsa (da configurare in setup())
Bounce2::Button buttonXplus = Bounce2::Button();
Bounce2::Button buttonXminus = Bounce2::Button();
Bounce finecorsaX = Bounce();

/*
Bounce2::Button buttonYplus = Bounce2::Button();
Bounce2::Button buttonYminus = Bounce2::Button();
Bounce finecorsaZ = Bounce();

Bounce2::Button buttonZplus = Bounce2::Button();
Bounce2::Button buttonZminus = Bounce2::Button();
Bounce finecorsaZ = Bounce();
*/

// dichiarazione della funzione implementata più sotto
void gestisciAsse(FastAccelStepper *stepper, DatiAsse &datiAsse, Bounce2::Button &dirAvanti, Bounce2::Button &dirIndietro, Bounce &finecorsa);


void setup() {
  engine.init();

  stepperX = engine.stepperConnectToPin(stepPinStepperX);
  if (stepperX) {
    stepperX->setDirectionPin(dirPinStepperX);
    stepperX->setEnablePin(enablePinStepperX);
    stepperX->setAutoEnable(true);
    stepperX->setDelayToEnable(100);
    stepperX->setDelayToDisable(100);

    // If auto enable/disable need delays, just add (one or both):
    // stepper->setDelayToEnable(50);
    // stepper->setDelayToDisable(1000);

    stepperX->setSpeedInUs(1000);       // the parameter is us/step !!!
    stepperX->setAcceleration(10000);   // step/s^2
  }

  /*
  stepperY = engine.stepperConnectToPin(stepPinStepperY);
  if (stepperY) {
    stepperY->setDirectionPin(dirPinStepperY);
    stepperY->setEnablePin(enablePinStepperY);
    stepperY->setAutoEnable(true);
    stepperY->setDelayToEnable(100);
    stepperY->setDelayToDisable(100);

    // If auto enable/disable need delays, just add (one or both):
    // stepper->setDelayToEnable(50);
    // stepper->setDelayToDisable(1000);

    stepperY->setSpeedInUs(1000);       // the parameter is us/step !!!
    stepperY->setAcceleration(10000);   // step/s^2
  }

  stepperZ = engine.stepperConnectToPin(stepPinStepperZ);
  if (stepperZ) {
    stepperZ->setDirectionPin(dirPinStepperZ);
    stepperZ->setEnablePin(enablePinStepperZ);
    stepperZ->setAutoEnable(true);
    stepperZ->setDelayToEnable(100);
    stepperZ->setDelayToDisable(100);

    // If auto enable/disable need delays, just add (one or both):
    // stepper->setDelayToEnable(50);
    // stepper->setDelayToDisable(1000);

    stepperZ->setSpeedInUs(1000);       // the parameter is us/step !!!
    stepperZ->setAcceleration(10000);   // step/s^2
  }
  */


  // impostazioni antirimbalzo
  finecorsaX.attach( pinFinecorsaX, INPUT_PULLUP);
  finecorsaX.interval(20);

  buttonXplus.attach( avantiX, INPUT_PULLUP );  // USE EXTERNAL PULL-UP
  buttonXplus.interval(5);                         // DEBOUNCE INTERVAL IN MILLISECONDS
  buttonXplus.setPressedState(LOW);                // LOW = TASTO PREMUTO

  buttonXminus.attach( indietroX, INPUT_PULLUP ); // USE EXTERNAL PULL-UP
  buttonXminus.interval(5);                        // DEBOUNCE INTERVAL IN MILLISECONDS
  buttonXminus.setPressedState(LOW);               // LOW = TASTO PREMUTO

/*
  finecorsaY.attach( pinFinecorsaY, INPUT_PULLUP);
  finecorsaY.interval(20);

  buttonYplus.attach( avantiY, INPUT_PULLUP );  // USE EXTERNAL PULL-UP
  buttonYplus.interval(5);                         // DEBOUNCE INTERVAL IN MILLISECONDS
  buttonYplus.setPressedState(LOW);                // LOW = TASTO PREMUTO

  buttonYminus.attach( indietroY, INPUT_PULLUP ); // USE EXTERNAL PULL-UP
  buttonYminus.interval(5);                        // DEBOUNCE INTERVAL IN MILLISECONDS
  buttonYminus.setPressedState(LOW);               // LOW = TASTO PREMUTO

  finecorsaZ.attach( pinFinecorsaZ, INPUT_PULLUP);
  finecorsaZ.interval(20);

  buttonZplus.attach( avantiY, INPUT_PULLUP );  // USE EXTERNAL PULL-UP
  buttonZplus.interval(5);                         // DEBOUNCE INTERVAL IN MILLISECONDS
  buttonZplus.setPressedState(LOW);                // LOW = TASTO PREMUTO

  buttonZminus.attach( indietroY, INPUT_PULLUP ); // USE EXTERNAL PULL-UP
  buttonZminus.interval(5);                        // DEBOUNCE INTERVAL IN MILLISECONDS
  buttonZminus.setPressedState(LOW);               // LOW = TASTO PREMUTO
*/



  // solo per debug
  Serial.begin(115200);
}


DatiAsse datiAsseX;
//DatiAsse datiAsseY;
//DatiAsse datiAsseZ;

uint32_t speedStep;

void loop() {
  
  int speedIn = analogRead(A0);
  speedStep = map(speedIn, 1023, 0, 50, 1000);

  gestisciAsse(stepperX, datiAsseX, buttonXplus, buttonXminus, finecorsaX);
  //gestisciAsse(stepperY, datiAsseY, buttonYplus, buttonZminus, finecorsaY);
  //gestisciAsse(stepperZ, datiAsseZ, buttonZplus, buttonZminus, finecorsaZ);


}


// questa funzione, da richiamare periodicamente in loop(), 
// si occupa di gestire un singolo asse.
// Va richiamata per ogni asse che deve essee gestito.
void gestisciAsse(FastAccelStepper *stepper, DatiAsse &datiAsse, Bounce2::Button &dirAvanti, Bounce2::Button &dirIndietro, Bounce &finecorsa) {

  // aggiornamento stato ingressi
  dirAvanti.update();
  dirIndietro.update();
  finecorsa.update();



  // il finecorsa è impegnato?
  bool finecorsaPremuto = finecorsa.read() == HIGH;

  // movimento avanti 
  bool possoMuovermi =  (!finecorsaPremuto || (finecorsaPremuto && (datiAsse.finecorsaImpegnato == indietro)));
  if (dirAvanti.isPressed() && possoMuovermi && !datiAsse.comandoAttivo) {
    stepper->setSpeedInUs(speedStep);
    stepper->runForward();
    Serial.println("forward");
    datiAsse.comandoAttivo = true;
    datiAsse.ultimaDirezione = avanti;
  }

  // necessario per cambiare la velocità
  if (dirAvanti.isPressed() && possoMuovermi ) {
    stepper->setSpeedInUs(speedStep); 
    stepper->runForward();   
  }



  // movimento indietro
  possoMuovermi = (!finecorsaPremuto || (finecorsaPremuto && (datiAsse.finecorsaImpegnato == avanti)));
  if (dirIndietro.isPressed() && possoMuovermi && !datiAsse.comandoAttivo) {
    stepper->setSpeedInUs(speedStep);
    stepper->runBackward();
    Serial.println("backward");
    datiAsse.comandoAttivo = true;
    datiAsse.ultimaDirezione = indietro;
  }

  // necessario per cambiare la velocità
  if (dirIndietro.isPressed() && possoMuovermi ) {
    stepper->setSpeedInUs(speedStep); 
    stepper->runBackward();   
  }  

  // stop in rampa
  if ((!dirAvanti.isPressed()) && (!dirIndietro.isPressed()) && datiAsse.comandoAttivo) {
    stepper->stopMove();            
    Serial.println("stopMove");
    datiAsse.comandoAttivo = false;
  }
  
  // se sono fermo, resetto la direzione corrente
  if (!stepper->isRunning()) {
    datiAsse.ultimaDirezione = nessuna;
  }
  
  // stop immediato per impegno finecorsa
  if (finecorsaPremuto && (datiAsse.finecorsaImpegnato == nessuna) && stepper->isRunning() ) {
    stepper->forceStop();           // forceStop == fermata immediata
    Serial.println("forceStop");

    datiAsse.comandoAttivo = false;
    datiAsse.finecorsaImpegnato = datiAsse.ultimaDirezione;
  }

  // rilascio finecorsa, resetto la memoria del finecorsa impegnato
  if (!finecorsaPremuto && (datiAsse.finecorsaImpegnato != nessuna)) {
    datiAsse.finecorsaImpegnato = nessuna;
    Serial.println("reset flag finecorsa");
  }

}

P.S. i manuali del DM556 fanno riferimento ad un SW di configurazione. Non so se utilizzando il suddetto SW si riesce ad avere una diagnostica più accurata.

[leomonti]

Proverò il nuovo sketch e ti saprò dire. Intanto GRAZIE.
Picolo OT: sto ancora usando la versione 1.8.19 dell'Ide. Ho provato la 2.2.1 ma non mi era piaciuta un granchè. Pro e contro?

[hellfire39]

Mah, non saprei dire. Per l'utente casuale, non vedo grosse differenze.
Sicuramente è un po' più comodo scrivere SW, ma trovo ancora più comodo scrive codice su Visual Studio Code e PlatformIO.
Di contro, quest'ultimo lo trovo un po' meno user friendly.

Io aggiorno sempre l'ambiente di sviluppo, ma per tenerlo aggiornato più che altro.

[torn24]

Off topic
Avevo sentito ultimamente notizie sull'ultimo ide arduino non basato più su java, per quanto riguarda la necessita di svilupparlo che IDE standard con i continui aggiornamenti era diventato mastodontico a livello di codice e risultava difficile per gli sviluppatori, il nuovo IDE non è una rivoluzione per chi è abituato a un comune IDE come visual studio, ma porta degli aiuti come il completamento automatico del codice, ossia scrivendo il codice ti suggerisce il codice da inserire, esempio vuoi inserire una libreria C ma non ti ricordi esattamente il nome, ti propone le possibili scelte corrette.
Ma niente di stravolgente o rivoluzionario, non aggiorno l'idee se non sono obbligato e se non mi crea problemi, poi è una scelta personale a casa sua uno fa quello che vuole o quasi

[hellfire39]

@torn24

non avevo dubbi che, tra due scelte, avessi fatto quella sbagliata...

Tenere aggiornato l'ambiente di sviluppo serve essenzialmente perché ogni nuova versione contiene parecchi bugfix.
La versione 2 ha il grande vantaggio di consentire il debug, oltre ad avere l'autocompletamento.

Ora, se devi solamente caricare uno sketch, potrebbe non essere importante rimanere aggiornati. Ma se utilizzi l'IDE per programmare, allora diventa fondamentale.
Il motivo per cui ero passato a VScode + PlatformIO, sebbene lo trovassi più macchinoso, era proprio per la presenza delle funzioni mancanti nella versione 1 dell'IDE di arduino.