Controller.

Per pilotare i motori stepper serve un controller. Esistono numerose varianti di controller, sia software che hardware. Tra i più noti software Mach3, LinuxCNC, EMC, mentre tra le soluzioni hardware GRBL è uno dei più noti.

Cosa fa un controller?

Abbastanza semplice a dirsi: prende in ingresso una sequenza di comandi in un linguaggio (G-Code) e li tramuta in comandi STEP e DIR per tutti gli assi della CNC.

Questa operazione è invece piuttosto complessa a farsi, in quanto un singolo comando può generare movimenti complicati, come la realizzazione di un arco che implica il pilotaggio in modo indipendente di due o più assi in modo non lineare.

Inoltre il controller tiene conto delle velocità e accelerazioni dell'utensile e le regola in funzione dei limiti della macchina e delle caratteristiche del materiale da lavorare, si occupa di gestire i fine corsa in modo che non si danneggi l'utensile e molto altro.

Molto diffuse sono le succitate implementazioni software, come Mach3 o LinuxCNC, ma a mio giudizio hanno il difetto di richiedere un PC desktop dedicato con porta parallela. Nel mio caso il controller sarebbe più grosso della fresa!

GRBL, un controller basato su Arduino. 

Dopo molte ricerche ho scoperto il GRBL, un software che gira su Arduino Uno e che può pilotare direttamente i moduli A4988. GRBL risolve il mio problema dello spazio, in quanto mi permette di costruire un modulo di dimensioni molto compatte che contiene sia il controller (Arduino con GRBL) che i tre driver A4988.

Oltre ai tre assi, GRBL consente di controllare i fine corsa indipendenti sui tre assi, direzione e velocità del mandrino, il motore per il liquido di raffreddamento, una sonda per il livellamento della superficie e alcuni pulsanti per il blocco d'emergenza e le pause nella lavorazione.

Rispetto ad altri controller software ha dei limiti: la memoria dell'Atmel ATMega328 è limitata, e alcune caratteristiche come un eventuale quarto asse, o un display DRO (digital readout) non sono implementate, né implementabili.

Qui sotto potete vedere la piedinatura di un Arduino UNO con installato il firmware GRBL 1.1. La versione è importante, in quanto nelle precedenti alcune funzioni usavano pin differenti. La versione 1.1 è la più recente al momento in cui scrivo, quindi mi riferirò sempre a quella.

Poiché ho simpatia per le cose piccole (niente battute, grazie), ho pensato di sostituire Arduino UNO con un clone di Arduino Nano.

Caricare il firmware GRBL.

Se avete esperienza di Arduino, allora sappiate che il caricamento di GRBL non segue il consueto procedimento per il caricamento degli sketch. Questo perché il codice è molto grande, e per ottimizzarlo è stata scelta una strada diversa, quella di caricare direttamente l'eseguibile .HEX.

Ma non spaventatevi: è stata prevista una strada più facile, ovvero installare una libreria e lanciare il file di esempio che come sempre accade accompagna la libreria. Questa libreria è in realtà il firmware ottimizzato, e lo sketch di esempio consiste in un semplice #include.

Non è necessario scaricare nulla da Internet. Andate sull'IDE di Arduino e aprite il menu Sketch>Include Library>Manage Libraries… :

Nella finestra che compare ricercate GRBL. Selezionatelo ed installatelo:

A questo punto aprite lo sketch di esempio File>Esempi>GRBL>GRBLupload e caricatelo. Punto.

GRBL: l'hardware.

L'Arduino, UNO o Nano che sia, ha comunque bisogno di un minimo di circuiteria esterna e di essere collegato ai driver per poter funzionare. Ho quindi buttato giù questo schema elettrico minimale che una volta montato su basetta millefori si è rivelato molto funzionale:

Oltre all'Arduino Nano e ai tre moduli A4988, sullo schema prendono posto pochissimi componenti: alcuni condensatori elettrolitici e un 7805 per generare i 5V a partire dall'alimentazione dei motori. Non mi fidavo ad usare il LDO presente sull'Arduino Nano, sia perché deve alimentare i tre driver sia perché potrei aver necessità di usare tensioni maggiori di 12V come tensione per i motori. E poi ho un cassetto pieno di 7805, così ne sfrutto uno…

Come è possibile vedere dallo schema, i moduli driver hanno due alimentazioni: una a 5 Volt per la logica ed una a 12 Volt per l'alimentazione dei motori. Su quest'ultima alimentazione è bene montare un condensatore elettrolitico da 100µF per smorzare i disturbi generati dai motori. I pin indicati MS1,2 e 3 servono per impostare il microstepping. Hanno una resistenza di pull down interna, in questo modo con tutti e tre i pin scollegati la funzione microstepping è disabilitata e ad ogni impulso in ingresso corrisponde ad uno step intero del motore. Per impostare il miscrostepping i pin vanno collegati al positivo secondo questa tabella:

Il mio suggerimento è di usare ponticelli di stagno in modo che una volta impostato non ci sia il rischio che a causa delle vibrazioni i ponticelli rimovibili abbiano problemi di falsi contatti. Lo stesso suggerimento vale anche per tutte le altre connessioni al PCB: una saldatura previene eventuali problemi che potrebbero sorgere con i connettori.

Il pin ENABLE dei driver serve per disabilitare l'alimentazione ai motori (anche da fermi nei motori circola corrente), e vengono controllati dal GRBL attraverso l'apposita uscita. Ciò è utile in caso di emergenza per bloccare istantaneamente i motori. Molto importante è collegare insieme i pin RESET e SLEEP, in caso contrario il modulo resta sempre in sleep e non riceve i comandi.

Dall'Arduino, oltre ai comandi STEP, DIR ed ENABLE per ogni asse, abbiamo altri ingressi ed uscite:

• INGRESSO LIMIT X,Y,Z per i microswitch di fine corsa per i tre assi X,Y,Z. Per ogni asse monteremo una coppia di switch in parallelo, uno per ogni estremo della corsa, che permetteranno al GRBL di proteggere la macchina.
• INGRESSO PROBE per la sonda tastatrice. Questa sonda è un semplice contatto che l'utensile fa col pezzo per verificare l'altezza del pezzo stesso da lavorare. Per funzionare si collega il pin all'utensile con un coccodrillo, ed il pezzo metallico da lavorare a massa. Se il pezzo fosse di legno o altro isolante, si può porre sul pezzo un sottile foglio di carta stagnola collegato a massa.
• INGRESSO RESET/ABORT: pulsante di emergenza per bloccare l'esecuzione del programma. ATTENZIONE! Non si tratta di un reset dell'Arduino, in quanto quest'ultimo non blocca i driver e potrebbe portare a comportamenti imprevedibili dei motori.
• INGRESSO FEED HOLD: pulsante che sospende temporaneamente l'esecuzione del G-Code, senza perdere la posizione dell'utensile. Utile in caso di bisogni fisiologici impellenti o per pulire l'area dai trucioli.
• INGRESSO CYCLE START/RESUME: pulsante per far ripartire il progrmma sospeso precedentemente con Feed Hold.
• USCITA COOLANT: a questa uscita va collegato attraverso un relè o un mosfet adeguato il sistema di pompaggio del liquido di raffreddamento, se la vostra macchina ne è provvista.
• USCITA SPINDLE PWM: questa uscita permette di controllare l'accensione e la velocità del mandrino dell'utensile. Ovviamente il motore della fresa deve essere provvisto di un idoneo ingresso o deve essere interposto un sistema di controllo a mosfet per pilotare il motore in PWM.
• USCITA SPINDLE DIRECTION: in abbinamento al precedente, questa uscita è utile per invertire il senso di rotazione del motore del mandrino, se il vostro sistema lo supporta
• USCITA/INGRESSO SERIALE: il progetto originale del GRBL non fa uso di questi terminali TX/RX direttamente, in quanto i comandi G-Code vengono ricevuti attraverso l'USB>Seriale montato a bordo dell'Arduino. Tuttavia nella mia realizzazione ho voluto portar fuori questi pin per un eventuale futuro controllo manuale della macchina, che penso di descrivere nella terza parte di questo tutorial.

Tutti gli ingressi hanno una resistenza di pullup, quindi è sufficente un contatto verso massa per attivarli.

Riguardo alle uscite, nel mio caso non potendo regolare la velocità del motore se non manualmente e non avendo un sistema di raffreddamento, per ora resteranno inutilizzate.

Come già accennato, per l'alimentazione di tutto il circuito ho usato una tensione di 12 Volt. la mia scelta è caduta su un vecchio alimentatore da PC portatile, in grado di fornire poco più di 4 Ampere che alla prova pratica si sono rivelati più che sufficienti per controllare i tre motori.

PCB. 

Anche se sto usando ancora il prototipo montato su millefori, ho disegnato anche un circuito stampato per questo controller/driver. Come di consueto prediligo gli stampati monofaccia, più semplici e veloci da realizzare.

Configurazione di GRBL.

Il firmware GRBL, prima di essere utilizzato a pieno, ha bisogno di essere informato riguardo alle caratteristiche della nostra macchina utensile. Ad esempio quanti step servono per muovere un determinato asse di un millimetro, quanto è la corsa massima di ogni asse, se ci sono collegati o meno determinati accessori.

Questa configurazione viene fatta inviando tramite USB dei comandi specifici per GRBL, comandi che nulla hanno a che vedere con il G-Code. La configurazione viene memorizzata sulla EEPROM interna dell'Arduino e normalmente non è necessario modificarla una volta che è stata configurata correttamente.

Per la configurazione, basta collegare l'Arduino col firmware GRBL alla porta USB che usiamo per programmare Arduino, apriamo uno sketch anche vuoto e apriamo il serial monitor, impostando il baud rate a 115200 Se tutto ha funzionato durante la programmazione, otterremo questa risposta:

.

Ad ogni "return" GRBL risponde con OK. Per conoscere la configurazione corrente basta scrivere $$ e premere invio. Il carattere $ non fa parte dei comandi G-Code, quindi è stato scelto come carattere di inizio per i comandi dedicati di GRBL. $$ significa "mostrami la configurazione corrente. Otterremo qualcosa di simile:

$0=10
$1=25
$2=0
$3=0
$4=0
$5=0
$6=0
$10=1
$11=0.010
$12=0.002
$13=0
$20=0
$21=0
$22=0
$23=0
$24=25.000
$25=500.000
$26=250
$27=1.000
$30=1000
$31=0
$32=0
$100=200.000
$101=200.000
$102=200.000
$110=500.000
$111=500.000
$112=500.000
$120=10.000
$121=10.000
$122=10.000
$130=134.000
$131=46.000
$132=80.000

Ogni riga è un parametro diverso, per modificarli basta scrivere $n=val. Ad esempio, se desidero modificare il parametro $0 da 10 a 20, scriverò $0=20, seguito da enter. Se la modifica è andata a buon fine, GRBL restiuirà OK, e al successivo comando $$ potremmo leggere il nuovo valore. Ma vediamo tutti i parametri in dettaglio, con il valore di default tra parentesi:

• $0 Step Pulse µs (10): è la durata dell'impulso inviato ai motori, espresso in microsecondi. Un valore più basso ci permette di inviare più impulsi al secondo al motore che quindi avrà una maggiore velocità massima. Ma un valore troppo piccolo potrebbe far saltare passi al motore o avere comportamenti imprevedibili. Se avete il datasheet del motore potete inserire il valore riportato nel datasheet, altrimenti potreste procedere sperimentalmente. Io ho lasciato il valore di default di 10 microsecondi.
• $1 Step Idle Delay mS (25): dopo che un impulso è stato inviato ad un motore, il driver viene disattivato. Per consentire al motore di completare la rotazione, si può impostare un ritardo di un certo numero di microsecondi prima della disattivazione. Inoltre è possibile mantenere i driver sempre  attivi impostando il valore 255. Quest'ultima impostazione è utile con alcuni driver impostat col microstep, in quanto questi si "dimenticano" il valore dei microstep quando vengono disattivati causando perdite di passi. Quindi: microstep? $1=255.
• $2 Step Port Invert (0): Gli impulsi di STEP generati da GRBL sono positivi, che significa che durante l'impulso la tensione sul pin d'uscita dell'Arduino è 5V. Alcuni driver possono richiedere invece un segnale invertito, e per farlo possiamo inserire un valore che va da 0 a 7 nel parametro $2, dove 0 significa "tutte le uscite non invertite" e 7 "tutte le uscite invertite". Per combinazioni diverse, ecco una tabella che aiuta nella comprensione:

  Valore	Maschera	Inversione X	inversione Y	Inversione Z
  0	00000000	N	N	N
  1	00000001	Y	N	N
  2	00000010	N	Y	N
  3	00000011	Y	Y	N
  4	00000100	N	N	Y
  5	00000101	Y	N	Y
  6	00000110	N	Y	Y
  7	00000111	Y	Y	Y

• $3 – Direction port invert (0): non sempre una volta collegati i motori, questi ruotano nella direzione che ci eravamo prefissati. Per non rifare tutti i cablaggi, è possibile invertire il senso di rotazione di ogni singolo asse intervendo sul parametro $3. Il parametro accetta valori da 0 a 7 e per invertire la rotazione di ogni motore possiamo far riferimento alla stessa tabella del parametro precedente.
• $4 – Step Enable Invert (0): anche il pin "enable" potrebbe aver bisogno di essere invertito per funzionare, in tal caso basta porre il parametro a 1.
• $5 – Limit pins inverted (0): anche il segnale presente sui pin dei microswitch di protezione potrebbe richiedere di essere invertito, in questo caso basta mettere il valore 1
• $6 – Probe Pin Invert (0): stesso discorso per l'inversione del pin della sonda tastatrice.
• $10 – Status Report (1): Quando inviamo il carattere "?" a GRBL, questi risponde con una serie di valori che identificano lo stto di funzionamento, la posizione, la velocità corrente di spostamento, lo stato dei pin, lo stato di riempimento del buffer ed il numero di linea del G-Code in esecuzione. Ognuno di questi dati viene mostrato solo se è cambiato rispetto alla precedente richiesta, in modo da ridurre la quantità di dati da trasmettere. .
• $11 Junction deviation, mm
• $12
• $13
• $20
• $21
• $22
• $23
• $24
• $25
• $26
• $27
• $30
• $31
• $32 – Laser mode (0): Attiva la modalità laser. Esiste un documento sul sito GRBL che descrive questa modalità. Il valore 0 disattiva il laser mode, 1 lo attiva. Non essendo al momento di mio interesse, non approfondisco. 
• $100, $101, $102– [X,Y,Z] (steps/mm): questo parametro serve a dire a GRBL quanti passi servono per effettuare lo spostameneto di un millimetro. Nel mio caso ad ogni giro della manopola si ottiene lo spostamento di un millimetro, uguale per ogni asse. Poiché i miei motori fanno 200 passi per ogni rotazione, ho inserito il valore 200. Se avessi attivato il microstep 1/2, avrei ottenuto 400 passi per ogni rotazione, e avrei inserito questo valore.
• $110, $111, $112 – [X,Y,Z] Max rate, (mm/min): è la massima velocità di traslazione per ognuno dei tre assi, e si trova sperimentalmente aumentando il valore fino a che il motore non perde i passi o si blocca. A questo punto si abbassa il valore ottenuto di un 15%-20%.
• $120, $121, $122 – [X,Y,Z] Acceleration, (mm/sec²⁾: è il valore dell'accelerazione dei motori sui tre assi. Anche questo si trova sperimentalmente, un asse alla volta, aumentando il valore fino a che il motore non si blocca o salta passi. A questo punto si abbassa il valore ottenuto di un 15%-20%.
• $130, $131, $132 – [X,Y,Z] Max travel, (mm): Questi parametri identificano la massima corsa in millimetri sui tre assi dell'utensile. Vanno misurati fisicamente sulla vostra CNC, nel mio caso sono 134, 46, 80. 

Ecco la lista dei comandi di configurazione con il rispettivo significato:.

La realizzazione.

E finalmente, dopo tante foto prese da Internet, ecco le foto della mia realizzazione e un po' di commenti sui dettagli.

Il circuito è abbastanza semplice, la prima versione l'ho realizzata su basetta millefori. Una delle mie preoccupazioni sono state le vibrazioni, sempre presenti in una macchina utensile, e per questo ho scelto di saldare tutte le connessioni possibili evitando i connettori interni, e per i connettori esterni usare quelli con un sistema di bloccaggio  .

— COMPRENDERE LA CNC —

Gli assi.

Una CNC può avere un numero variabile di assi, da uno a diverse decine, ma il minimo per poter lavorare oggetti tridimensionali è tre assi.

A ogni asse ovviamente corrisponde un motore. Per la mia fresa gli assi sono tre, chiamati X, Y e Z. La direzione standard di questi assi è definita in questo disegno:

. 

Ovviamente si tratta solo di una convenzione, ma se non la rispettiamo si rischia di avere problemi quando andiamo a realizzare oggetti disegnati da altri, oppure di ottenere oggetti "rovesciati" rispetto a quello che ci si aspetta.

Il sistema di coordinate.

Uno degli aspetti più ostici in una CNC è comprendere il sistema di coordinate.

Provare la CNC.

Qui finisce la prima parte di questo articolo, anche perché al momento qui mi sono fermato. Se mi avete seguito fino qui magari avrete voglia di provare quanto realizzato finora, giusto?

Vi anticipo che, prima di immergermi a studiare G-Code, CAM ed altre amenità software, ho scaricato da Internet alcuni semplici programmini che consentono di inviare comandi G-Code e file completi verso la CNC. Giusto il minimo per verificare che i movimenti funzionino regolarmente come teorizzato, e togliersi la voglia di fresare qualcosa…

Riferimenti.

Riporto qui di seguito un po' di link utili per chi volesse approfondire:.

https://github.com/gnea/grbl  Il sito principale di GRBL

https://github.com/gnea/grbl/wiki Il Wiki di GRBL, con tutte le istruzioni per l'uso.

.