Lo sketch non funziona correttamente

Ciao scusate ma ho un altro problema, quello che segue è lo sketch completo, se commento il codice nei punti che ho chiamato commento 1 e commento 2 lo sketch funziona, tranne ovviamente la parte riguardante il motore deputato alla rotazione della tv, se tolgo i commenti lo sketch non si comporta correttamente i segnali inviati dal telecomando non producono l'azione corretta.
Cercherò di essere più chiaro, io voglio che premendo il tasto1 del telecomando il motore passo passo si azioni portando avanti la tv, che raggiunto il fine corsa aziona un secondo motore che la fa ruotare avanti fino a che tocca un altro finecorsa.
Premendo il tasto 0 volglio che avvenga il contrario, prima la tv deve ruotare per rimettersi in posizione orrizontale e poi toccato un micro deve avviare il motore passo passo per arretrare.

//Inclusione delle librerie necessarie
#include <SoftwareSerial.h>
#include <IRremoteInt.h>

#include <IRremote.h>
//Definizione dei pin
static int pinAcceleratore = A0; //pin analogico deputato a leggere i valori del potenziometro
static int mA = 12; //pin digitale per determinare gli stati logici da inviare al modulo (IN1)
static int mB = 13; //pin digitale per determinare gli stati logici da inviare al modulo (IN2)
//Definisco il senso di marcia del motore
  /*
    mA |   mB  | Evento
  -----|-------|----------------------
  LOW  | LOW   | fermo
  LOW  | HIGH  | Movimento in un senso
  HIGH | LOW   | Movimento senso opposto
  HIGH | HIGH  | Fermo
  */
static int pinPotenza = 11; //pin digitale tramite il quale inviare un segnale di tipo PWM tramite la funzione analgWrite() (ENA)
int accelerazione;  //valore letto dal pin A0
int potenza;  //valore in uscita dal pin 11
int limitswitchPinRotazioneAvantiTV=6; //pin di arduino collegato al segnale S del micro azionato quando la TV ruota avanti
int limitswitchPinRotazioneIndietroTV=5; //pin di arduino collegato al segnale S del micro azionato quando la TV ruota indietro
const int pinDir = 2; //pin di arduino collegato al pin DIR del dirver che comanda il motore passo-passo
const int pinStep = 3; //pin di arduino collegato al pin DIR del dirver che comanda il motore passo-passo
int limitswitchPinTVdentro=8; //pin di arduino collegato al segnale S del micro azionato quando la TV è completamente rientrata
int limitswitchPinTVfuori=7; //pin di arduino collegato al segnale S del micro azionato quando la TV è completamente uscita
const int numStepMotore = 200; //imposto il numero di step per rotazione del motore 
const long velocita = 400; //imposto i microsecondi tra un impulso e l'altro sul pin STEP a 500

int receiver = 10; // pin 1 of IR receiver to Arduino digital pin 11
IRrecv irrecv(receiver); // create instance of 'irrecv'
decode_results results;
void setup()
{
  pinMode(10,OUTPUT); // imposto il pin 10 che riceverà il segnale dal telecomando
  pinMode(limitswitchPinTVdentro,INPUT); //inizializzo il pin a cui è collegato il segnale del micro a TV rientrata
  pinMode(limitswitchPinTVfuori,INPUT); //inizializzo il pin a cui è collegato il segnale del micro a TV uscita
  pinMode(6, INPUT_PULLUP); //inizializzo il pin a cui è collegato il micro rotazione tv avanti
  pinMode(5, INPUT_PULLUP); //inizializzo il pin a cui è collegato il micro rotazione tv indietro
  pinMode(pinStep, OUTPUT); //inizializzo il PIN STEP come OUTPUT
  pinMode(pinDir, OUTPUT); //inizializzo il PIN DIR come OUTPUT
  pinMode(mA, OUTPUT); //inizializzo il PIN mA (IN1)come OUTPUT 
  pinMode(mB, OUTPUT); //inizializzo il PIN mB (IN2)come OUTPUT
  pinMode(pinAcceleratore, INPUT); //inizializzo il PIN A0 come OUTPUT  
  pinMode(pinPotenza, OUTPUT); //inizializzo il PIN 11 come OUTPUT
  digitalWrite(mA, LOW); // imposto come fermo il motore
  digitalWrite(mB, LOW); //             "
  
  Serial.begin(9600); // for serial monitor output
  irrecv.enableIRIn(); // Start the receiver
  pinMode(9, OUTPUT); // Pin 9 output
}
void loop()
{
  int sensorVal = digitalRead(6);
 
  if (irrecv.decode(&results)) // have we received an IR signal?
  {
    Serial.println(results.value, HEX); // display it on serial monitor in hexadecimal
    irrecv.resume();// receive the next value
  }

  if ( results.value == 0xB4B4DC23 ) //se premo il tasto 1 sul telecomando
  {
    while(digitalRead(limitswitchPinTVfuori)==HIGH){
      digitalWrite(9, HIGH); //il LED si accende
      digitalWrite(pinDir, HIGH);
      for (int x = 0; x < numStepMotore; x++ ) {
        digitalWrite(pinStep, HIGH);
        delayMicroseconds(velocita);
        digitalWrite(pinStep, LOW);
        delayMicroseconds(velocita);
        }
    }
    
  /* commento1
if(sensorVal == HIGH){
    accelerazione = analogRead(pinAcceleratore);
    potenza = map(accelerazione, 0, 1024, 0, 255);
    digitalWrite(mA, LOW);
    digitalWrite(mB, HIGH);
    analogWrite(pinPotenza, potenza);
    }*/
  }
  if ( results.value == 0xB4B422DD ) //se premo il tasto 0 sul telecomando
  {
    /*commento2
while(digitalRead(limitswitchPinRotazioneIndietroTV)==HIGH){
      digitalWrite(mA, HIGH);
      digitalWrite(mB, LOW);
      }*/
      while(digitalRead(limitswitchPinTVdentro)==HIGH){
        digitalWrite(9, LOW);
        digitalWrite(pinDir, LOW);
        for (int x = 0; x < numStepMotore; x++ ) {
          digitalWrite(pinStep, HIGH);
          delayMicroseconds(velocita);
          digitalWrite(pinStep, LOW);
          delayMicroseconds(velocita);
      }
      }
  }
}

Alcuni dubbi:
limitswitchPinTVfuori è il fine corsa che dovrebbe arrestare kla fuoriuscita della tv prima dell'inizio della rotazione?
sensorVal è il finecorsa della rotazione della tv quando si apre, ovvero deve fineché HIGH la tv deve ruotare?
Quindi il motore stepper dovrebbe girare in un senso finché limitswitchPinTVfuori è HIGH? Dopodiché dovrebbe partire quella parte legata a pinPotenza?

Alcune cosa da migliorare, all'inzio definisci i pin con delle variabili, essendo i pin immutabili durante l'esecuzione del rpogramma definiscili const e puoi tranquillamenta passare da int a byte. Inoltre dopo aver definito alcuni pin con delle variabili poi non le usi e fai

digitalRead(6);

dovrebbe essere

digitalRead(limitswitchPinRotazioneAvantiTV);

seguendo le tue variabili, non è che è quello a non far funzionare il programma ma è sempre buona cosa non usare direttamente il numero ma una const o una define, tu l'hai fatto a metà definisci ma non usi.

    /*commento2
while(digitalRead(limitswitchPinRotazioneIndietroTV)==HIGH){
      digitalWrite(mA, HIGH);
      digitalWrite(mB, LOW);
      }*/

Qui dici di aspettare all'infinito finchè non hai digitalRead(limitswitchPinRotazioneIndietroTV)==HIGH
e mentre aspetti, ad ogni giro, metti
digitalWrite(mA, HIGH);
digitalWrite(mB, LOW);
che impostati la prima volta restano quindi invariati.
Se vuoi far muovere il motore devi metterci quantomeno l'intera sequenza per farlo muovere di un intero passo, così ad ogni iterazione si muove di un intero passo, altrimenti fa il primo scattino e poi resta piantato li per sempre.

E' il solo pezzo di codice che ho letto perchè mi è caduto subito l'occhio su questa cosa.
Ti torna come comportamento, quello che ho descritto?

Ciao grazie per l'interessamento e scusa se ti scrivo solo ora, limitswitchPinTVfuori è il finecorsa che segnala al motore passo passo che "trascina" la tv che la corsa è finita, quando viene eccitato voglio che si arresti la corsa della tv, che fino a quel momento è in orizzontale e faccia partire il secondo motore che la deve far ruotare, che non è un motore passo passo ma è un motore 12-24 volt da tergicristallo, perché mi serviva più coppia.
Il motore del tergicristallo è comandato sempre da arduino ma attraverso un motor driver L298N.

Ti ringrazio per la risposta, mi scuso per non aver specificato che solo il motore che si occupa del trascinamento della tv è un motore passo-passo, quello che si occupa della rotazione è un motore da tergicristallo comandato da arduino attraverso un motor driver L298N

Ok, quindi fare di continuo

     digitalWrite(mA, HIGH);
      digitalWrite(mB, LOW);

dovrebbe essere sufficiente a farlo muove fino al fine corsa, giusto?
Questo accade veramente?
Lo hai verificato?
Perchè se accade veramente puoi scommentare il pezzo, non è la causa, altrimenti bisogna indagare bene bene.

nanigago:
... e scusa se ti scrivo solo ora...

Non ti preoccupare, ognuno scrive in base al tempo che ha :wink:

Ciao ho fatto di tutto, commentato, riscritto, ricontrollato tutto dall'assegnazione dei pin, a tutto, e dopo un bel po di lavoro ho circoscritto il problema o almeno così sembra, perdonami se riposto tutto lo sketch se no non si capisce bene il concetto:

//Inclusione delle librerie necessarie
#include <SoftwareSerial.h>
#include <IRremoteInt.h>
#include <IRremote.h>
//Definizione dei pin
static int pinAcceleratore = A0; //pin analogico deputato a leggere i valori del potenziometro
static int mA = 12; //pin digitale per determinare gli stati logici da inviare al modulo
static int mB = 13; //pin digitale per determinare gli stati logici da inviare al modulo
static int pinPotenza = 11; //pin digitale tramite il quale inviare un segnale di tipo PWM tramite la funzione analgWrite()
int accelerazione;  //valore letto dal pin A0
int potenza;  //valore in uscita dal pin 11

//Definisco il senso di marcia del motore
  /*
    mA |   mB  | Evento
  -----|-------|----------------------
  LOW  | LOW   | fermo
  LOW  | HIGH  | Movimento in un senso
  HIGH | LOW   | Movimento senso opposto
  HIGH | HIGH  | Fermo
  */

int limitswitchPinRotazioneAvantiTV=6; //pin di arduino collegato al segnale S del micro azionato quando la TV ruota avanti
int limitswitchPinRotazioneIndietroTV=5; //pin di arduino collegato al segnale S del micro azionato quando la TV ruota indietro
const int pinDir = 2; //pin di arduino collegato al pin DIR del dirver che comanda il motore passo-passo
const int pinStep = 3; //pin di arduino collegato al pin DIR del dirver che comanda il motore passo-passo
int limitswitchPinTVdentro=8; //pin di arduino collegato al segnale S del micro azionato quando la TV è completamente rientrata
int limitswitchPinTVfuori=7; //pin di arduino collegato al segnale S del micro azionato quando la TV è completamente uscita
const int numStepMotore = 200; //imposto il numero di step per rotazione del motore 
const long velocita = 400; //imposto i microsecondi tra un impulso e l'altro sul pin STEP a 500
int receiver = 4; // pin 1 of IR receiver to Arduino digital pin 11
IRrecv irrecv(receiver); // create instance of 'irrecv'
decode_results results;

void setup()
{
  Serial.begin(9600);
  accelerazione = 0;
  potenza = 0;
  pinMode(pinAcceleratore, INPUT); //input in quanto legge il valore analogico del pin A0
  pinMode(mA, OUTPUT); //output perche' definisce lo stato logico del pin IN1 del modulo L298N
  pinMode(mB, OUTPUT); //output perche' definisce lo stato logico del pin IN2 del modulo L298N
  pinMode(pinPotenza, OUTPUT);  //output perche' definisce il valore PWM del pin EN1 del modulo L298N
  digitalWrite(pinAcceleratore, LOW);
  digitalWrite(mA, LOW);
  digitalWrite(mB, HIGH);
  //
  pinMode(4,OUTPUT); // imposto il pin 10 che riceverà il segnale dal telecomando
  pinMode(limitswitchPinTVdentro,INPUT); //inizializzo il pin a cui è collegato il segnale del micro a TV rientrata
  pinMode(limitswitchPinTVfuori,INPUT); //inizializzo il pin a cui è collegato il segnale del micro a TV uscita
  pinMode(6, INPUT_PULLUP); //inizializzo il pin a cui è collegato il micro rotazione tv avanti
  pinMode(5, INPUT_PULLUP); //inizializzo il pin a cui è collegato il micro rotazione tv indietro
  pinMode(pinStep, OUTPUT); //inizializzo il PIN STEP come OUTPUT
  pinMode(pinDir, OUTPUT); //inizializzo il PIN DIR come OUTPUT
  // il problema è qui sotto
  irrecv.enableIRIn(); // Start the receiver
  pinMode(9, OUTPUT); // Pin 9 output
  //
  }
void rotazione_avanti(){
  accelerazione = analogRead(pinAcceleratore);
  potenza = map(accelerazione, 0, 1024, 0, 255);
  analogWrite(pinPotenza, potenza);
  /*
  int sensorVal = digitalRead(6);
  if(sensorVal == HIGH){
    accelerazione = analogRead(pinAcceleratore);
    potenza = map(accelerazione, 0, 1024, 0, 255);
    digitalWrite(mA, LOW);
    digitalWrite(mB, HIGH);
    analogWrite(pinPotenza, potenza);
    }*/
}
void rotazione_indietro(){
  int sensorVal2 = digitalRead(5);
  if(sensorVal2 == HIGH){
    digitalWrite(mA, HIGH);
    digitalWrite(mB, LOW);
    }
}
void tv_avanti(){
  while(digitalRead(limitswitchPinTVfuori)==HIGH){
    digitalWrite(9, HIGH); //il LED si accende
    digitalWrite(pinDir, HIGH);
    for (int x = 0; x < numStepMotore; x++ ) {
      digitalWrite(pinStep, HIGH);
      delayMicroseconds(velocita);
      digitalWrite(pinStep, LOW);
      delayMicroseconds(velocita);
    }
  }
}
void tv_indietro(){
  while(digitalRead(limitswitchPinTVdentro)==HIGH){
    digitalWrite(9, LOW);
    digitalWrite(pinDir, LOW);
    for (int x = 0; x < numStepMotore; x++ ) {
      digitalWrite(pinStep, HIGH);
      delayMicroseconds(velocita);
      digitalWrite(pinStep, LOW);
      delayMicroseconds(velocita);
      }
  }
}
void loop()
{
  accelerazione = analogRead(pinAcceleratore);
  potenza = map(accelerazione, 0, 1024, 0, 255);
  Serial.print("Accelerazione = ");
  Serial.print(accelerazione);
  Serial.print(" - potenza = ");
  Serial.println(potenza);
  analogWrite(pinPotenza, potenza);
  
  //rotazione_avanti();
  
  
  /*
  if (irrecv.decode(&results)) // sto ricevendo un segnale IR?
  {
    Serial.println(results.value, HEX); // mostrami il segnale ricevuto sul serial monitor in hexadecimale
    irrecv.resume();// mi prepare per ricevere il prossimo segnale
  }
  if ( results.value == 0x4075708F ) //se premo il tasto 1 sul telecomando
  {
    //tv_avanti();
    rotazione_avanti();
}
  if ( results.value == 0x4075A05F ) //se premo il tasto 0 sul telecomando
  {
    rotazione_indietro();
    //tv_indietro();
    }*/
}

commentando la linea irrecv.enableIRIn() all'interno del setup posta sotto il commento il problema è qui sotto, il motore ruota correttamente, adesso devo capire perché quella linea rompe le scatole e come ovviare alla cosa, poi devo rimettere tutto in ordine perchè così come è commentato non mi serve a niente, l'indagine continua, sto impazzendo.

Scusa se continuo con le domande banali.
Hai individuato nell'inizializzazione dell'oggetto IRrecv il problema, nel senso che se non la fai funziona, o almeno da segni di vita sul loop, presumo che se metti un Serial.print() subito dopo non ci arriva, giusto?

Ora la domanda stupida: sei sicuro di aver impostato correttamente il pin in inizializzazione?
Riformulo: se provi a usare solo l'IRrecv riesci a farlo funzionare?
Perchè vedo:

int receiver = 4; // pin 1 of IR receiver to Arduino digital pin 11

Cioè quello che dichiari differisce da quanto indicato nel commento.

La mia curiosità al momento torna a:
Se metti tutto il codice come dovrebbe essere e nel setup, subito dopo

irrecv.enableIRIn(); // Start the receiver

ci metti un Serial.print("XXXXX"), lo stampa?

Edit:
Però tutto questo non quadrerebbe con il problema iniziale.
Mi sa che mi sono un po' perso.
Forse sarebbe da ripartire dall'inizio, tracciando, magari con delle Serial.print tutti i passi rilevanti per vedere dove passa e dove no, i valori attesi e quelli realmente ricevuti, ecc.

Devo ancora approfondire ma la butto lì un po alla "vigliacca" come si dice volgarmente, credo di essere incappato in un bug della libreria IRremote, se così vogliamo definirlo, infatti in rete ho trovato diversi riscontri che parlano di conflitti Timer tra la libreria stessa e l'utilizzo di PWM, proverò ad omettere la variazione di velocità di rotazione ricavata dala rotazione del potenziometro con una regolazione esterna e vediamo cosa succede, certo che al primo progetto serio al meno per me, trovarsi una rogna del genere non è male
:sob:

Ecco, già questo è più sensato, perchè il codice che vai a commentare è proprio quello che attiva le interrupt interne usate dalla libreria.

void  IRrecv::enableIRIn ( )
{
// Interrupt Service Routine - Fires every 50uS
#ifdef ESP32
	// ESP32 has a proper API to setup timers, no weird chip macros needed
	// simply call the readable API versions :)
	// 3 timers, choose #1, 80 divider nanosecond precision, 1 to count up
	timer = timerBegin(1, 80, 1);
	timerAttachInterrupt(timer, &IRTimer, 1);
	// every 50ns, autoreload = true
	timerAlarmWrite(timer, 50, true);
	timerAlarmEnable(timer);
#else
	cli();
	// Setup pulse clock timer interrupt
	// Prescale /8 (16M/8 = 0.5 microseconds per tick)
	// Therefore, the timer interval can range from 0.5 to 128 microseconds
	// Depending on the reset value (255 to 0)
	TIMER_CONFIG_NORMAL();

	// Timer2 Overflow Interrupt Enable
	TIMER_ENABLE_INTR;

	TIMER_RESET;

	sei();  // enable interrupts
#endif

	// Initialize state machine variables
	irparams.rcvstate = STATE_IDLE;
	irparams.rawlen = 0;

	// Set pin modes
	pinMode(irparams.recvpin, INPUT);
}

nanigago:
Devo ancora approfondire ma la butto lì un po alla "vigliacca" come si dice volgarmente, credo di essere incappato in un bug della libreria IRremote, se così vogliamo definirlo, infatti in rete ho trovato diversi riscontri che parlano di conflitti Timer tra la libreria stessa e l'utilizzo di PWM

NON c'è alcun bug ...
... è che prima di mischiare più librerie, occorre studiarsele e vedere le risorse che utilizzano.

Ovviamnete, se una libreria usa una certa risorsa (es. un certo Timer) NON si possono usare altre cose che utilizzano lo stesso Timer. Di pin che sono in grado di generare segnali PWM che ne sono vari e, a coppie, utilizzano Timer diversi, quindi ... basta scegliere la coppia che NON va in conflitto con lo stesso Timer usato dalla IRremote o, ancora meglio, selezionare un'altro Timer nel file "boarddefs.h" della IRremote :slight_smile:

Guglielmo

Chiedo scusa ho definito il problema che mi è successo erroneamente come BUG, la prossima volta non includerò librerie diverse con questa leggerezza, anche perché il tempo che si crede di risparmiare non approfondendo l'argomento prima, lo si spende dopo in "smadonnamenti" vari, ho imparato la lezione, ora mi rimetto all'opera grazie.

nanigago:
Chiedo scusa ho definito il problema che mi è successo erroneamente come BUG

vabbeh dai non fasciamoci la teste per queste cose :wink: fossero questi i problemi...

nanigago:
...il tempo che si crede di risparmiare non approfondendo l'argomento prima, lo si spende dopo in "smadonnamenti" vari...

Già, parole sante, ma non prenderti il merito di questo "errore", ci siamo passati tutti, compresi i bugiardi che lo negheranno :stuck_out_tongue:

Alla fine sei riuscito a risolvere? Con i suggerimenti di Guglielmo e smadonnando un po' in giro?

Ciao non ho ancora ultimato il progetto, perché mi sono arenato un'altra volta, in una cavolata che però mi è più ostica del previsto, infatti se testo la funzione "rotazione_avanti()" da sola, funziona egregiamente, ruota fino all'intervento del micro che indica il raggiungimento del corretto angolo di rotazione, ma se la inserisco nel programma, parte e non si ferma più ignorando completamente il micro.
Mentre ti scrivo mi viene in mente che devo aver definito alcune variabili in modo locale e non globale, l'errore potrebbe essere quello, ma se hai altre idee io sono sempre aperto a nuovi consigli.
Ti posto il codice come l'ho pensato fino a qui:

//Inclusione delle librerie necessarie
#include <SoftwareSerial.h>
#include <IRremoteInt.h>
#include <IRremote.h>
//Definizione dei pin
int sensorVal = digitalRead(6);
static int mA = 12; //pin digitale per determinare gli stati logici da inviare al modulo
static int mB = 13; //pin digitale per determinare gli stati logici da inviare al modulo
static int pinPotenza = 11; //pin digitale tramite il quale inviare un segnale di tipo PWM tramite la funzione analgWrite()
int limitswitchPinRotazioneAvantiTV=6; //pin di arduino collegato al segnale S del micro azionato quando la TV ruota avanti
int limitswitchPinRotazioneIndietroTV=5; //pin di arduino collegato al segnale S del micro azionato quando la TV ruota indietro
const int pinDir = 2; //pin di arduino collegato al pin DIR del dirver che comanda il motore passo-passo
const int pinStep = 3; //pin di arduino collegato al pin DIR del dirver che comanda il motore passo-passo
int limitswitchPinTVdentro=8; //pin di arduino collegato al segnale S del micro azionato quando la TV è completamente rientrata
int limitswitchPinTVfuori=7; //pin di arduino collegato al segnale S del micro azionato quando la TV è completamente uscita
const int numStepMotore = 200; //imposto il numero di step per rotazione del motore 
const long velocita = 400; //imposto i microsecondi tra un impulso e l'altro sul pin STEP a 500
int receiver = 4; // pin di Arduino che riceve il segnale IR
IRrecv irrecv(receiver); // create instance of 'irrecv'
decode_results results;

//Definizione senso di marcia del motore
  /*
    mA |   mB  | Evento
  -----|-------|----------------------
  LOW  | LOW   | fermo
  LOW  | HIGH  | Movimento in un senso
  HIGH | LOW   | Movimento senso opposto
  HIGH | HIGH  | Fermo
  */
void setup()
{
  Serial.begin(9600);
  pinMode(mA, OUTPUT); //output perche' definisce lo stato logico del pin IN1 del modulo L298N
  pinMode(mB, OUTPUT); //output perche' definisce lo stato logico del pin IN2 del modulo L298N
  pinMode(pinPotenza, OUTPUT);  //output perche' definisce il valore PWM del pin EN1 del modulo L298N
  digitalWrite(mA, LOW);
  digitalWrite(mB, HIGH);
  pinMode(4,OUTPUT); // imposto il pin 10 che riceverà il segnale dal telecomando
  pinMode(limitswitchPinTVdentro,INPUT); //inizializzo il pin a cui è collegato il segnale del micro a TV rientrata
  pinMode(limitswitchPinTVfuori,INPUT); //inizializzo il pin a cui è collegato il segnale del micro a TV uscita
  pinMode(8, INPUT_PULLUP); //inizializzo il pin a cui è collegato il micro tv dentro
  pinMode(7, INPUT_PULLUP); //inizializzo il pin a cui è collegato il micro tv fuori
  pinMode(6, INPUT_PULLUP); //inizializzo il pin a cui è collegato il micro rotazione tv avanti
  pinMode(5, INPUT_PULLUP); //inizializzo il pin a cui è collegato il micro rotazione tv indietro
  pinMode(pinStep, OUTPUT); //inizializzo il PIN STEP come OUTPUT
  pinMode(pinDir, OUTPUT); //inizializzo il PIN DIR come OUTPUT
  irrecv.enableIRIn(); // Start the receiver
  pinMode(9, OUTPUT); // Pin 9 output
}
void rotazione_avanti(){
  //int sensorVal = digitalRead(6);
  if(sensorVal == HIGH){
    digitalWrite(mA, LOW);
    digitalWrite(mB, HIGH);
    digitalWrite(pinPotenza, HIGH);
  }
  else
  {
    digitalWrite(mA, LOW);
    digitalWrite(mB, LOW);
    digitalWrite(pinPotenza, LOW);
    }
}
void rotazione_indietro(){
  int sensorVal2 = digitalRead(5);
  if(sensorVal2 == HIGH){
    digitalWrite(mA, HIGH);
    digitalWrite(mB, LOW);
    digitalWrite(pinPotenza, HIGH);
    }
    else
  {
    digitalWrite(mA, LOW);
    digitalWrite(mB, LOW);
    digitalWrite(pinPotenza, LOW);
    }
}
void tv_avanti(){
  int sensorVal3 = digitalRead(7);
  while(digitalRead(limitswitchPinTVfuori)==HIGH){
    digitalWrite(9, HIGH); //il LED si accende
    digitalWrite(pinDir, HIGH);
    for (int x = 0; x < numStepMotore; x++ ) {
      digitalWrite(pinStep, HIGH);
      delayMicroseconds(velocita);
      digitalWrite(pinStep, LOW);
      delayMicroseconds(velocita);
    }
  }
  if (sensorVal3 == HIGH){
    rotazione_avanti();
  }
}
void tv_indietro(){
  while(digitalRead(limitswitchPinTVdentro)==HIGH){
    digitalWrite(9, LOW); //il LED si spegne
    digitalWrite(pinDir, LOW);
    for (int x = 0; x < numStepMotore; x++ ) {
      digitalWrite(pinStep, HIGH);
      delayMicroseconds(velocita);
      digitalWrite(pinStep, LOW);
      delayMicroseconds(velocita);
      }
  }
}
void loop()
{
  
  if (irrecv.decode(&results)) // sto ricevendo un segnale IR?
  {
    Serial.println(results.value, HEX); // mostrami il segnale ricevuto sul serial monitor in hexadecimale
    irrecv.resume();// mi prepare per ricevere il prossimo segnale
  }
  if ( results.value == 0x4075708F ) //se premo il tasto 1 sul telecomando
  {
    tv_avanti();
    }
  if ( results.value == 0x4075A05F ) //se premo il tasto 0 sul telecomando
  {
    tv_indietro();
    }
}

Se gestisco la rotazione avanti con un if funziona interrompendosi premendo il micro, se la faccio usando while non lo fa mi sono incastrato su una monata ma non ne salto fuori.

// così funziona
void rotazione_avanti(){
  int sensorVal = digitalRead(6);
  if(sensorVal == HIGH){
    digitalWrite(mA, LOW);
    digitalWrite(mB, HIGH);
    digitalWrite(pinPotenza, HIGH);
  }
  else
  {
    digitalWrite(mA, LOW);
    digitalWrite(mB, LOW);
    digitalWrite(pinPotenza, LOW);
    }
}
//così non funziona
void rotazione_avanti(){
  int sensorVal = digitalRead(6);
  while(sensorVal == HIGH){
    digitalWrite(mA, LOW);
    digitalWrite(mB, HIGH);
    digitalWrite(pinPotenza, HIGH);
    }
}

Citando la guida di Arduino approposito delle variabili "any variable declared outside of a function (e.g. setup(), loop(), etc. ), is a global variable." perfetto ma allora perché nella seguente funzione se commento la variabile perché già dichiarata non và e se la metto invece funziona?

void rotazione_avanti(){
  //int sensorVal = digitalRead(6);// commento perchè già dichiarata fuori da ogni funzione e quindi globale
  if(sensorVal == HIGH){
    digitalWrite(mA, LOW);
    digitalWrite(mB, HIGH);
    digitalWrite(pinPotenza, HIGH);
  }
  else
  {
    digitalWrite(mA, LOW);
    digitalWrite(mB, LOW);
    digitalWrite(pinPotenza, LOW);
    }
}

leggi bene, (ma bene significa controllando anche sul reference ogni (OGNI) parola)
ma veramente bene
la riga che commenti
oh, e te lo dico subito....
bene significa bene!
chiaro il concetto?

Ho letto bene e ho scoperto di essere un pirla, sperando di non essere pirla due volte adesso ho fatto così, ho dichiarato fuori da ogni funzione:

int sensorVal;

e all'interno della funzione: sensorVal = digitalRead(6);

bravo!
scusa se prima ti son sembrato un po' brusco
ma qui è pieno di gente che gli chiedi perchè vuole accendere la lampadina e ti risponde che la lampadina è rossa...
capirai che dopo un po' ci si premunisce specificando bene (ma Bene Bene) la domanda....

Nessun problema, anzi grazie per l'aiuto.