help progetto mini tornio da banco

[brborl]

Salve a tutti,mi sono imbarcato in una cosa troppo grande per me' che sono un semplice elettricista con molta passione per il fai da te' e chi doveva aiutarmi nella parte programmazione di arduino si e' traferito per lavoro all'estero quindi mi ritrovo con il materiale e non so' come fare,mi spiego meglio,vorrei motorizzare l'avanzamento del carrello longitudinale del mio tornietto da banco che uso per hobby per otimizzare la velocita di avanzamento a mio piacimento senza dover cambiare ogni volta gli ingranaggi,il materiale acquistato su consiglio del mio amico e' questo:
motore:NEMA 23 MODELLO 23HS9442-4,2A-1,8 DEG/STEP DELLA LONGS-MOTOR
DRIVER DM542A DELLA LONG-MOTOR
N°1 ARDUINO UNO
N°2 FINECORSA N.O. DA INSTALLARE COME FINE CORSA TUTTO/AVANTI TUTTO INDIETRO
N°1 POTENZIOMETRO 10K 1 GIRO PER REGOLARE LA VELOCITA' DEL MOTORE
N°1 SELETTORE 1-2,POSIZIONE "1" N.O. ROTAZIONE SX,POSIZIONE "0" N.O. ROTAZIONE DX
N°1 DISPLAY PER LA VISUALIZZAZONE DELLA VELOCITA' IMPOSTATA DA POTENZIOMETRO QUINDI NO ENCODER MA CALCOLO MATEMATICO
N° 1 ALIMENTATORE 24 VDC 5A X IL DRIVER
N° 1 ALIMENTATORE 5 VDC PER ARDUINO
la parte cablaggio principale senza input e output su arduino e montaggio meccanico gia' eseguita,mi manca tutta la parte programmazione di arduino in quanto per me ' sconosciuta,diciamo che potrei arrivare a caricare un programma gia' pronto ma non crearlo,chiedo aiuto a qualche buon anima che ha gia eseguito qualcosa di simile se mi puo' passare tale software per arduino,grazie mille.
Bruno

[torn24]

Ciao! Il programma per arduino non dovrebbe essere molto complicato. Seppur non complicato anche conoscendo le basi della programmazione arduino, comporta la spesa di tempo per realizzarlo Propongo questo! Aspetta se qualcuno ha già qualche programma pronto, senno vediamo di creare il programma impiegando 30 o 60 minuti, perché poi c'è sempre qualcosa da sistemare dopo la prova del programma, e se uno ha pensato un ora di tempo poi potrebbe servire più tempo

[torn24]

Ho provato a fare un abbozzo di programma, manca il display perché esistono tanti tipi diversi e prevede che tu installi le giuste librerie per arduino, in caso di lcd i2c bisogna anche sapere l'indirizzo del tuo i2c usato dalla libreria. In pratica potrebbe essere laborioso il codice per far funzionare il display.


Il programma è un po semplicistico ma mi è venuto cosi, non sono riuscito a farlo più complesso
Se leggi i commenti nel codice, sai che devi mettere il numero pin effettivamente utilizzato per pulsanti e potenziometro, devi inoltre mettere il passo in millimetri della vite e i passi motore necessari per fare un giro di vite, informati su passi a giro del motore e fai i calcoli.


ecco l'abbozzo di programma che probabilmente avrà bisogno di correzioni per funzionare... comunque una buona base di partenza

Codice: Seleziona tutto

/* Qui le costanti associate ai pin
 * MODIFICARE e mettere il numero pin
 * utilizzato
 */
#define PASSOVITE 5  // PASSO DELLA VITE SENZA RIDUZIONI
#define PASSIGIRO 200 //PASSI A GIRO DELLA VITE
#define STEPPIN 2
#define DIRPIN 3
#define FINECORSA1 4
#define FINECORSA2 5
#define SELETTORE 6
#define POTENZIOMETRO A0
/* Varibili globali usate nel programma */

int Velocita=0;
int temp=0;
int Pausa=0;
int ValorePrecedente=0;
int StepAlMinuto=0;
int Pausa=0;
void setup() {
  /* con input PULLUP sono premuti quando sono LOW stato basso*/
  pinMode(STEPPIN,OUTPUT);
  pinMode(DIRPIN,OUTPUT);
  pinMode(FINECORSA1,INPUT_PULLUP);
  pinMode(FINECORDA1,INPUT_PULLUP);
  pinMode(SELETTORE,INPUT_PULLUP);

}

void loop() {
  
    temp=analogRead(POTENZIOMETRO); //Lettura potenziometro
    if(temp!=ValorePrecedente){// Se il valore del potenziometro è cambiato

        ValorePrecedente=temp;
        Velocita=map(temp,0,1024,0,1000); //Velocità massima 1000 millimetri al minuto
        StepAlMinuto=(velocita/PASSOVITE)*PASSIGIRO; // Passi motore al minuto
        Pausa=(60*1000)/StepAlminuto/2; //Pausa per i passi
    }
      
   if(digitalRead(SELETTORE)==HIGH){
       digitalWrite(DIRPIN,HIGH);
   }else{
       digitalWrite(DIRPIN,LOW);
   }

   /* Qui esegue il passo motore solo se i finecorsa non sono attivi.
    *  il SELETTORE è un PULLUP deve dare LOW e HIGH
    *  questo codice funziona se SELETTORE A 1 FINECORSA1
    *  SELETTORE A ZERO FINECORSA2
    *  il finecorsa deve dare LOW massa quando è attivato
    */
    if(digitalRead(SELETTORE)==LOW && digitalRead(FINECORSA1)==HIGH || digitalRead(SELETTORE)==HIGH && igitalRead(FINECORSA2)==HIGH){//Se selettore e LOW e finecorsa1 non attivo O settore e HIGH  e finecorsa2 non attivo
                                                               
        STEP(); //Fai un passo motore
    }// end if
   
}

void STEP(){
    // Funzione che fa un singolo passo motore
    digitalWrite(STEPPIN,HIGH);
    delay(Pausa);
    digitalWrite(STEPPIN,LOW);
    delay(Pausa);
}

[hellfire39]

@Torn24
Ti consiglio di buttare un occhio alla libreria AccelStepper.
Quella libreria gestisce anche le accelerazioni, potrebbero essere utili.

----------------
P.S. da un'occhiata veloce al codice, mi pare di aver visto la possibilità di avere divisioni per 0.
temp = 0 --> velocità = 0 --> StepAlMinuto = 0 --> Pausa = !divisione per zero!

Non sarebbe il caso di aver un selettore di start e stop?
Nel caso di risposta negativa, si potrebbe mettere un limite inferiore sotto il quale non fare passi.

[torn24]

@ hellfire39 ho sentito parlare della libreria, però ho pensato che nell'avanzamento utensile da tornio abbiamo una certa tolleranza sull'avanzamento e ho pensato che non sia necessario preoccuparsi dell'accelerazione e decelerazione.

hellfire39 se vuoi modificare il codice che ho postato per migliorarlo "esempio le divisioni per zero" o vorresti proporre uno migliore, sarebbe una cosa positiva. Non pretendo di dare la soluzione migliore ma capita spesso di dare una soluzione funzionante dove nessuno vuole darla

[brborl]

Un grazie a tutti questa sera o domani provo,in attesa vediamo se arrivano ulteriori info,rigrazie.
Bruno

[hellfire39]

dove nessuno vuole darla

appunto

L'accelerazione è sempre una buona idea. Qui, in realtà, per come è scritto il codice, l'accelerazione la fai già con il potenziometro.
Cerco che, se l'utente scambia al volo la direzione, il motore non gradirebbe molto

La libreria AccelStepper è interessante, ma un po' scomoda, per certi aspetti.
Infatti, in speedmode, non utilizza l'accelerazione. Lo fa solamente per comandi di posizione.

[brborl]

salve @torn24 ho provato il tuo programma non sono riuscito a farlo girare,assieme a mio figlio abbiamo apportato alcune modifiche tralasciando i finecorsa e al posto del selettore di inversione marcia abbiamo utilizzato un pulsante,ad ogni impulso avviene il cambio di direzione,tutto sembra funzionare giri minimo e giri massimo sotto l'aspetto tornitura non riusciamo pero' a fermare il motore con il potenziometro totalmente a zero,abbiamo provato in diversi modi ma probabilmente qualcosa sfugge alle nostre misere capacita' di programmazione arduino,vediamo se qualche guru' riesce al illuminarci,grazie.

come puoi vedere abbiamo messo a commento la parte di programma in cui avevi impostato la variabile pausa poiché in quel modo il programma non faceva girare il motore.
Bruno

Codice: Seleziona tutto

#include <MultiStepper.h>
#include <Stepper.h>
/* Qui le costanti associate ai pin
 * MODIFICARE e mettere il numero pin
 * utilizzato
 */

  
int PASSOVITE = 2; // PASSO DELLA VITE SENZA RIDUZIONI
int PASSIGIRO = 3200; //PASSI A GIRO DELLA VITE
int STEPPIN = 7;
int DIRPIN = 6;
int FINECORSA1 = 4;
int FINECORSA2 = 5;
int SELETTORE = 3;
int POTENZIOMETRO = A0;
/* Varibili globali usate nel programma */

int Velocita;
boolean setdir= LOW;
//int temp=0;
//int Pausa=0;
//int ValorePrecedente=0;
//int StepAlMinuto=0;

void revmotor (){
  setdir = !setdir;
  }

void setup() {
  /* con input PULLUP sono premuti quando sono LOW stato basso*/
  pinMode(STEPPIN,OUTPUT);
  pinMode(DIRPIN,OUTPUT);
  pinMode(FINECORSA1,INPUT_PULLUP);
  pinMode(FINECORSA1,INPUT_PULLUP);
  pinMode(SELETTORE,INPUT);
  attachInterrupt(digitalPinToInterrupt(SELETTORE), revmotor, FALLING);
}

void loop() {
  
    //temp=analogRead(POTENZIOMETRO); //Lettura potenziometro
    //if(temp!=ValorePrecedente){// Se il valore del potenziometro è cambiato

      //  ValorePrecedente=temp;
        Velocita=map((analogRead(POTENZIOMETRO)),0,1024,0,1000); //Velocità massima 1000 millimetri al minuto
       // StepAlMinuto=(Velocita/PASSOVITE)*PASSIGIRO; // Passi motore al minuto
        //Pausa=(60*1000)/StepAlMinuto/2; //Pausa per i passi
    //}
  
   
   if(digitalRead(SELETTORE)==HIGH){
       digitalWrite(DIRPIN,HIGH);
   }else{
       digitalWrite(DIRPIN,LOW);
   }

   /* Qui esegue il passo motore solo se i finecorsa non sono attivi.
    *  il SELETTORE è un PULLUP deve dare LOW e HIGH
    *  questo codice funziona se SELETTORE A 1 FINECORSA1
    *  SELETTORE A ZERO FINECORSA2
    *  il finecorsa deve dare LOW massa quando è attivato
    */
    if(digitalRead(SELETTORE)==LOW && digitalRead(FINECORSA1)==HIGH || digitalRead(SELETTORE)==HIGH && digitalRead(FINECORSA2)==HIGH){//Se selettore e LOW e finecorsa1 non attivo O settore e HIGH  e finecorsa2 non attivo
                                                               
        STEP(); //Fai un passo motore
    }// end if
   
}

void STEP(){
    // Funzione che fa un singolo passo motore
    digitalWrite(DIRPIN,setdir);
    digitalWrite(STEPPIN,HIGH);
    delayMicroseconds(Velocita);
    digitalWrite(STEPPIN,LOW);
    delayMicroseconds(Velocita);
}

[hellfire39]

Ciao,
prima di tutto verifichiamo l'hardware. Sarebbe interessante vedere come è stato cablato il tutto.

Attenzione a dire: con la pressione di un pulsante si cambia direzione: se non viene messa in atto una strategia antirimbalzo, ad ogni pressione del pulsante, Arduino vedrà molti impulsi. Tenetene conto.

Se commentate la parte che dovrebbe temporizzare i passi da inviare al motore, non so come la cosa possa funzionare.
E' sbagliato, da un punto di vista logico, scrivere delay(velocità) perché il ritardo è un tempo non è una velocità. Anzi è il suo inverso.

Il codice originale che calcola la velocità ha un baco: se la funzione map() ritornasse 0 (che dovrebbe essere velocità nulla), il programma va in crash perché esegue una divisione per zero.

Inoltre, la lettura di un valore analogico tende ad essere ballerina, quindi non è detto che ogni lettura abbia sempre lo stesso esatto valore.

per ovviare al problema bisognerebbe controllare che il risultato di map() sia maggiore di un certo valore (ad es. 10).
In caso contrario: impostare la velocità nulla.

Vi rimetto il programma originale con una piccola modifica (guardate la variabile inMoto).

Codice: Seleziona tutto

/* Qui le costanti associate ai pin
 * MODIFICARE e mettere il numero pin
 * utilizzato
 */
#define PASSOVITE 5  // PASSO DELLA VITE SENZA RIDUZIONI
#define PASSIGIRO 200 //PASSI A GIRO DELLA VITE
#define STEPPIN 2
#define DIRPIN 3
#define FINECORSA1 4
#define FINECORSA2 5
#define SELETTORE 6
#define POTENZIOMETRO A0
/* Varibili globali usate nel programma */

int Velocita=0;
int temp=0;
int Pausa=0;
int ValorePrecedente=0;
int StepAlMinuto=0;
int Pausa=0;
void setup() {
  /* con input PULLUP sono premuti quando sono LOW stato basso*/
  pinMode(STEPPIN,OUTPUT);
  pinMode(DIRPIN,OUTPUT);
  pinMode(FINECORSA1,INPUT_PULLUP);
  pinMode(FINECORDA1,INPUT_PULLUP);
  pinMode(SELETTORE,INPUT_PULLUP);

}

void loop() {
  
    bool inMoto;
    temp=analogRead(POTENZIOMETRO); //Lettura potenziometro
    if(temp!=ValorePrecedente){// Se il valore del potenziometro è cambiato
        inMoto = (temp > 10);
		if (inMoto) {
			ValorePrecedente=temp;
			Velocita=map(temp,0,1024,0,1000); //Velocità massima 1000 millimetri al minuto
			StepAlMinuto=(velocita/PASSOVITE)*PASSIGIRO; // Passi motore al minuto
			Pausa=(60*1000)/StepAlminuto/2; //Pausa per i passi
		}	
    }
      
   if(digitalRead(SELETTORE)==HIGH){
       digitalWrite(DIRPIN,HIGH);
   }else{
       digitalWrite(DIRPIN,LOW);
   }

   /* Qui esegue il passo motore solo se i finecorsa non sono attivi.
    *  il SELETTORE è un PULLUP deve dare LOW e HIGH
    *  questo codice funziona se SELETTORE A 1 FINECORSA1
    *  SELETTORE A ZERO FINECORSA2
    *  il finecorsa deve dare LOW massa quando è attivato
    */
    if ([color=#FF0000]inMoto [/color]&& digitalRead(SELETTORE)==LOW && digitalRead(FINECORSA1)==HIGH || digitalRead(SELETTORE)==HIGH && igitalRead(FINECORSA2)==HIGH){//Se selettore e LOW e finecorsa1 non attivo O settore e HIGH  e finecorsa2 non attivo
                                                               
        STEP(); //Fai un passo motore
    }// end if
   
}

void STEP(){
    // Funzione che fa un singolo passo motore
    digitalWrite(STEPPIN,HIGH);
    delay(Pausa);
    digitalWrite(STEPPIN,LOW);
    delay(Pausa);
}

Vi consiglio di scaricare la libreria AccelStepper, direttamente dall'IDE di Arduino e guardare gli esempi.
Otterrete un codice più pulito e, soprattutto, non bloccante.

------------------------------
P.S. evitate di utilizzare parole TUTTE MAIUSCOLE nel codice se non si tratta di costanti.
Arduino, di solito, utilizza il camelStepping, ovvero scrivere in minuscolo, tilizzando le maiuscole per separare le parole. Con la prima lettera minuscola. (es. digitalWrite e non DIGITALWRITE). Quindi step() e non STEP()

Dimenticavo: occhio a delayMicrosecond(). Va bene utilizzarlo, ma non andate troppo veloci altrimenti il driver e/o lo stepper non ce la fanno. Secondo: nei calcoli, se volete farli, tenete conto che digitalWrite è lento, quindi introduce altro ritardo oltre quello voluto.

[mimoletti]

Se ti può interessare, quello che cerchi, l'ho realizzato con un micro della Pic, se ti va di realizzarlo ti posso fornire gratuitamente il file hex da caricare nel micro e tutte le info necessarie. Il circuito ha solo il Pic e pochi altri componenti. Volendo lo puoi realizzare anche su una basetta mille fori.

[hellfire39]

Mi sa che dovrai dargli il micro già programmato.
Dubito che abbiano un pickit3 nelle tasche

[mimoletti]

Eventualmente non ci sono problemi.

[torn24]

@ brborl il programma come lo avete modificato anche se non può sembrare, fa cose totalmente diverse da quello che ho postato. Modificare senza capire il principio di funzionamento è difficile che porta a migliorie, un po come cambiare 4 ingredienti a una ricetta, viene fuori una cosa totalmente diversa che diviene inutile leggere la ricetta
Nel mio viene calcolato l'avanzamento in millimetri al minuto, avendo passo vite e step motore, nel tuo programma modificato metti un tempo di pausa col potenziometro.

A volte il programma non funziona per via della parte elettronica e dei collegamenti ad esempio se abbiamo un selettore, e il pin è in PULLUP, dovremmo collegare il selettore da una parte a massa per dare il valore LOW, nell'altra posizione del selettore non deve esserci nessun collegamento, cosi avremo se il selettore da massa sul pin leggeremo LOW, se il selettore è posizionato dove non ci sono collegamenti il pin resta HIGH e leggeremo tale valore.
sarebbe utile un disegnino anche a matita di come colleghi i pulsanti, selettore e finecorsa, perché potrebbe essere li il problema.
Per semplificare le cose il programma è pensato a pin in PULLUP, vuol dire che i pin normalmente sono allo stato HIGH, per leggere un segnale sul pin dobbiamo collegarlo a massa e leggeremo LOW questo semplifica le cose perché nel circuito non occorrono resistenze, basta che un pulsante o un finecorsa quando premuto colleghi a massa il pin.

la modifica di hellfire39 evita la divisione per zero, perché controlla che il valore del potenziometro sia superiore a 10, nel codice sono rimasti il codice colore if([color ... che vanno tolti.

[torn24]

Allora propongo!
Visto che i collegamenti sono pochi, un disegnino a matita di come sono collegati pulsanti e finecorsa, foto con telefonino e posti la foto.

Per quanto riguarda fermare il motore sarebbe più sensato che col potenziometro regoliamo l'avanzamento, ma pensare a un pulsante di star e uno di stop. Per evitare che accendo il tornio questo parta immediatamente, e fermarlo quando vogliamo.

Purtroppo se si lavora a distanza chi riceve informazioni deve saperle interpretare nel modo corretto per agire nel modo giusto, un po come assistenza telefonica, chi chiede aiuto deve avere un minimo di nozioni altrimenti la cosa diventa impossibile, se ad esempio dico per telefono regola il pressostato di un compressione chi ascolta deve sapere cosé il pressostato

[hellfire39]

In realtà i programmi non sono così diversi tra loro.
In un caso si utilizza il valore analogico per calcolare il ritardo, in microsecondi, tra un passo e l'altro.
Nel secondo caso si utilizza il valore analogico per calcolare la velocità lineare e convertirla nel ritardo, in millisecondi.
Peccato che poi non funziona al di sopra di una certa velcoità

Forse, è più corretto utilizzare i microsecondi, perché, con i millisecondi, hai, al massimo

500 passi/s = 2,5 giri/s = 150 rpm = 150*5= 750 mm/min, ipotizzando vite passo 5 e passi interi, figurati se si mettono micropassi assurdi, tipo 3200...

Se andassi oltre, avresti un valore minore di 1 che verrebbe approssimato a 0 in delay. Di fatto non hai pausa e non vedrai mai l'impulso del passo.

Di contro, anche se si fa il calcolo in microsecondi, il calcolo sarà ancor più sbagliato perché non tiene conto dei ritardi introdotti dal resto del codice, che non sono trascurabili.

In questo caso, la funzione map è sostanzialmente inutile. Introduce un certo ritardo e chissenefrega se alla fine il fondoscala è di 1024mm/min invece che 1000mm/min.
In questo caso si sarebbe potuto evitare tranquillamente.

Anche i calcoli in virgola mobile sono abbastanza pesanti e, quando intervengono, ritardano non poco il codice.
Non pensare che, se il potenziometro è fermo, il valore sarà lo stesso. Molto probabilmente oscillerà almeno tra due cifre consecutive, di fatto facendo eseguire il codice di calcolo anche quando non si vorrebbe.
Per evitare questo si può agire innanzitutto elettricamente con un piccolo condensatore, ma soprattutto, rinunciando a parte della risoluzione (ad es dividendo per 4 il valore letto: temp >>= 2)

Inoltre, utilizzare delay() non è una buona pratica di programmazione, perché blocca il codice e previene , ad esempio, l'utilizzo di altri pulsanti per fare altre azioni in maniera asincrona. Questo è uno dei motivi per cui avevo consigliato di utilizzare una libreria tipo AccelStepper che non è bloccante.

P.S. confermo la necessità di partire da un disegnino con i collegamenti.