Consiglio su partenza dolce con stepper e pololu A4988

/*e Guardare la fotocopia e ricordi che, questo Sketch ha 
 * il controllo degli step, ma per la nostra piattaforma mi basta 
 * che si muova di 1/16 
 * di giro in avanti e 1/16 di giri indietro, inserisco anche 
 * un pin con l'attivazione
 * e buonanotte, in modo da avere al massimo 3 Pin impegnati.. Ciau
 */

int DIR = 2; /*Questo è collegato all'accensione creo una variabile 
               che se la riceve lo Slave Attiva la piattaforma
               Questo lo decido con un ponte sul circuito, guarda la
               tabella fotocopia del driver Populo !!! */

int pinOrario = 7; /* L'idea è Pin Direzione, vedi tabella 
                 fotocopia, Pin Rotazione in un senso, terzo 
                 pin senso contrario di rotazione :D */
int pinAntiorario = 8;
int pinON_Pop = 4; /*Ho inserito l'accensione del driver perchè 
                   non ne potevo più è collegato sul pin Enable del 
                   driver Populo A4988 */
int STEP = 3;

void setup() {
  
pinMode(DIR, OUTPUT);
pinMode(pinON_Pop, OUTPUT);
pinMode( pinOrario,INPUT );
pinMode( pinAntiorario,INPUT );
}
void loop()
{
   
 
    digitalWrite(DIR,HIGH);
    digitalWrite(pinON_Pop, HIGH);
    delay(50);
 
    if ( digitalRead( pinOrario ) == HIGH ) {
    for ( int i=0; i<50; i++) { stepGo(); delay(10); 
    delay(50);
    digitalWrite(pinON_Pop, LOW);}
        
    }
    digitalWrite(DIR,LOW);
    digitalWrite(pinON_Pop, HIGH);
    delay(50);
    
    if ( digitalRead( pinAntiorario ) == HIGH ) {
    for ( int i=0; i<50; i++) { stepGo(); delay(10);
    delay(50);
    digitalWrite(pinON_Pop, LOW);}
    }
}
 void stepGo() {
        digitalWrite(STEP, HIGH);
        delayMicroseconds(100);  // Non conoscendo come funziona bene il 
        digitalWrite(STEP, LOW);// driver populo, non modifico questo 
        delayMicroseconds(100); // parametro 
 }

 /* risultato scopiazzante, ma sto pian piano prendendo confidenza con
  *  L'alfArduino anche se mi perdo con la matematica...
  *  Lo sketch funziona benone ma dovrò passare alla meccanica per 
  *  togliere gli strattoni che dà a ogni impulso il motore stepper...
  *  forse lo riduco con una puleggia e una ginghia in gomma..
  *  Alla Prossima Marco.
  */

Ciao a tutti, sto realizzando un plastico ferroviario in garage e pian piano stò affrontando i vari problemi, ho realizzato questo sketch che funziona "secondo me " :sunglasses: bene, solo che avendo bisogno di usarlo a 1/4 di giro è molto scattoso anche se quello che cercavo era la precisione dello stepper... Esiste una soluzione software? Ho trovato rampe di accellerazione per altri driver ma non per il populo... Se non esiste la possibilità metterò un riduttore meccanico pignone/corona + cinghia di gomma.

Lo skech ha collegato 2 pulsanti per la rotazione oraria e antioraria, in più ho aggiunto un pin che attiva e disattiva la scheda, perchè fà un fischio che pure il gatto esce dalla stanza! :rofl:

Grazie Marco

Beh intanto mi sfugge il motivo di mettere due delay consecutivi, uno da 10 ed uno da 50, invece di uno solo. Inoltre ti consiglio di abituarti ad indentare meglio, ma per ora ti basta premere Ctrl-T all'interno dell'IDE e te lo fa lui.

A parte questo, comunque se con stepGo() fai fare uno step e vuoi avere una "rampa" credo possa bastarti usare dei delay maggiori all'inizio della sequenza di movimento per distanziare maggiormente i singoli step. Tu così come vedo nello sketch fai uno step ogni 60 ms, quindi circa 16 al secondo: se per i primi "x" secondi li distanziassi secondo un valore inizialmente maggiore usando un delay aggiuntivo che decresce come valore potresti ottenere forse l'effetto che cerchi.

Per dire, se vuoi una "rampa" nei primi 600 ms quindi per i primi 10 cicli (i<10), per distanziare gli step da 100 a 60 ms potresti aggiungere un delay(40-i*4) (per i=0 sarà 40, per i=1 sarà 36, e così via fino ad escluderlo quando i>=10).

Ovviamente non sapendo bene come tu voglia implementare l'uso dei pulsanti devi vedere tu come inserire questa logica nel tuo codice.

PS: a parte il latino, ma che è un "populo"?:wink:

... credo un bel refuso ... probabilmente parlava dei diver della Pololu :wink:

Guglielmo

/*e Guardare la fotocopia e ricordi che, questo Sketch ha 
 * il controllo degli step, ma per la nostra piattaforma mi basta 
 * che si muova di 1/16 
 * di giro in avanti e 1/16 di giri indietro, inserisco anche 
 * un pin con l'attivazione
 * e buonanotte, in modo da avere al massimo 3 Pin impegnati.. Ciau
 */
 #include <SoftwareSerial.h>
 SoftwareSerial rs485(12,13); // 12 "RD" pin della Ricezione e 13"DI" Tx
  
int DIR = 2; /*Questo è collegato all'accensione creo una variabile 
               che se la riceve lo Slave Attiva la piattaforma
               Questo lo decido con un ponte sul circuito, guarda la
               tabella fotocopia del driver Populo !!! */

int h; /* L'idea è Pin Direzione, vedi tabella 
                 fotocopia, Pin Rotazione in un senso, terzo 
                 pin senso contrario di rotazione :D */
int j; //riceve dal master la lettera 'j' e inverte il senso
int pinON_Pop = 4; /*Ho inserito l'accensione del driver perchè 
                   non ne potevo più è collegato sul pin Enable del 
                   driver Populo A4988 */
int STEP = 3;

void setup() {

pinMode(11, OUTPUT);//Parte RS 485 anche se è un trasmettitore mette Uscita
digitalWrite(11,LOW); //LOW perchè deve ricevere
rs485.begin(4800);  

pinMode(DIR, OUTPUT); //Parte Stepper Populo 
pinMode(pinON_Pop, OUTPUT);
pinMode( j,INPUT );
pinMode( h,INPUT );
}
void loop()
{
   
    if (rs485.available()) {  // significa processa i dati in arrivo!!!!
    byte h =rs485.read();
    if ( digitalRead( h=='h' ) == HIGH ) {
    digitalWrite(pinON_Pop, HIGH);
    digitalWrite(DIR,HIGH);              // Ruota in un 'Senso' 
    for ( int i=0; i<50; i++) { 
    delay(50);
    digitalWrite(STEP, HIGH);
    delayMicroseconds(100);  // Non conoscendo come funziona bene il 
    digitalWrite(STEP, LOW);// driver populo, non modifico questo 
    delayMicroseconds(100); // parametro 
    
    digitalWrite(pinON_Pop, LOW);}
        
    }}
    
    if (rs485.available()) {  // significa processa i dati in arrivo!!!!
    byte j =rs485.read();
    if ( digitalRead( j=='j' ) == HIGH ) {
    digitalWrite(pinON_Pop, HIGH);
    digitalWrite(DIR,LOW);            // Ruota in un 'Senso Opposto'
    for ( int i=0; i<50; i++) { 
    delay(50);
    digitalWrite(STEP, HIGH);
    delayMicroseconds(100);  // Non conoscendo come funziona bene il 
    digitalWrite(STEP, LOW);// driver populo, non modifico questo 
    delayMicroseconds(100); // parametro 
    digitalWrite(pinON_Pop, LOW);}
    }
}}
/*void stepGo() {
        digitalWrite(STEP, HIGH);
        delayMicroseconds(100);  // Non conoscendo come funziona bene il 
        digitalWrite(STEP, LOW);// driver populo, non modifico questo 
        delayMicroseconds(100); // parametro 
 }

 /* risultato scopiazzante, ma sto pian piano prendendo confidenza con
  *  L'alfArduino anche se mi perdo con la matematica...
  *  Lo sketch funziona benone ma dovrò passare alla meccanica per 
  *  togliere gli strattoni che dà a ogni impulso il motore stepper...
  *  forse lo riduco con una puleggia e una ginghia in gomma..
  *  Alla Prossima Marco.
  */

Rieccomi, ho fatto un pò di ordine, perchè per ora non riesco ancora a scrivere tutto di mio... Io per il momento lavoro ( anche se è una parola grossa) così:

Scopiazzo, guardo come si comporta uno sketch, mi vado a leggere gli appunti e i libri, ( P.S. il Libro di Leonardo Miliani è fantastico!) e per il duro sforzo, mi si incrociano gli occhi :scream: . Ad esempio, stavo infamando l'arduino che avevo comprato invece avevo messo dei cavi al contrario ( ma per me è nosmale amministrazione)....

Eh, accidenti ho scritto male il nome Pololu ... E il Lupo Ulula lì?!? :rofl:

Ora che ho riscritto tutto mi decripto il consiglio di docdoc.

Grazie molto gentili, Marco.

P.S. Mai comprare breadbord economiche rischiano di fati diventare matto! Le ho cestinate.

Ci sono un po di cose senza senso, sbagli dei concetti elementari.

Con digitalRead(pin), devi mettere solo il nome del pin, non puoi mettere altro.
Se leggi un carattere da seriale devi confrontare i caratteri.
Se invece ti servono due condizioni, esempio, il carattere è uguale a h e il pin è HIGH, usi && nella condizione if()

ESEMPIO

byte j =rs485.read();
    if ( digitalRead( j=='j' ) == HIGH ) { // questo non ha senso
forse una cosa del genere
   if(digitalRead(pin)==HIGH && j=='j')// Se il pin è HIGH e il carattere è j

Ciao torn24, avevo trovato una spiegazione sul web, che mi spiegava che con l'istruzione
" if digitalRead() == HIGHT" diceva che così scritto "spiegava l'autore" che qualsiasi segnale che leggeva da seriale lo skecth eseguiva il comando... Io volevo un comando più selettivo e ho inserito ( j=='J') anche perchè come Master utilizzerò Arduino mega con un sacco di pulsanti e non vorrei far confuzione quindi ho utilizzato i caratteri alfanumerici che mi sono più familiari... Ora studierò meglio le funzioni boleane.

Saluti Marco

/* Slave Piattaforma girevole:
 *  è composta da Arduino UNO e un DRiver PololuA4988 e a sua volta 
 *  uno stepper trovato dentro una stampante... L'idea è che il master 
 *  invia una lettera 'h' e gira in un senso e se riceve una lettera    
 *  'j' gira in un senso opposto, magari con una piccola rampa di accelerazione 
 *  per non lanciarmi per terra la Locomotiva (perchè stò facendo un plastico 
 *  ferroviario)... Ho aggiunto un pin che attiva il driver perchè 1 mi 
 *  serve per fare il debug e 2 fischia e mi sveglia la famiglia che se 
 *  la dorme ( i miei esperimenti sono notturni).
 */


#include <SoftwareSerial.h>
SoftwareSerial rs485(12,13); // 12 "RD" pin della Ricezione e 13"DI" Tx
                             // modulo rs485 Max
const int stepPin = 3;
const int dirPin = 2;
const int stepForRevolution = 100;
const int coeffSpeedLOW = 10000; // se metto un incremento matematico mi costruisco una rampa
const int PinPoW = 4;

const int h; //Comando per Slave Piattaforma gira in un senso
const int j; //Comando per invertire il senso di rotazione


void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  pinMode(PinPoW, OUTPUT);

Serial.begin(9600); //seriale a monitor
rs485.begin(4800);
pinMode(11, OUTPUT);//anche se è un trasmettitore mette Uscita
digitalWrite(11,LOW);// LOW = ricezione dati e HIGH = trasmissione dati


}
//byte stato = LOW; // trasmette alla ricevente uno stato che sarò un singolo valore bite 
  

void loop() {
  digitalWrite(PinPoW, HIGH); //Silenzia Pololu
  if (rs485.available());  // significa processa i dati in arrivo!!!!
  byte h =rs485.read();
  if(h=='h') {
  
  digitalWrite(PinPoW, LOW); //Attiva il Pololu
  
  digitalWrite(dirPin, HIGH); //Motore in direzione oraria
  for (int x = 0; x < 1 * stepForRevolution; x++){  // // "n" giri veloci in avanti
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(coeffSpeedLOW);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(coeffSpeedLOW);
  digitalWrite(dirPin, HIGH);
  }
  digitalWrite(PinPoW, HIGH); //Silenzia Pololu
  }
  if (rs485.available());  // significa processa i dati in arrivo!!!!
  byte j =rs485.read();
  if(j=='j') {
  
  digitalWrite(PinPoW, LOW);
  
  digitalWrite(dirPin, LOW); //Motore in direzione antioraria
  for (int x = 0; x < 1 * stepForRevolution; x++){  // "n" giri lenti nell'altra direzione
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(coeffSpeedLOW);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(coeffSpeedLOW);
  digitalWrite(dirPin, LOW);
  }
  digitalWrite(PinPoW, HIGH);
  }}

Ciao a tutti, dopo aver studiato e non aver ancora la certezza dell'uso delle parentesi graffe... Non sò perchè ma mi si "ingrippa il cervello"... Sono riuscito ad ottenere uno Slave con Arduino Uno con il controllo della piattafora girevole, ho impostato il polulo con la modalità 1/16 al premere del tasto X gira di circa 12,5 Gradi in un senso e premendo il tasto Y nel senso contrario... Non vado a stuzzicare di più il moto scattoso in modalità software, ma mi divertirò con l' Hardware. :rofl: :joy:

Lo pubblico così se qualcuno vuole farsi venire mal di testa ha una traccia per partire. :stuck_out_tongue_winking_eye:

Il progetto è composto da: Mega come master e più slave che controllano i servizi di un piccolo plastico ferromodellistico. Insomma se lo osserva un plasticista gli viene mal di pancia e un
programmatore mal di testa! HAhahah!

Saluti Marco

Beh la soluzione per questa cosa esiste ed è dentro di te... ehm, ce l'hai sotto alle dita: nell'IDE premi i tasti Ctrl-T, vedrai che il codice diventa molto più semplice da capire "ad occhio" perché ti fa l'indentazione "buona" (e da quel momento abituati a scrivere usando quel tipo di indentazione, perché ottimale e soprattutto "standard" :wink: ).

Se provi a fare come ti ha suggerito @docdoc dovresti accorgerti che il
if (rs485.available())
così non fa quello che ti aspetti. Il codice "funziona" comunque, ma diciamo che funziona per culo...
Il ; a fine riga nell'if "chiude" subito quell'if e quindi è come se tutta la riga non ci fosse.

  if (rs485.available())  // significa processa i dati in arrivo!!!!
    byte j = rs485.read();
  if (j == 'j') {

Ciao fratt,
secondo il mio modo di pensare così dovevo scriverlo, peccato che non funziona... Vi giuro che ho lasciato perdere per qualche giorno perchè sono andato in crisi... E da queste parti ...[ c'è molta crisi! ...E tu come la vedi?].
Come su tutti i libri vari che ho mi sembrava la logica giusta, ma alla fine con la libreria molto personale "Culo" mi funziona! :rofl: :joy:

Saluti Marco

Il metodo available() ti restituisce il numero dei byte che sono presenti nel buffer di ricezione (e che quindi puoi leggere con read()).

In questo modo ti funziona solo perché leggi un byte per volta e read() se non c'è nulla nel buffer ti restituisce -1 e di conseguenza l'if è sempre falso tranne quando ricevi 'h'.
Di fatto cosi la prima riga del blocco che ho quotato è inutile e se la elimini funziona esattamente nello stesso modo.

Appena avrai necessità di leggere più di un byte, ovviamente la magia sparisce.

Prova ad aprire una graffa dopo l'if available in modo che la read e l'altro if siano dentro il primo if.
Poi la chiudi prima del secondo if available.

Eh certo, perché la variabile "j" viene creata dentro alla if e poi distrutta all'uscita. Tu poi hai un'altra variabile "j" definita globalmente che quindi è quella che "vede" la seconda if
Peraltro questa variabile globale (ma anche altre) la definisci costante, il che non ha alcun senso.
Per cui se devono essere variabili TOGLI il "const" nella definizione, e se vuoi usare variabili "locali" ad una funzione evita di chiamarle esattamente come quelle globali.

Rieccomi,

secondo la mia mente distorta, lo slave dovrebbe ragionare così, accendi la seriale 485, se leggi il carattere 'h' , fai quello che dico e se ricevi il carattere 't' fai altro, se non ricevi nulla non fare nulla...
Ho provato in tutti i modi ma... Il computer non mi capisce! :rofl: Sono disperato! :sob:
Sto leggendo l'ultimo libro e sono fermo all'uso delle parentesi, pensavo di aver fatto mio l'uso della punteggiatura ma non è così :slightly_frowning_face:

Continuo a studiare, tanto per il momento funziona!
e tipo cosi?

  if (rs485.available()) { // significa processa i dati in arrivo!!!!
    rs485.read()==('h') ;

Io la interpreto come: se la lettura è uguale al caratere 'h' esegui le istruzioni seguenti...

P.S. Non vale insultare c'ho un età io... :sunglasses:

Marco

Purtroppo il compilatore C++ la interpreta diversamente... :wink:

if (rs485.available())  // Ci sono dei dati pronti per essere letti
{ 
    if (rs485.read() == 'h')    // Se il carattere è 'h', esegui il blocco tra parentesi
   {
        // blocco istruzioni condizionato dal costrutto if
        fai_quello_che_dico;
        
   }   // fine primo if annidato

   else if (rs485.read() == 't')    // Se il carattere è 't', esegui il blocco tra parentesi
   {
        // blocco istruzioni condizionato dal costrutto if
        fai_altro_per_favore;
        
   }   // fine secondo if annidato
}  // fine primo if

Ehm, no, in quel modo "butta via" il carattere ricevuto se non è 'h'...:wink:
Meglio una cosa del genere direi, anche più facile da leggere:

if (rs485.available())  // Ci sono dei dati pronti per essere letti
{ 
    // Analizzo il comando
    char cmd = rs485.read();
    switch (cmd) {
      case 'h':
        fai_quello_che_dico;
        break;

      case 't':
        fai_altro_per_favore;
        break;

   }   // fine analisi comando
}  // fine primo if

Hai ragione, sarebbe meglio salvare il byte ricevuto in una variabile per poi confrontare la variabile stessa.

Condivido anche la scelta dello switch/case, ma @ArTex mi sembra già abbastanza in difficoltà con gli if :laughing: :laughing:

Direi altomare....

Quando penso di aver appreso qualcosa mi ritrovo a non aver capito un "h" come dice "Balasso"...
Le parolaccce le dice lui per me!

In effetti con lo switch/case me l'ero cavata bene con l'esercizio usa un "shift register"? Si chiamava così il chip? :scream:

Il problema che sto litigando con la seriale e vassapere come si ingrippano i miei pensieri...

Grazie Marco

/* Slave Piattaforma girevole:
    è composta da Arduino UNO e un DRiver PololuA4988 e a sua volta
    uno stepper trovato dentro una stampante... L'idea è che il master
    invia una lettera 'h' e gira in un senso e se riceve una lettera
    'j' gira in un senso, magari con una piccola rampa di accelerazione
    per non lanciarmila Locomotiva (perchè stò facendo un plastico
    ferroviario)... Ho aggiunto un pin che attiva il driver perchè 1 mi
    serve per fare il debug e 2 fischia e mi sveglia la famiglia che se
    la dorme ( i miei esperimenti sono notturni).
*/

#include <SoftwareSerial.h>
SoftwareSerial rs485(12, 13); // 12 "RD" pin della Ricezione e 13"DI" Tx
// modulo rs485 Max
const int stepPin = 3;
const int dirPin = 2;
const int stepForRevolution = 100;
const int coeffSpeedLOW = 800; /* Questo è un intervallo in millisecondi... La traccia Web era una stupidaggine */
const int PinPoW = 4;

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  pinMode(PinPoW, OUTPUT);

  Serial.begin(9600); //seriale a monitor
  rs485.begin(4800);
  pinMode(11, OUTPUT);//anche se è un trasmettitore mette Uscita
  digitalWrite(11, LOW); // LOW = ricezione dati e HIGH = trasmissione dati
}

void loop() {
  digitalWrite(PinPoW, HIGH); //Silenzia Pololu
  if (rs485.available())
  { // significa processa i dati in arrivo!!!!
    if  (rs485.read() == 'h')
    {
      digitalWrite(PinPoW, LOW); //Attiva il Pololu

      digitalWrite(dirPin, HIGH); //Motore in direzione oraria
      for (int x = 0; x < 1 * stepForRevolution; x++) { // // "n" giri veloci in avanti
        digitalWrite(stepPin, HIGH);
        delayMicroseconds(coeffSpeedLOW);
        digitalWrite(stepPin, LOW);
        delayMicroseconds(coeffSpeedLOW);
        digitalWrite(dirPin, HIGH);
      }
    }
  }


  digitalWrite(PinPoW, HIGH); //Silenzia Pololu

  if (rs485.read() == 'j') {

    digitalWrite(PinPoW, LOW);

    digitalWrite(dirPin, LOW); //Motore in direzione antioraria
    for (int x = 0; x < 1 * stepForRevolution; x++) { // "n" giri lenti nell'altra direzione
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(coeffSpeedLOW);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(coeffSpeedLOW);
      digitalWrite(dirPin, LOW);
    }
  }
  digitalWrite(PinPoW, HIGH);
}

Erieccomi! Così non sò per quale motivo "astrale" funzioni ma funziona... La variabile che mi memorizza il carattere alla fine non mi serve...

P.S. Quando vado in pensione scriverò la mia vita e le parentesi... Son peggio che capire le donne... Senza offesa eh! Io scherzo.

Ditemi che stavolta c'ho imbroccato! :star_struck:

Marco

Mi spiace dirtelo, ma no, non può funzionare correttamente. Poi ti spiego meglio sotto.

Beh se hai un solo comando possibile si, non ti serve. Se invece ne hai più di uno, così come si vede anche in questa versione, invece devi per forza usare una variabile, come ti avevo indicato. E comunque non può funzionare correttamente. Perché? Per prima cosa perché tu qui metti le due "if" con una read() ciascuna, il che significa che se tu mandi il carattere 'h' entra nella prima if() e funziona. Se mandi invece 'j' la prima read() se lo "mangia" e lo scarta perché diverso da 'h', e la seconda read() non riceve 'j' anzi non riceve nulla e quindi non entra nella if() che dovrebbe gestire la 'j'. Tu devi memorizzare ed elaborare il carattere ricevuto, e per farlo in modo più pratico e semplice ti basta usare una switch invece delle if.

Poi hai messo la seconda if() al di fuori del controllo "if (rs485.available())" invece devi includere tutte le letture solamente se available() ti dice che ci sono caratteri nel buffer di ricezione.

Infine un paio di consigli "stilistici". Se quella for che fa girare il motore è identica nei due casi (tranne che per il comando di direzione) mettila in una funzione e richiama quella dentro ai due comandi ricevuti. Questa cosa è sempre opportuna quando vedi che hai parti di codice identico ossia copia/incolla: non solo il codice diventa più leggibile, ma se per caso devi fare qualche correzione non devi ricordarti per forza di farlo ovunque tu hai duplicato quel codice e farlo nell'esatto modo.
Poi come commento a quella for() hai scritto ""n" giri lenti nell'altra direzione" ma in realtà di giri ne fa uno solo ("1 * stepForRevolution"): se la for() la metti in una funzione puoi anche usare un parametro per specificare quanti giri fargli fare.
Infine le costanti è opportuno indicarle sempre con tutte maiuscole: è una convenzione, ma è largamente usata (hai notato che usi già costanti come LOW, HIGH, INPUT, OUTPUT ad esempio?) per distinguere variabili da costanti o simboli non modificabili e rende il codice più comprensibile da tutti. Inoltre meglio definirle non come "const int" ma come "#define" (tra l'altro i pin hanno valori sicuramente inferiori a 100, quindi usare un "int" da 2 byte che va da -32768 a 32767 è inutile, e su piccole MCU risparmiare byte è cosa da abituarsi a non trascurare), e possibilmente mettendoli tutti a inizio sketch così hai subito sott'occhio in unico punto tutta la configrazione.

Vedi questa versione "modificata", e chiedi tranquillamente se qualcosa non la capisci bene, così cerchi di ampliare le tue conoscenze:

/* Slave Piattaforma girevole:
    è composta da Arduino UNO e un DRiver PololuA4988 e a sua volta
    uno stepper trovato dentro una stampante... L'idea è che il master
    invia una lettera 'h' e gira in un senso e se riceve una lettera
    'j' gira in un senso, magari con una piccola rampa di accelerazione
    per non lanciarmila Locomotiva (perchè stò facendo un plastico
    ferroviario)... Ho aggiunto un pin che attiva il driver perchè 1 mi
    serve per fare il debug e 2 fischia e mi sveglia la famiglia che se
    la dorme ( i miei esperimenti sono notturni).
*/
// CONFIGURAZIONE
// modulo rs485 Max
#define P_STEP 3
#define P_DIR 2
#define P_POW 4
// E il pin 11??? E perché non definie pure i pin della Softwareserial?

// Numero di step per giro
#define STEP_X_GIRO 100
// intervallo in millisecondi per la velocità di rotazione
#define SPEED_LOW 800

#include <SoftwareSerial.h>
SoftwareSerial rs485(12, 13); // 12 "RD" pin della Ricezione e 13"DI" Tx

void setup() {
  pinMode(P_STEP, OUTPUT);
  pinMode(P_DIR, OUTPUT);
  pinMode(P_POW, OUTPUT);

  Serial.begin(9600); //seriale a monitor
  rs485.begin(4800);
  pinMode(11, OUTPUT);//anche se è un trasmettitore mette Uscita
  digitalWrite(11, LOW); // LOW = ricezione dati e HIGH = trasmissione dati
  digitalWrite(P_POW, HIGH); //Silenzia Pololu
}

void loop() {
  if (rs485.available())  
  { // Ci sono dei dati pronti per essere letti
    // Analizzo il comando
    char cmd = rs485.read();
    switch (cmd) {
      case 'h':
        digitalWrite(P_POW, LOW);
        digitalWrite(P_DIR, HIGH); //Motore in direzione oraria
        rotazione(1);
        digitalWrite(P_POW, HIGH);
        break;

      case 't':
        digitalWrite(P_POW, LOW);
        digitalWrite(P_DIR, LOW); //Motore in direzione antioraria
        rotazione(1);
        digitalWrite(P_POW, HIGH);
        break;
    }
  }  // fine elaborazione comandi
}

void rotazione(int giri) 
{
  for (int x = 0; x < giri * STEP_X_GIRO; x++) {
    digitalWrite(P_STEP, HIGH);
    delayMicroseconds(SPEED_LOW);
    digitalWrite(P_STEP, LOW);
    delayMicroseconds(SPEED_LOW);
    digitalWrite(P_DIR, LOW);
  }
}

nota bene: ovviamente provala (non l'ho provata, se ci sono errori vedi tu). Poi come puoi vedere, l'uso di costanti/define va fatto per TUTTI i valori di configurazione a partire dai pin (che generalmente indico con prefisso "P_"), ed il pin 11 non lo hai definito, così come i due usati per la SoftwareSerial: lascio a te il compito di definire i corrispondenti simboli con #define ed inserirli nel codice.:wink: