Ottimizzazione funzione coordinate con motori passo passo

Buongiorno a tutti. Nel mio progetto ho 2 (in realtà 3) motori tipo Nema 17 che servono per spostare una testina che monta una penna su di un piano seguendo come indicazioni le coordinate del punto da raggiungere. Sto utilizzando 3 motori Nema 17 cinesi, comandati da driver a4988, e un Arduino Pro Micro cinese anch’esso.
Premetto che il codice che ho scritto (grazie anche a qualche dritta di alcuni utenti di questo forum) funziona bene, almeno fino al punto in cui sono arrivato. Tuttavia mi rendo conto che la funzione alla quale ho delegato il compito di raggiungere le coordinate rallenta di molto la velocità dei motori. Posto il codice così è tutto più chiaro.

void goToCoord(long x, long y){
	
	//xPos e yPos sono le coordinate attuali della testina
	long deltaX = x - xPos;
	long deltaY = y - yPos;
	float alpha;	//Coefficiente angolare della retta da percorrere
	float xMovement = 0;	//Serviranno per tenere conto
	float yMovement = 0;	//del movimento già effettuato
	
	float xtra = 0;		//Tiene conto dei decimali di passo dell'asse x
	
	if(x <= maxXSteps && y <= maxYSteps && x >= 0 && y >= 0){	//Se il punto da raggiungere non è fuori dal piano di lavoro...
		
		//Questa porzione di codice evita che il calcolo del coefficiente angolare presenti una divisione per 0
		//Le funzioni moveX e moveY muovono questa o quell'asse e tengono traccia del movimento sulle variabili xPos e yPos
		if(deltaX == 0){
			moveY(deltaY);
		}else if(deltaY == 0){
			moveX(deltaX);
		}else if(deltaX != 0 && deltaY != 0){
			alpha = (float)deltaX/(float)deltaY;
		}
		
		//La vera e propria porzione di codice che muove le assi
		while(xMovement < abs(deltaX) && yMovement < abs(deltaY)){			
			moveX((int)alpha * deltaX/abs(deltaX));
			xMovement += (int)alpha;
			
			xtra += alpha - (int)alpha;
			
			if(abs(xtra) > 1){
				moveX(1 * deltaX/abs(deltaX));
				xMovement++;
				xtra -= (int)xtra;
			}
			
			moveY(1 * deltaY/abs(deltaY));
			yMovement++;
		}
	}
}

Il problema di base della realizzazione di questa funzione è chiaramente il fatto che ho dovuto simulare una specie di multitasking, muovendo alternativamente un’asse e l’altra, di modo che il movimento sembrasse unico. Si può riassumere il tutto così: “muovi l’asse Y di 1, poi muovi l’asse X di deltaX/deltaY”. Il problema era come gestire lo scarto dovuto al fatto che quasi sempre il coefficiente angolare della retta sarebbe stato un valore con la virgola. Per cui ho inserito la variabile xtra, la quale semplicemente tiene conto di ogni quanti cicli l’asse X accumula uno scarto di decimali superiori ad 1 e fa compiere un passo extra all’asse X.

Personalmente la soluzione mi soddisfa molto, ma inevitabilmente lo svolgimento di tutte quelle operazioni tra uno spostamento e l’altro rallenta le possibilità dei motori. Certo magari l’ideale sarebbe utilizzare un arduino per ogni asse, ma non è certo necessario. Volevo sapere quindi se secondo voi c’è un modo per ottimizzare il tutto.

Non ho capito bene come hai fatto, ma io dividerei in due il problema.
Scriverei un codice che mi calcola il movimento teorico con la precisione che ritengo, ad es. 2 decimali, con valori interi moltiplicati, quindi, per 100. Il valore 1,15 sarebbe quindi rappresentato da 115.
Scriverei un secondo codice che approssima il risultato alla precisione minima dei motori e li comanda se rispetto al valore precedente c'è una variazione.
Il passo del primo pezzo dovrebbe essere il massimo comun divisore dei passi del secondo, per ridurre al minimo i giri a vuoto, cioè quelli che non producono variazioni sui motori.

Il secondo pezzo, farebbe semplicemente un arrotondamento dei valori del primo, senza tenere conto dei vari delta intermedi ma facendo dei semplici arrotondamenti matematici. Ad es. facendo la divisione intera per 100.

Maurizio