Menu di controllo della velocità passo-passo guidato per Arduino: 6 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

Questa libreria SpeedStepper è una riscrittura della libreria AccelStepper per consentire il controllo della velocità del motore passo-passo. La libreria SpeedStepper consente di modificare la velocità del motore impostata e quindi accelera/decelera alla nuova velocità impostata utilizzando lo stesso algoritmo della libreria AccelStepper. La libreria SpeedStepper ti consente anche di impostare il limite più e meno e una posizione 'home'. C'è un comando goHome per tornare alla posizione iniziale.

Limitazioni: la libreria SpeedStepper guida solo le uscite di direzione e passo e quindi deve essere collegata a un driver del motore, come Easy Driver, per azionare effettivamente il motore passo-passo. La libreria AccelStepper fornisce più opzioni di guida che potrebbero essere copiate in questa libreria se necessario.

Sono forniti tre schizzi di esempio, ciascuno dei quali può essere eseguito senza un motore o un driver del motore. Lo schizzo speedStepperPlot emette comandi di velocità di esempio e il comando goHome e genera un grafico della velocità e della posizione risultanti. Lo schizzo speedStepperSetup fornisce una configurazione guidata da menu per impostare la posizione iniziale e i limiti del motore, quindi avviare il motore e regolare la velocità su e giù e goHome per terminare. Lo schizzo speedStepperProfile mostra un esempio di impostazione ed esecuzione di un profilo di velocità.

Mentre la libreria AccelStepper fornisce un buon controllo della posizione, il controllo della velocità era necessario per il prototipo della sonda per la fusione del ghiaccio per la raccolta di campioni biologici su Europa. Ecco un video di una versione precedente del prototipo, che utilizzava il peso invece di un motore. La revisione 1.1 ha aggiunto i profili di velocità dopo che un utente ha richiesto un mezzo per controllare il profilo di velocità di una pompa.

Questa libreria funziona su Arduino Uno e Mega2560, ma per il prototipo è stata utilizzata una memoria più grande / processore più veloce SparkFun Redboard Turbo.

Questa istruzione è disponibile anche online su Stepper Speed Control Library per Arduino

Forniture

Per eseguire gli sketch di esempio sono necessari solo un Arduino UNO o Mega2560 e le librerie software

Per i test al banco della libreria è stato utilizzato uno SparkFun Redboard Turbo con un Easy Driver, un motore passo-passo da 200 passi/giro, 12V 350mA e un'alimentazione 12 DC 2A o superiore, ad es. https://www.sparkfun.com/products/14934. Cavo USB da A a MicroCavo seriale da USB a TTL Arduino IDE V1.8.9 e un computer su cui eseguirlo. Libreria SpeedStepper Libreria pfodParser per le classi nonBlockingInput e pfodBufferedStream Libreria millisDelay per ritardi non bloccanti

Passaggio 1: funzioni della libreria

La libreria SpeedStepper esegue il motore passo-passo limitato dai limiti impostati dalla libreria. Vedere il file SpeedStepper.h per i vari metodi di libreria disponibili. Ecco uno schema della logica dietro di loro.

La posizione dello stepper viene tracciata contando il numero di passi (impulsi). La libreria limita la posizione tra le posizioni setPlusLimit(int32_t) e setMinusLimit(int32_t). Il limite più è sempre >= 0 e il limite meno è sempre <= 0. All'avvio la posizione del motore è 0 (home) ei limiti sono impostati su numeri +/- molto grandi (circa +/-1e9 step). setAcceleration(float) imposta la velocità con cui il motore aumenterà o diminuirà la velocità. Quando il motore si avvicina al limite più o meno, decelera a questa velocità finché non si ferma al limite. All'avvio l'accelerazione è impostata su 1.0 step/sec/sec. L'impostazione dell'accelerazione è sempre un numero +ve. Il segno dell'impostazione setSpeed(float) definisce la direzione in cui si muoverà il motore.

setSpeed(float) imposta la velocità alla quale accelerare/decelerare il motore, dalla sua velocità attuale. La velocità impostabile tramite setSpeed(float) è limitata, in valore assoluto, dalle impostazioni, setMaxSpeed(float), default 1000 step/sec e setMinSpeed(float), default 0.003 step/sec. Questi valori predefiniti sono anche i limiti di velocità assoluti codificati che la libreria accetterà per setMaxSpeed() e setMinSpeed(). Se si desidera impostare una velocità massima > 1000 passi/sec, sarà necessario modificare la prima riga nel file SpeedStepper.cpp per modificare maxMaxSpeed(1000) alla velocità massima desiderata. In pratica la velocità massima è anche limitata dal tempo tra le chiamate al metodo run() della libreria. Per 1000 passi/sec il metodo run() deve essere chiamato almeno ogni 1mS. Vedere la sezione Latenza di seguito.

Il tentativo di impostare una velocità inferiore alla velocità minima causerà l'arresto del motore. Ognuno di questi setter ha un getter corrispondente, vedere il file SpeedStepper.h. Per la velocità, getSetSpeed() restituisce la velocità impostata tramite setSpeed(), mentre getSpeed() restituisce la velocità corrente del motore che varia man mano che accelera/decelera alla velocità impostata. Se il motore non sta andando nella direzione in cui pensi a +ve puoi chiamare invertDirectionLogic() per scambiare la direzione in cui si muove il motore per +ve velocità.

getCurrentPosition() restituisce la posizione corrente del motore rispetto a 'home' (0). È possibile sovrascrivere la posizione corrente del motore setCurrentPosition(int32_t). La nuova posizione è limitata all'interno dei limiti più/meno impostati.

Inizialmente il motore è fermo in posizione 0. Chiamando setSpeed(50.0) inizierà ad accelerare nella direzione +ve fino a una velocità massima di 50 passi/min. Chiamare hardStop() fermerà immediatamente il motore dove si trova. D'altra parte, chiamare il metodo stop() imposterà la velocità a zero e decelererà l'arresto del motore. La chiamata a stopAndSetHome() arresterà immediatamente il motore e imposterà la sua posizione a 0. I valori dei limiti più/meno non vengono modificati ma ora sono riferiti a questa nuova posizione 0 (home). La chiamata a goHome() riporterà lo stepper in questa posizione 0 (home) e si fermerà. La chiamata a setSpeed() annullerà il ritorno a casa.

La libreria SpeedStepper fornisce anche il controllo del profilo di velocità tramite i metodi setProfile(SpeedProfileStruct* profileArray, size_t arrayLen), startProfile(), stopProfile(), per interrompere un profilo in esecuzione e isProfileRunning(). Vedere lo schizzo di esempio speedStepperProfile.

Passaggio 2: esecuzione dell'esempio SpeedStepperPlot senza motore

Installa Arduino IDE V1.8.9 Scarica e installa la libreria SpeedStepper Salva SpeedStepper.zip e poi usa la voce di menu Arduino IDE Sketch → Includi libreria → Aggiungi libreria. ZIP per importare la libreria Scarica e installa anche la libreria millisDelay

Apri lo schizzo di esempio Esempi → SpeedStepper → speedStepperPlot (riavvia l'IDE se necessario). Questo schizzo è configurato per funzionare con Serial, ad es. UNO e Mega ecc. Per l'esecuzione su SparkFun Redboard Turbo vedi sotto.

Non è necessaria alcuna scheda driver o motore passo-passo per eseguire questo esempio. Questi esempi utilizzano D6 e D7 come uscite. È possibile modificare i pin di uscita in qualsiasi uscita digitale modificando le impostazioni STEP_PIN e DIR_PIN nella parte superiore dello schizzo.

Carica lo schizzo a bordo e quindi apri Strumenti → Plotter seriale a 115200 baud per mostrare il grafico della velocità (ROSSO) e della posizione (BLU) Il limite positivo è impostato a 360 che fa sì che la velocità salga a zero da circa 100 punti sull'asse x. Il limite negativo è -510. La posizione si ferma a ~-390 perché la velocità è stata richiesta a 0.0. Al punto 380 sull'asse x, viene emesso il cmd goHome che riporta lo stepper in posizione zero.

Questo schizzo speedStepperPlot utilizza millisDelays per passare da una velocità all'altra e accelerazioni nel tempo. In molti casi l'utilizzo di uno SpeedStepperProfile, come nel prossimo esempio, è più semplice.

Passaggio 3: esecuzione dell'esempio SpeedStepperProfile senza motore

Apri lo schizzo di esempio Esempi → SpeedStepper → speedStepperPlot, questo schizzo produce il grafico sopra utilizzando il plotter seriale Arduino ed è un esempio di esecuzione di un profilo di velocità prescritto, ad esempio se si esegue una pompa.

Gli Stepper Speed Profiles sono costituiti da un array di SpeedProfileStruct, che è definito nel file SpeedStepper.h.

struct SpeedProfileStruct {

velocità di galleggiamento; // la velocità target alla fine di questo passo unsigned long deltaTms; // il tempo per accelerare dalla velocità attuale (all'inizio di questo passaggio) alla velocità target };

Definire un array di SpeedProfileStruct contenente la velocità target per ogni passaggio e il tempo, deltaTms, in mS, per raggiungere quella velocità target dalla velocità target precedente. Se il deltaTms è zero o molto piccolo, la velocità passerà immediatamente alla nuova velocità target. In caso contrario, verrà calcolata l'accelerazione richiesta. Verrà chiamato setAcceleration() seguito da una chiamata a setSpeed() per la nuova velocità target. In tutti i casi il profilo sarà limitato dai limiti di posizione più e meno esistenti e dalle impostazioni di velocità massima/minima. Se vuoi mantenere una velocità, ripeti la velocità precedente con il tempo in cui desideri che venga mantenuta. Poiché la nuova velocità target è la stessa della velocità attuale, l'accelerazione calcolata sarà zero e non si verificherà alcun cambiamento di velocità.

Questo array SpeedProfileStruct ha prodotto il grafico sopra

const SpeedProfileStruct profile = { { 0, 0}, // ferma immediatamente se non è già stato fermato { 0, 1000}, // mantieni zero per 1 sec { -50, 0}, // salta a -50 { -200, 2000}, // rampa a -200 { -200, 6000}, // mantieni a -200 per 6 sec { -50, 2000}, // diminuisci a -50 { 0, 0}, // // fermati immediatamente { 0, 1500}, // mantieni zero per 1,5 sec { 50, 0}, // salta a 50 { 200, 2000}, // rampa a 200 { 200, 6000}, // mantieni 200 per 6 sec { 50, 2000}, // rampa a 50 { 0, 0}, // // fermati immediatamente { 0, 1000} // mantieni zero // per tracciare l'output }; const size_t PROFILE_LEN = sizeof(profile) / sizeof(SpeedProfileStruct); // calcola la dimensione dell'array del profilo

Il profilo viene impostato chiamando setProfile(SpeedProfileStruct* profileArray, size_t arrayLen) ad es. stepper.setProfile(profilo, PROFILE_LEN);

Una volta che il profilo è stato impostato, chiama startProfile() per avviarlo alla velocità corrente del motore (di solito inizierai da fermo). Alla fine del profilo, il motore continuerà a funzionare all'ultima velocità target. Il metodo isProfileRunning() può essere chiamato per vedere se il profilo è ancora in esecuzione. Se vuoi fermare il profilo in anticipo puoi chiamare stopProfile() che abbandonerà il profilo e fermerà il motore.

Passaggio 4: esecuzione dell'esempio SpeedStepperSetup senza motore

Lo schizzo di esempio è progettato come base per la tua applicazione del motore passo-passo. Fornisce un'interfaccia guidata da menu che consente di passare al motore nella sua posizione iniziale, se non è già presente, quindi reimpostare facoltativamente i limiti più e meno e quindi far funzionare il motore all'interno di tale intervallo. Il menu 'run' consente di aumentare e diminuire la velocità, congelare alla velocità corrente, fermarsi e anche tornare a casa.

Questo schizzo illustra una serie di funzionalità software che mantengono il loop() reattivo in modo da poter aggiungere i propri input del sensore per controllare lo stepper. È necessario evitare ritardi che interferirebbero con il controllo della velocità. (Vedi I ritardi sono un male)

Installa le librerie utilizzate per eseguire SpeedStepperPlot, sopra, quindi installa anche la libreria pfodParser. La libreria pfodParser fornisce le classi NonBlockingInput e pfodBufferedStream che vengono utilizzate per gestire l'input dell'utente e l'output del menu con il blocco dell'esecuzione di loop().

Apri gli esempi → SpeedStepper → speedSpeedSetup esempio. Questo schizzo è configurato per funzionare con Serial, ad es. UNO e Mega ecc. Per l'esecuzione su SparkFun Redboard Turbo vedi sotto.

Non è necessaria alcuna scheda driver o motore passo-passo per eseguire questo esempio. Questi esempi utilizzano D6 e D7 come uscite. È possibile modificare i pin di uscita in qualsiasi uscita digitale modificando le impostazioni STEP_PIN e DIR_PIN nella parte superiore dello schizzo. Carica lo schizzo sulla scheda e quindi apri Strumenti → Serial Monitor a 115200 per vedere il menu SETUP.

SETUP pos:0 sp:0.00 +Lim:500000 -Lim:-500 LATENZA: stepper:492uS loop:0uS p -- set Home l -- imposta limiti h -- goHome r -- run >

Quando lo schizzo viene eseguito, la posizione corrente dello stepper viene presa come posizione 'home' (0). Se è necessario riposizionare lo stepper nella sua vera posizione "home", immettere il comando p per visualizzare il menu SET HOME

SET HOME pos:0 sp:0.00 +Lim:1073741808 -Lim:-1073741808 LATENCY: stepper:752uS loop:3852uS x -- setHome qui ed esci + -- Forward - -- Reverse s -- swap Forward/Reverse -- hardStop >

Come puoi vedere i limiti codificati nello schizzo sono stati rimossi in modo da poter riposizionare lo stepper ovunque. Devi fare attenzione a non spingerlo oltre i limiti fisici o potresti rompere qualcosa.

Usa il + cmd per iniziare a muovere lo stepper in avanti, se trovi che si muove nella direzione sbagliata inserisci un non comando o solo una riga vuota per fermarlo e poi usa lo scommand per scambiare la direzione di Avanti. Dovresti aggiornare lo schizzo per includere una chiamata a invertDirectionLogic() nella configurazione per risolvere questo problema per la prossima esecuzione.

Utilizzare i comandi +/- per posizionare lo stepper nella posizione zero corretta. Il motore si avvia lentamente e poi aumenta la velocità man mano che procede, basta usare e svuotare la linea per fermarlo. La velocità massima per questo e il menu dei limiti è impostata da MAX_SETUP_SPEED nella parte superiore di setupMenus.cpp.

Una volta che il motore è stato posizionato nella sua posizione 'home', utilizzare il cmd x per reimpostare la posizione corrente su 0 e tornare al menu SETUP.

Se è necessario impostare i limiti, di solito solo nella configurazione iniziale, utilizzare il cmd l per accedere al menu SET LIMITS

SET LIMITS pos:0 sp:0.00 +Lim:1073741808 -Lim:-1073741808 LATENCY: stepper:944uS loop:5796uS l -- setLimit qui + -- Forward - -- Reverse h -- goHome x -- exit -- hardStop >

Utilizzare il + cmd per avanzare ulteriormente al limite più e quindi utilizzare il cmd l per impostarlo come limite più. Il comando h può quindi essere utilizzato per tornare a 0 e l'uso di – cmd per spostarsi se si riporta alla posizione del motore al limite negativo. Usa di nuovo il cmd l per impostare il limite negativo. Annotare le posizioni dei limiti più e meno e aggiornare le istruzioni setPlusLimit e setMinusLimit del metodo setup() con questi valori.

Quando i limiti sono impostati, usa il cmd x per tornare al menu SETUP e poi puoi usare il cmd r per aprire il menu RUN

RUN MENU pos:0 sp:3.31 +Lim:500000 -Lim:-500 LATENZA: stepper:944uS loop:5796uS + -- Accelerazione - -- Riduzione velocità h -- goHome. -- hardStop -- freeze Speed >+ pos:4 sp:9.49 +Lim:500000 -Lim:-500 LATENZA: stepper:792uS loop:5664uS pos:42 sp:29.15 +Lim:500000 -Lim:-500 LATENZA: stepper:792uS loop:5664uS pos:120 sp:49.09 +Lim:500000 -Lim:-500 LATENZA: stepper:792uS loop:5664uS pos:238 sp:69.06 +Lim:500000 -Lim:-500 LATENZA: stepper:792uS loop: 5664uS

Il + cmd inizia ad accelerare in avanti e stampa la posizione e la velocità ogni 2 secondi. Quando il motore raggiunge la velocità desiderata è possibile interrompere l'accelerazione con un qualsiasi altro tasto (o un input vuoto). Puoi ridurre la velocità usando il – cmd giù per fermarti. Se fermato il – cmd accelererà al contrario.

Questo menu RUN fornisce il controllo manuale del progetto. Per il controllo automatico dovrai aggiungere altri sensori.

Passaggio 5: latenza

Il controllo del motore passo-passo dipende dal software che comanda ogni passo. Per mantenere la velocità impostata, il tuo schizzo deve chiamare il metodo stepper.run() abbastanza spesso da attivare il passaggio successivo al momento giusto per la velocità corrente. Per il controllo tramite sensori è necessario essere in grado di elaborare tempestivamente nuove misurazioni. La stampa della posizione/velocità include due misurazioni della LATENZA per consentirti di verificare che il tuo schizzo sia abbastanza veloce.

Latenza stepper (pfodBufferedStream)

La latenza stepper misura il ritardo massimo tra chiamate successive al metodo stepper.run(). Per far funzionare il motore passo-passo a 1000 passi al secondo, la latenza passo passo deve essere inferiore a 1000 uS (1 mS). La prima versione di questo schizzo aveva una latenza di molti millisecondi. Per superare queste chiamate extra al metodo runStepper() (che chiama stepper.run()) sono state aggiunte tramite il codice. Questo non ha risolto completamente il problema perché il menu e le istruzioni di stampa dell'output bloccavano lo schizzo una volta che il piccolo buffer Serial Tx era pieno. Per evitare questo blocco, è stato utilizzato pfodBufferedStream dalla libreria pfodParser per aggiungere un buffer di stampa di output di 360 byte in cui le istruzioni di stampa potrebbero scrivere rapidamente. Quindi pfodBufferedStream rilascia i byte alla velocità di trasmissione specificata 115200 in questo caso. pfodBufferedStream ha l'opzione di bloccare quando il buffer è pieno o semplicemente di eliminare i caratteri di overflow. Qui è impostato per eliminare eventuali caratteri extra quando il buffer è pieno in modo che lo sketch non venga bloccato in attesa che Serial invii caratteri.

Latenza del loop (NonBlockingInput)

La latenza del ciclo misura il ritardo massimo tra chiamate successive al metodo loop(). Imposta la velocità con cui puoi elaborare le nuove misurazioni del sensore e regolare la velocità impostata del motore. Quanto velocemente deve essere quindi dipende da cosa stai cercando di controllare.

I ritardi dovuti alle istruzioni di stampa sono stati rimossi utilizzando pfodBufferedStream sopra, ma per elaborare l'input dell'utente è necessario prendere il primo carattere dell'input e ignorare il resto della riga. La classe NonBlockingInput nella libreria pfodParer viene utilizzata per restituire un carattere diverso da zero quando è presente un input, utilizzando readInput(), e per cancellare e scartare i seguenti caratteri, utilizzando clearInput(), fino a quando non vengono ricevuti caratteri per 10 mS senza bloccare il ciclo ()

Ovviamente la latenza del loop sarà aumentata dal codice extra che aggiungi per leggere i sensori e calcolare la nuova velocità impostata. Molte librerie di sensori prendono il tipo di usare solo il ritardo (..) tra l'inizio di una misurazione e il recupero del risultato. Sarà necessario riscrivere queste librerie per utilizzare invece millisDelay, per prelevare la misurazione dopo un adeguato ritardo non bloccante.

Passaggio 6: esecuzione di SpeedStepperSetup con un motore passo-passo e SparkFun Redboard Turbo

Per eseguire lo schizzo SpeedStepperSetup per davvero avrai bisogno di un motore passo-passo, driver e alimentatore e in questo esempio SparkFun Redboard Turbo.

Lo schema elettrico sopra (versione pdf) mostra i collegamenti. Nello schizzo SpeedStepperSetup cambia la definizione SERIAL in #define SERIAL Serial1

Motore passo-passo, alimentatore, driver e protezione

Esistono molti tipi e dimensioni di motori passo-passo. Qui viene utilizzato un motore passo-passo a due bobine 12V 350mA per i test. Per alimentare questo stepper è necessario un alimentatore di 12V o più e maggiore di 350mA.

Questa libreria fornisce solo un output di direzione e passo, quindi è necessario un driver per interfacciarsi con il motore passo-passo. L'Easy Driver e il Big Easy Driver controllano la corrente alle bobine del motore in modo da poter utilizzare in sicurezza un'alimentazione di tensione più elevata, ad esempio utilizzando un'alimentazione a 6V per un motore da 3,3V. L'Easy Driver può fornire tra 150mA/bobina e 700mA/bobina. Per correnti più elevate, il Big Easy Driver può fornire fino a 2A per bobina. Leggi le domande frequenti in fondo alla pagina Easy Drive.

Questi esempi utilizzano D6 e D7 come uscite Step e Direction. È possibile modificare i pin di uscita in qualsiasi uscita digitale modificando le impostazioni STEP_PIN e DIR_PIN nella parte superiore dello schizzo.

Programmazione di Sparkfun Redboard Turbo

La programmazione del Redboard Turbo è problematica. Se non riesce a programmare, premere prima il pulsante di ripristino una volta e riselezionare la porta COM nel menu Strumenti di Arduino e riprovare. Se non funziona, premi due volte il pulsante di ripristino e riprova.

Cablaggio dell'Easy Driver

Due motori passo-passo a bobina hanno 4 fili. Utilizzare un multimetro per trovare le coppie che si collegano a ciascuna bobina, quindi collegare una bobina ai terminali Easy Driver A e l'altra bobina al terminale B. Non importa in che modo li colleghi perché puoi usare s cmd nel menu di configurazione per scambiare la direzione del movimento.

L'alimentazione del motore è cablata a M+ e GNDImpostare il livello logico della scheda con il collegamento 3/5V. Cortocircuitare il collegamento per le uscite del microprocessore a 3,3V, come lo SparkFun Redboard Turbo (se lo lasci aperto è adatto per segnali digitali a 5V, es. UNO, Mega)Collegare i pin GND, STEP, DIR al microprocessore GND e allo step e pin di uscita dir. Non sono necessarie altre connessioni per pilotare il motore.

Cavo seriale da USB a TTL

Quando si sposta lo schizzo SpeedStepperSetup da Uno/Mega al Redboard Turbo, si potrebbe ingenuamente sostituire #define SERIAL Serial con #define SERIAL SerialUSB per adattarsi alla connessione seriale USB Redboard Turbo, tuttavia si scoprirà che la latenza dello stepper risultante è di circa 10 ms. Questo è 10 volte più lento di quello dell'ONU. Ciò è dovuto al modo in cui la CPU Redboard gestisce la connessione USB. Per superare questo problema, collegare un cavo seriale da USB a TTL a D0/D1 e impostare #define SERIAL Serial1 per utilizzare la connessione seriale hardware per controllare il motore passo-passo. L'utilizzo di Serial1 fornisce LATENCY: stepper: 345uS loop: 2016uS che è 3 volte più veloce dell'UNO per lo stepper e la latenza del loop

Programma terminale

Il monitor seriale Arduino è un po' più difficile da usare per controllare il motore passo-passo in quanto è necessario inserire il carattere nella riga cmd e quindi premere Invio per inviarlo. Un mezzo più rapido e reattivo consiste nell'aprire una finestra di terminale, TeraTerm per PC (o CoolTerm Mac), collegata alla porta COM del cavo da USB a TTL. Quindi in quella finestra premendo un tasto cmd lo invia immediatamente. Premendo Invio basta inviare una riga vuota.

Impostazione della gamma di velocità del motore

Come cablato sopra, l'Easy Drive è configurato per 1/8 passi, quindi 1000 passi/sec faranno girare il motore a 1000/8 / 200 passi/giro = 0,625 giri al secondo o 37,5 giri/min al massimo. Modificando gli ingressi su MS1/MS2 è possibile commutare tra 1/8, ¼, ½ e passi interi. Per i passaggi completi, collegare sia MS1 che MS2 a GND. Ciò consentirà velocità fino a 300 giri / min. La scelta delle impostazioni MS1/MS2 appropriate consente di regolare il rapporto di trasmissione installato tra il motore e la parte condotta.

Protezione hardware

Mentre la libreria SpeedStepper consente di impostare i limiti di posizione sul movimento del motore, la virata della posizione viene eseguita contando i passi emessi dal software. Se il motore va in stallo, ovvero la coppia è insufficiente per guidare il motore nella fase successiva, la posizione del software non sarà sincronizzata con la posizione del motore. Quindi, quando usi il comando 'goHome', il motore supererà la posizione iniziale. Per evitare danni all'hardware è necessario installare interruttori di finecorsa ai limiti rigidi per scollegare l'alimentazione del motore

Impostazione del limite di corrente del motore

Innanzitutto, impostalo sull'impostazione più bassa del potenziometro. cioè la tensione su TP1 è minima. Il potenziometro è delicato, quindi non forzare il potenziometro oltre i fermi meccanici. Imposta il motore a una velocità lenta e costante, quindi ruota lentamente il potenziometro finché il motore non salta o scatta tra i passaggi.

Conclusione

Questo progetto mostra come utilizzare la libreria SpeedStepper in un'applicazione pratica. Mentre la libreria AccelStepper fornisce un buon controllo della posizione, era necessario il controllo della velocità per il prototipo della sonda per la fusione del ghiaccio per la raccolta di campioni biologici su Europa, quindi la libreria AccelStepper è stata riscritta per fornire il controllo della velocità con limiti finali e una funzione goHome.