ElectroYou

Buongiorno a tutti, sto dando una mano a costruire un modellino in scala di una siviera dove dovremmo mettere un motore passo passo, ma non so come dimensionarlo.

Idealmente l'oggetto finito rassomiglia a:



il motorino serve per dare il senso di svuotamento, si pensava ad un movimento di circa 70/80°.
E' previsto un riduttore 60:1 a vite senza fine, per cui il motore dovrebbe fare una decina di giri in un senso, una pausa, e il ritorno. Il tempo di ciclo potrebbe anche essere lungo un minuto o più, non c'è bisogno di velocità.
Non avendo fretta posso aspettare che la parte meccanica venga assemblata e fare delle misure, però volevo portarmi avanti e stimare grossolanamente una taglia verosimile.

Come mi consigliate di procedere?

Perché usare un riduttore a vite senza fine? Se il motore lo monti all'interno del crogiolo (*) in asse con il supporto e il crogiolo lo fai ben equilibrato, forse non ti serve neppure il riduttore o, al limite, usi un riduttore assiale. Prevedi comunque i finecorsa, sono necessari per l'avvio.

(*) Se è un modellino non credo ci sia metallo fuso all'interno...

Ciao,
non avendo una idea delle dimensioni, pesi, coppie che il motore deve erogare è impossibile dimensionare lo stepper. Sai dare qualche indicazione?

Immagino che il riduttore a vite senza fine di rapporto 1:60 l'hai scelto per avere l'irreversibilità del moto. E' corretto?

Hai un po di dati sul riduttore? Anche per capire che rendimento ha

Un servo?

Grazie a tutti per le risposte,

il motore e il riduttore sono montati come sarebbe sull'originale, riproduzione abbastanza fedele...
non è un mio progetto, e non ho voce in capitolo, se non per la parte elettrica, dove sto dando una mano.
il riduttore è usato sia per la riduzione che per "ruotare l'asse di 90°" (non mi viene in mente il termine giusto).
Il riduttore se lo sono fatto in casa, riproduzione fedele di una nota marca commerciale.

No, non c'è metallo fuso, ma la fanno di metallo pari all'originale, per cui come peso, a spanne tra arco e siviera, dovremmo essere attorno ai 20/30kg, da sola la siviera è alta circa 80 cm (siamo in scala 1:5 o 1:6).

Dalle vostre risposte e considerazioni credo che a questo punto sia più saggio aspettare che finiscano di montare il tutto e poi eseguire alcune misure magari con una chiave dinamometrica o avete qulcos'altro da consigliare?

Non sapendo quanto è il passo della vite, non si possono fare i calcoli.

A 'naso', e sempre non ci siano attriti eccessivi dovuti a una realizzazione grossolana, la coppia necessaria dovrebbe essere minima.

Esiste un modello 3D nella parte? Se ci fosse sarebbe tutto più semplice.

Ho provato a chiedere ma no, non hanno fatto modelli 3d, hanno fatto tutto carta e penna.
In tanto stanno procedendo, appena mi presentano l'oggetto montato vedo di fare un po di foto

Senza liquido, non vedo così difficile fare due conti su quanto sia sbilanciata la siviera, nel caso peggiore...
Si tratterebbe di stimare la posizione del baricentro.

EDIT: Aggiornamento scritto in vari giorni e riprese...

Finalmente sono riuscito a farmi dare un disegnino della siviera che via via sta venendo realizzata, BRUTALMENTE col paint ci ho disegnato sopra quella cosa color rosso-nera che dovrebbe essere il motore e quella riga marrone è la cinghia che collega il motore al riduttore, in ogni caso in "settimana" dovrei avere qui da me il tutto assemblato.



Sebbene non siano indicate in questo disegno, in realtà poi la siviera non verrà appesa ma ci saranno 4 gambe sarà un piedistallo.

La parte di recipiente, anche se non è ancora stata ultimata nelle lavorazioni, prendendola in mano per i perni e facendola ribaltare, si dimostra ben bilanciata, resta alla posizione che la metti senza fare grossi sforzi, oltre quello di sopportare il peso stesso.

Mentre aspettavo "i meccanici", che 2 mesi fa' mi avevano detto "in settimana ci siamo...", mi è arrivato per le mani un potenziometro di precisione con una porzione rovinata in decenni di lavoro, che però montandolo adeguatamente, considerando i pochi gradi di movimento che servono qui, si riesce a riciclare.

Da qui nasce l'idea di abbandonare il motore passo passo, per passare ad un motore tradizionale. Il problema persiste per il dimensionamento, non vorrei fargli mettere un motore sbagliato.
Ora come ora per le mie prove ora sto usando "in mano" un motoriduttore recuperato qualche decennio fa, per verificare i movimenti.

Velocemente ho buttato giù uno schemino dei collegamenti ed un paio di righe di codice.
Vista la semplicità ho optato per non diventare troppo matto e realizzare su millefori con l'aiuto di un arduino pro mini che già girava per casa.

Il circuito risultante è


Il codice seguente è per arduino, ho aggiunto qualche commento.
Brevemente: I pulsanti P1-P2-P3 servono per fare ruotare la siviera in senso orario; antiorario; salvare posizione esclusivamente quando si è nel programma di azzeramento.
Il potenziometro su A0 è fissato in asse con la siviera, mentre quello si A1 serve per regolare la velocità massima.

Codice: Seleziona tutto

//includo librerie per eemprom 
//serve per salvare le 2 posizioni che a noi servono
#include <EEPROM.h>

// definizione I/O
// assegno dei nomi familiari ai vari piedini 
int startCiclo = 4;
int stopCiclo = 5;
int uscitaPWM = 6;
int releInversione = 7;
int pinLed = 13;
int pinPosizione = A0;
int pinPulsanti = A2;
int pinVelocita = A1;

// posizioni
// i valori sono compresi tra 0 e 1024 
// minima e massima servono per limitare l'escursione, nel mio caso per eludere una porzione danneggiata
int positionMinima=200;
int positionMassima=824;
int position0=400;  //posizione 0 di default
int position1=700;  //posizione 1 di default
int currentPosition; //conterrà il valore analogico della posizione effettiva letta ad ogni ciclo
int ptr;    //conterrà il numero della Posizione da Raggiungere

// varie
bool isrunning=false;
bool firstRun=true;
int verso0;
int verso1;
int distance0;
int distance1;
int speed4;

// scomposizione da 1 valore decimale a 2 binari per salvataggio in EEPROM
unsigned int decToBin;
unsigned int nalto;
unsigned int nbasso;


void setup() {

//imposto Pin in ingressi e uscite
pinMode(startCiclo, INPUT_PULLUP);
pinMode(stopCiclo, INPUT_PULLUP);
pinMode(releInversione, OUTPUT);
pinMode(pinLed, OUTPUT);
delay(100);

//leggo i pulsanti di startCiclo e stopCiclo
int valP5=digitalRead(startCiclo);
int valP6=digitalRead(stopCiclo);

//se all'accensione entrambi sono LOW, quindi premuti
if(valP5==LOW && valP6==LOW){
    //eseguo il programma azzeramento();
    azzeramento();
}

//forzo ad essere diseccitato il rele
digitalWrite(releInversione, LOW);
delay(200);

//leggo posizioni eeprom N°: 0 5 10 15 20
int eer0=EEPROM.read(0);    //controllo
int eer1=EEPROM.read(5);    //Low byte
int eer2=EEPROM.read(10);    //High byte
int eer3=EEPROM.read(15);    //low byte
int eer4=EEPROM.read(20);    //hi byte

//se eer0 è impostata a 1 = azzeramento già eseguito 
//altrimenti uso i default dichiarati sopra
if(eer0 == 1){
    //ricompongo il valore decimale "ri-unendo" i due byte 
    position0= eer1 | ( eer2 << 8 );
    position1= eer3 | ( eer4 << 8 );
    }
}//end setup

void loop() {
//leggo posizione attuale, stato P5 e P6
  currentPosition = analogRead(pinPosizione);
  int valP5=digitalRead(startCiclo);
  int valP6=digitalRead(stopCiclo);
  if(valP5==LOW){
    isrunning=true;
  }
  if(valP6==LOW){
    isrunning=false;
  }

//trovo verso e distanza per raggioungere il punto 0 ed il punto 1
  verso0 = position0 - currentPosition;
  verso1 = position1 - currentPosition;
  distance0=abs(verso0);
  distance1=abs(verso1);
  
  if (isrunning==true){ //se start è stato premuto
     //per prima cosa porta la siviera a P0 a prescindere da dove fosse stata fermata
    if (firstRun==true){
        if ( verso0 > 0) {digitalWrite(releInversione, LOW);}
        if (verso0 < 0) {digitalWrite(releInversione, HIGH);}
        
        //Velocità
        int speed1 = analogRead(pinVelocita);
        int speed2 = map(speed1, 0, 1024, 0, 127);
        int speed3 = 127;
        //rampa di frenata da modificare in base al motore
        if ( distance0 < 50 ){speed4=map(distance0, 0, 50, 20, 127);}
        else {speed4 = speed3 + speed2;}

        //movimento effettivo
        if ( distance0 !=0){analogWrite(uscitaPWM,speed4);}
        else {analogWrite(uscitaPWM,0);
               //all'arrivo in posizione lampeggio il led onboar 5 volte
               //le prossime 5 righe possono essere eliminate se non neccesario led
               for(int i=0; i<5; i++){
                  digitalWrite(13, HIGH);
                  delay(500);
                  digitalWrite(13, LOW);
                  delay(500);}
              firstRun=false;
              ptr=1;
             }
     }//firstrun
     else{//se non è firstRun, 
        if(ptr==1){ //se posizione da raggiungere =1
          if ( verso1 > 0) {digitalWrite(releInversione, LOW);}
          if (verso1 < 0) {digitalWrite(releInversione, HIGH);}       
          //Velocità
          int speed1 = analogRead(pinVelocita);
          int speed2 = map(speed1, 0, 1024, 0, 127);
          int speed3 = 127;
          //rampa di frenata
          if ( distance1 < 50 ){speed4=map(distance1, 0, 50, 20, 127);}
          else {speed4 = speed3 + speed2;}
          //movimento effettivo
          if ( distance1 !=0){analogWrite(uscitaPWM,speed4);
          } else {analogWrite(uscitaPWM,0);
            for(int i=0; i<3; i++){
                digitalWrite(13, HIGH);
                delay(250);
                digitalWrite(13, LOW);
                delay(250);
                ptr=0;
            }
          }
        }//fine ptr=1
        if(ptr==0){
          //verso0 = position0 - currentPosition;
        if ( verso0 > 0) {digitalWrite(releInversione, LOW);}
        if (verso0 < 0) {digitalWrite(releInversione, HIGH);}
        
        //Velocità
        int speed1 = analogRead(pinVelocita);
        int speed2 = map(speed1, 0, 1024, 0, 127);
        int speed3 = 127;
        //rampa di frenata
        if ( distance0 < 50 ){speed4=map(distance0, 0, 50, 20, 127);}
        else {speed4 = speed3 + speed2;}

        //movimento effettivo
        if ( distance0 !=0){analogWrite(uscitaPWM,speed4);}
        else {analogWrite(uscitaPWM,0);
              for(int i=0; i<5; i++){
                digitalWrite(13, HIGH);
                delay(500);
                digitalWrite(13, LOW);
                delay(500);}
              firstRun=false;
              ptr=1;}
        }//fine ptr0
     }//fine else firstrun
   }// fine isrunning
  else{ //se quindi sono in Stop
        analogWrite(uscitaPWM,0);//fermo il PWM
        }//fine else isrunning
}//fine loop

void azzeramento(){
int a=0;
  while(a<3){
    //Velocità
    int speed1 = analogRead(pinVelocita);
    int speed2 = map(speed1, 0, 1024, 0, 127);
    int speed3 = 127 + speed2;
    
    int pulsanteN=letturaPulsanti();
    delay(1);
    int currentPosition = analogRead(pinPosizione);
    switch(pulsanteN){
     case 0:
     //nessun pulsante premuto
     //imposto velocità motore a 0
     analogWrite(uscitaPWM,0);
     break;
     
     case 1:
     //pulsante 1 movimento senso orario
     //imposto relè su spento
     digitalWrite(releInversione, LOW);
     delay(50);
     //limite per non sconfinare su zona rovinata
     if(currentPosition < positionMassima){
     analogWrite(uscitaPWM, speed3);}
     break;
     
     case 2:
     //pulsante 2 senso Anti orario
     digitalWrite(releInversione, HIGH);
     delay(50);
     //limite per non sconfinare su zona rovinata
     if(currentPosition > positionMinima){
     analogWrite(uscitaPWM, speed3);}
     break;
     
     case 3:
     //pulsante 3 salvataggio in EEPROM posizioni
     if (a==0){//sto salvando posizione0
         decToBin=currentPosition;
         nalto=decToBin >> 8;
         nbasso=decToBin & 0xff;
         EEPROM.update(5, nbasso);    //LOW
         EEPROM.update(10, nalto);    //HIGH
        }
     else if (a==1){//sto salvando posizione1
         decToBin=currentPosition;
         nalto=decToBin >> 8;
         nbasso=decToBin & 0xff;
         EEPROM.update(15, nbasso);    //LOW
         EEPROM.update(20, nalto);    //HIGH
        }
     else if (a==2){EEPROM.update(0, 1);}//imposto a 1 posizione0 
    //lampeggio il led onboard
     delay(200);
     for (int i=0; i<3; i++){
        digitalWrite(13, HIGH);
        delay(200);
        digitalWrite(13, LOW);
        delay(200);
        }
     a++;
     break;
     
     case 4:
     //pulsante 4 - previsto perché con i meccanici non si sa mai che possa servire a qualcosa...
     break;
     }//fine switch
  }//fine while
  }//fine azzeramento

int letturaPulsanti(){
//restituisce un valore da 0 a 4 a seconda del valore analogico letto
int vaip = analogRead(pinPulsanti);
if (vaip > 1000) return 0; // expected 1023 = nessun pulsante premuto
if (vaip < 25) return 1; // expected 0 + 25 for tollerance (pulsante 1)
if (vaip < 202) return 2; // expected 179 + 25 for tollerance (pulsante 2)
if (vaip < 328) return 3; // expected 305 + 25 for tollerance (pulsante 3)
if (vaip < 422) return 4; // expected 398 + 25 for tollerance (pulsante 4)
}

Ma devi controllare il motore in posizione?

In ogni caso, io userei un ponte intero (full-bridge o H-bridge). La soluzione coi relè è molto limitante, oltre ad essere (mia modesta opinione) molto poco "seria".