Cosa sono i PID e l’autotune

2 votes, average: 5.00 out of 52 votes, average: 5.00 out of 52 votes, average: 5.00 out of 52 votes, average: 5.00 out of 52 votes, average: 5.00 out of 5 (2 votes, average: 5.00 out of 5)
You need to be a registered member to rate this post.
Loading...

PID sta per Proporzionale – Integrale – Derivata. Cerchiamo di capire cosa sono questi paroloni e cosa vogliono dire.

Se in un controllo automatizzato di temperatura usassimo un sistema semplice cioè quello di staccare il riscaldatore una volta raggiunta la temperatura voluta cosa accadrebbe?

Il riscaldatore, nel nostro caso una resistenza, conserverebbe ancora per un po della sua energia continuando a riscaldare il nozzle facendo superare la temperatura  impostata di alcuni gradi. Una volta persa la sua energia comincerebbe a raffreddarsi rifacendo scendere la temperatura del nozzle. A questo punto appena la temperatura rilevata scende al di sotto della temperatura impostata il circuito di controllo dovrà riaccendere il riscaldatore, ma quest’ultimo avrà un tempo t prima di tornare ad avere una energia tale per far risalire la temperatura del nozzle. Quindi la temperatura oscillerà di un dT rispetto alla temperatura impostata.

Oscillazione

Quindi questo metodo non è funzionale per il nostro scopo.

Si pilota, invece, la resistenza con un’onda di tipo PWM (Pulse Width Modulation) cioè un’onda quadra in cui quello che varia è il tempo in cui ha valore alto rispetto al tempo che ha un valore basso:

PWM

All’inizio quando il resistore è freddo il Duty Cycle sarà del 99%, cioè un impulso con una lunga durata alto e praticamente nulla basso.

Man mano che la temperatura si avvicina a quella impostata il Duty Cycle diminuirà, in questo modo la resistenza non avrà troppa energia per superare la soglia della temperatura impostata, ma ne avrà a sufficienza per essere ancora calda e tornare a scaldarsi per non scendere troppo al di sotto sempre della temperatura impostata.

Ma come fa il sistema a gestire questo Duty Cycle? Ecco che intervengono i valori PID di cui stiamo parlando.

Il valore Proporzionale (P) o Kp è una costante che è uguale a Conteggi/C, cioè di quanto deve variare l’uscita PWM rispetto a quanto si discosta la temperatura rilevata, sia in alto che in basso, a quella impostata. Un valore troppo basso rende la curva di salita più morbida, ma il controllo è meno reattivo a variazioni di temperatura. Mentre un valore troppo alto di Kp rende il sistema più reattivo, con una curva molto instabile rispetto al target:

PID_Kp

A questo punto si è portati a pensare che basta trovare il giusto valore di Kp, in effeti è già un parametro che fa molto per tenere la temperatura stabile, ma grazie anche agli altri due si arriverà ad avere una vera stabilità.

Il valore Integrale (I) o Ki rappresenta l’integrale dell’errore nel tempo dato dal parametro Kp. Questo parametro serve per variare il guadagno del controllo di temperatura per fare in modo che si acceleri il processo verso la temperatura impostata.

La derivata del processo di errore viene calcolata determinando la pendenza dell’errore nel tempo, questo valore viene moltiplicato per la costante Kd. La derivata predice il comportamento del sistema e migliora così tempo e stabilità del sistema stesso.

Qui di seguito vediamo una gif che spiega abbastanza bene quello che accade variando i tre parametri Kp, Ki e Kd:

PID_Compensation_Animation

Dopo questa spiegazione generale torniamo alle nostre stampanti.

Questi valori PID cambiano da Hotend a Hotend e anche da altri fattori esterni, tipo coibentazione del nozzle, areazione e anche velocità di stampa.

Per questo motivo bisogna fare il tuning di questi valori una volta pronta la stampante e ripetere questa operazione ogni tanto, per adeguarli anche all’usura stessa del nostro hotend.

Per fare questo tuning ci viene incontro un comando Gcode:

M303 H<numero hotend> S<temperatura target> C<numero di cicli> U<bolean upgrade>

Nel caso di un solo Hotend si può omettere il valore H, mentre per fare i tuning del BED nel caso volessero essere usati si mette il valore -1 come H (H-1).

La temperatura target di default è 150 e il numero di cicli di default è 5. Più cicli migliorano la stabilità, ma già 5 è un ottimo valore. Quindi il comando finale sarà:

M303 S200 C6

M303 H0 S210

M303 H1 C8

Per il Bed:

M303 H-1 S100 C5

Una cosa importantissima e fare questo controllo partendo da una temperatura ambiente del nozzle.

Alla fine il FW ci restituirà i tre valori Kp, Ki e Kd. A questo punto se abbiamo precedentemente attivato la EEPROM e usato il sotto comando U1 (upgrade istantaneo dei valori) possiamo salvare i nuovi valori subito con il comando M500 e quindi avere già il nostro hotend funzionante anche le prossime volte che accenderemo la stampante, altrimenti dobbiamo copiarci i valori e metterli nel FW ricompilare il tutto e scaricalo nella nostra scheda.

Nel file Configuration_Feature.h alla sezione PID troviamo:

// HotEnd{HE0,HE1,HE2,HE3}
#define DEFAULT_Kp {40, 40, 40, 40} // Kp for H0, H1, H2, H3
#define DEFAULT_Ki {07, 07, 07, 07} // Ki for H0, H1, H2, H3
#define DEFAULT_Kd {60, 60, 60, 60} // Kd for H0, H1, H2, H3

Qui mettiamo i tre valori per ogni hotend che abbiamo. I valori possono anche essere cambiati con il comando Gcode:

M301 H<hotend> P<Kp> I<Ki> D<Kd>

Mentre per il Bed il comando Gcode è:

M304 P<Kp> I<Ki> D<Kd>

Se usiamo il PLA e abbiamo una ventilazione molto forte, questa potrebbe influire sull’andamento della curva della temperatura se il nostro hotend non è perfettamente coibentato, per questo motivo meglio fare l’autotuning con le ventole accese, in questo modo i PID vengono calcolati tenendo conto dell’influenza dell’aria sul nozzle.

Il FET sulle schede controlla la resistenza in corrente, quindi se alimentiamo la board a 24V per esempio ai capi della resistenza ci saranno 24 V, ma possiamo limitare la corrente tramite il valore:

#define BANG_MAX 255       // limits current to nozzle while in bang-bang mode; 255=full current

255 è la massima corrente, abbassando il valore limitiamo la corrente che circolerà nella nostra resistenza, se per esempio non è idonea a lavorare a 24V.

Purtroppo il tuning dei PID non tiene conto della velocità di stampa e quindi il movimento del nozzle stesso e della velocità in cui arriva un filamento a temperatura ambiente. Quindi aumentando la velocità potremmo avere un abbassamento della temperatura e una conseguente alterazione della curva. Per aggiustare questo inconveniente ci viene incontro sempre il FW MK che ha anche il parametro Kc, un valore che varia la potenza in uscita in funzione della velocità di estrusione. Kc è in percentuale quindi 100 vuol dire il 100%, possiamo incrementarlo se abbiamo problemi di stampa a determinata velocità. Il valore può essere cambiato con il comando Gcode:

M301 H<hotend> C<Kc>.

Un altro valore è la Lag per PID tick un parametro superato il quale deve calcolare il nuovo valore di potenza in uscita. Il valore Lag si varia con il comando Gcode:

M301 H<Hotend> L<lag in PID tick>

che però non potrà mai superare LPQ_MAX_LEN, di default è impostato a 20 nel FW.

Anche questi due ultimi valori vengono memorizzati in EEPROM se attivata. Per attivare Kc dobbiamo decommentare:

#define PID_ADD_EXTRUSION_RATE

Quindi ricordatevi di fare il l’autotune dei PID e di rifarlo spesso per avere sempre delle buone stampe.

MagoKimbra…

Color Mixing Extruder

1 vote, average: 5.00 out of 51 vote, average: 5.00 out of 51 vote, average: 5.00 out of 51 vote, average: 5.00 out of 51 vote, average: 5.00 out of 5 (1 votes, average: 5.00 out of 5)
You need to be a registered member to rate this post.
Loading...

Oltre al noto flusso canalizzatore di Immagina e Crea, esiste un altro metodo per stampare a colori. Questo sistema prevede un hotend con nozzle in grado di sciogliere più di un filo e di conseguenza miscelare i vari colori.

diamond-hotend-prints[1]

MarlinKimbra o MK4due consente l’uso anche di questo sistema vediamo come.

Innanzitutto dobbiamo sapere quanti estrusori veri monteremo sulla nostra stampante, per esempio se monteremo un Diamond Hotend dobbiamo avere tre estrusori, ma essendo quest’ultimi facenti parte di un insieme il FW lo vedrà come unico estrusore.

In Configuration_Basic.h settiamo quindi a 1 il numero di estrusori:

/***********************************************************************
************************** Extruders number ***************************
***********************************************************************/
// This defines the number of extruder real or virtual
#define EXTRUDERS 1

Ma avendo fisicamente tre motori settiamo a tre DRIVER_EXTRUDER:

// This defines the number of Driver extruder you have and use
#define DRIVER_EXTRUDERS 3

Ora apriamo il file Configuration_Feature.h e abilitiamo COLOR_MIXING_EXTRUDER:

#define COLOR_MIXING_EXTRUDER

E settiamo quanti Tools virtuali abbiamo, i tools virtuali sarebbero i nostri colori mixati, come se avessimo n fili ognuno con un colore ben definito. Per ora lasciamo a 16.

// Use the Virtual Tool method with M163 and M164
#define MIXING_VIRTUAL_TOOLS 16

Abbiamo sempre un solo hotend quindi abilitiamo sempre la voce SINGLENOZZLE:

#define SINGLENOZZLE

Ora il nostro firmware è pronto, è inutile dire che in questo caso a differenza degli altri sistemi, vedi MKR4, NPr2 o il Dondolo il numero dei driver per gli estrusori deve essere per forza il numero di motori che vogliamo mettere, quindi nel caso del Diamond ci servirà una scheda con 3 driver per gli estrusori, l’Alligator con la piggy può esserci utile.

Dopo aver scaricato il FW nella nostra scheda e collegata a un host settiamo i nostri parametri. Prima di tutto dobbiamo definire i colori, questo perché per ora le informazioni non ci arrivano dagli slicer, l’unica informazione è il Tools T0 – T1 – T2 etc etc.

Immaginiamo di avere i classici tre colori Red – Green – Blu su i tre estrusori. Passiamo a creare i Tools, ne abbiamo 16 vi ricordate, virtuali.

Iniziamo a spiegare i comandi:

M163 S[index] P[mix value], con questo comando diciamo che usiamo l’estrusore[index] di un valore[mix value], il valore è un numero con la virgola compreso tra 0 e 1, dove 1 sta per il 100% e 0 per lo 0%. Per capirci il colore finale sarà composto da una percentuale di E0 + una percentuale di E1 + una percentuale di E2 e il totale deve fare 100%. Questo è dovuto al fatto che oltre a stampare di un certo colore noi cmq dobbiamo estrudere un valore fisso di materiale che deve comporre il nostro oggetto. Quindi se l’oggetto è fatto di rosso l’estrusione sarà del 100% di E0 + 0% di E1 + 0% di E2, se invece è un colore X avrà valori diversi per ogni estrusore, ma sempre il 100% di materiale deve estrudere.

Quindi creiamo il primo Tools T0, che sarà di Rosso.

M163 S0 P1 ; 100% Red
M163 S1 P0 ; 0% Green
M163 S2 P0 ; 0% Blu

Ora salviamo questa combinazione di colori nel nostro Tools T0 si usa il comando:

M164 S[index], dove l’index è il nostro Tools, quindi:

M164 S0 ; Store color mixing in tools T0

Ora creiamo il Tools Green:

M163 S0 P0 ; 0% Red
M163 S1 P1 ; 100% Green
M163 S2 P0 ; 0% Blu

E salviamolo sul Tools T1:

M164 S1 ; Store color Mixing in Tools T1

Creiamo il Tools T2 Blu:

M163 S0 P0 ; 0% Red
M163 S1 P0 ; 0% Green
M163 S2 P1 ; 100% Blu

E salviamolo sul Tools T2:

M164 S2 ; Store color Mixing in Tools T2

Creiamo un Giallo:

M163 S0 P0.5 ; 50% Red
M163 S1 P0.5 ; 50% Green
M163 S2 P0 ; 0% Blu

E salviamolo sul Tools T3:

M164 S3 ; Store color Mixing in Tools T3

Creiamo un Viola:

M163 S0 P0.5 ; 50% Red
M163 S1 P0 ; 0% Green
M163 S2 P0.5 ; 50% Blu

E salviamolo sul Tools T4:

M164 S4 ; Store color Mixing in Tools T4

Creiamo un Celeste:

M163 S0 P0 ; 0% Red
M163 S1 P0.5 ; 50% Green
M163 S2 P0.5 ; 50% Blu

E salviamolo sul Tools T5:

M164 S5 ; Store color Mixing in Tools T5

Creiamo un Arancio:

M163 S0 P0.7 ; 70% Red
M163 S1 P0.3 ; 30% Green
M163 S2 P0 ; 0% Blu

E salviamolo sul Tools T6:

M164 S6 ; Store color Mixing in Tools T6

Ora senza fare tutta la palette colori mi sembra abbastanza chiaro come definire un colore e come memorizzarlo su di un tools virtuale.
A questo punto apriamo Host e settiamo la stampante con 16 estrusori, magari mettiamo per ogni estrusore l’esatto colore che abbiamo messo nei nostri Tools cosi è più chiaro. Importiamo il nostro oggetto e settiamo per ogni parte che ci interessa un Tools (estrusore). Per farvi capire ho messo 7 pezzi di colore diverso da 1 a 7.

Color_mixing

Facciamo lo slicing e mandiamo in stampa. A ogni cambio di Tools (estrusore) il FW non lo interpreta come un vero è proprio cambio di estrusore, ma applicherà la percentuale decisa per quel Tools ai tre estrusori. Per farvi capire se arriva un comando G1 E1, quindi estrudi 1 mm e stiamo usando il Tools T0, l’estrusore E0 estruderà 1 mm e gli altri due 0. Mentre se stiamo usando il Tools T4 (Giallo) l’estrusore E0 estruderà 0,5 mm, l’estrusore E1 0,5 mm e l’estrusore E2 0 mm, quindi sempre 1 mm di materiale uscirà dal nozzle, ma di colore giallo.

La sequenza di comandi M163 e M164 può essere aggiunta all’inizio del gcode o inserita nello start gcode in modo da poter salvare il gcode finale nella sd con gli esatti colori voluti.

Buon divertimento.

MagoKimbra.

 

 

Più estrusori con un solo driver con il sistema MKR4.

2 votes, average: 5.00 out of 52 votes, average: 5.00 out of 52 votes, average: 5.00 out of 52 votes, average: 5.00 out of 52 votes, average: 5.00 out of 5 (2 votes, average: 5.00 out of 5)
You need to be a registered member to rate this post.
Loading...

ATTENZIONE!!! Questo articolo è vecchio. Il sistema MKR4 è stato sostituito con il più nuovo sistema MKR6 che permette l’uso di 6 estrusori con due driver e soli 2 pin d’abilitazione, sempre con l’uso di una scheda a 8 relé. A presto la guida.

 

Questo articolo spiega come si può far funzionare fino a 6 estrusori con una normalissima scheda che ha un solo driver per estrusori.

Prima cosa bisogna acquistare una scheda arduino da 6 o più relè. Verificare che sia optoisolata e funzionate a 5v.

Esempio:

SainSmart-8-Channel-DC-5V-Relay-01[1]

Una volta fatto questo abilitiamo MarlinKimbra o MK4due a questa funzione, per prima cosa diciamo al FW che abbiamo 4 estrusori:

/***********************************************************************
************************** Extruders number ***************************
***********************************************************************/
// This defines the number of extruder real or virtual
#define EXTRUDERS 4

Poi definiamo che abbiamo un solo driver per gli estrusori:

// This defines the number of Driver extruder you have and use
#define DRIVER_EXTRUDERS 1

A questo punto andiamo in Configuration_Feature.h e abilitiamo MKR4:

/***********************************************************************
************************* Multiextruder MKR4 **************************
***********************************************************************
* *
* Setting for more extruder width relay system *
* See Configuration_pins.h for pin command relay *
* *
* Uncomment MKR4 to enable this feature *
* *
* Uncomment INVERTED_RELE_PINS if your relay switches with GND *
***********************************************************************/
#define MKR4
//#define INVERTED_RELE_PINS
/***********************************************************************/

C’è anche la possibilità di invertire il segnale per far scattare i relè se per caso si attivano con livello basso…

Dobbiamo anche dire al Firmware che pur avendo 4 estrusori però abbiamo un solo Hotend, quindi sempre in Configuration_Feature.h abilitiamo Singlenozzle:

/***********************************************************************
**************************** Single nozzle ****************************
***********************************************************************
* *
* This is used for single nozzle and multiple extrusion configuration *
* *
* Uncomment SINGLENOZZLE to enable this feature *
* *
***********************************************************************/
#define SINGLENOZZLE
/***********************************************************************/

Tutto questo lo possiamo fare in maniera semplice e rapida con il configuratore on line che trovate qui sul blog.

Ora per concludere la parte Firmware andiamo in Configuration_Pins.h e diciamo al Firmware quali sono i pin che servono per far scattare i relè. Per ogni estrusore oltre E0 ci vuole 1 pin, quindi nel nostro caso abbiamo bisogno di 3 pin per E1, E2 e E3:

#define E0E1_CHOICE_PIN 4
#define E0E2_CHOICE_PIN 5
#define E0E3_CHOICE_PIN 6

Questi tre pin sono un esempio, ma cambiano da scheda in scheda. Per la Ramps 1.4 si possono usare i pin per i servo lasciando il pin 11 per un eventuale servo bed level.

Ora passiamo al cablaggio, prendiamo i 4 fili che escono dal driver E0 e li colleghiamo in questa maniera:

MKr4 collegamenti new

Come vedete è abbastanza semplice. Il nero che esce dal driver lo colleghiamo in parallelo su tutti i cavi neri dei vostri 4 motori, stessa cosa facciamo per il rosso. Il nero e il rosso sono l’uscita A1 e B1 del driver, quindi 1 di una coppia e l’altro dell’altra coppia.

Mentre A2 il verde e B2 il blu li andiamo a mettere sul centrale dei due primi relè. I Normalmente Chiusi dei due primi relè li andiamo a collegare al verde e blu del primo motore che sarebbe E0, in questo modo quando i relè sono nella situazione tutti non eccitati il motore che andremo a controllare sarà appunto E0.

I Normalmente Aperti dei due primi relè andranno sui centrali della prossima coppia di relè, mi raccomando non invertite le coppie, mantenete la connessione a due a due…

I Normalmente Chiusi della seconda coppia andranno al verde e blu del secondo motore E1.

I Normalmente Aperti andranno a servire la successiva coppia sempre sul centrale.

I Normalmente Chiusi della terza coppia andranno al verde e blu del terzo motore E2.

I Normalmente Aperti andranno al quarto motore E3, nel caso avessimo più estrusori ripeteremo l’operazione dei precedenti, quindi non andranno al motore bensì ai centrali della prossima coppia…

E’ facilmente intuibile che a secondo di quanti estrusori vogliamo montare basta diminuire o aumentare di due i relè.

La prima coppia serve per commutare tra E0 e seconda coppia.

La seconda coppia serve per commutare tra E1 e terza coppia. Nel caso volessimo solo 3 estrusori ci possiamo fermare qui mettendo al posto della terza coppia i fili al terzo motore.

La terza coppia serve per commutare tra E2 e E3 o quarta coppia per andare avanti con gli estrusori.

I relè vanno alimentati con una 12v fissa da prendere dall’alimentatore, poi hanno degli ingressi per farli commutare, in questo caso visto che dovranno commutare a coppie dovremmo collegarli tra loro l’in 1 e 2, l’in 3 e 4, l’in 5 e 6. Poi dobbiamo portare i 3 pin scelti per farli scattare E0E1_CHOICE_PIN, E0E2_CHOICE_PIN e E0E3_CHOICE_PIN.

Fatto tutto ciò possiamo alimentare la nostra scheda e dopo aver compilato e scaricato il fw passiamo alla fase di test.

Se abbiamo fatto tutto come si deve dovremmo avere questo risultato: Se ci colleghiamo con Host i relè dovrebbero rimanere tutti nello stato di quiete, ma se passiamo da E0 a E1 dovremmo sentire commutare i primi due relè, ce ne possiamo accorgere dai led che di solito sono montati sulla schedina relè.

Se passiamo da E1 a E2 vedremo scattare anche la seconda coppia di relè e infine come passiamo da E2 a E3 scatterà l’ultima coppia di relè.

A questo punto possiamo provare il tutto. disabilitiamo il controllo di temperatura con il comando M302, questo fa in modo che possiamo estrudere anche se la temperatura dell’hotend non è al di sopra del minimo…

Proviamo a estrudere con ogni singolo estrusore, sentirete i relè commutare ogni qualvolta cambiate estrusore.

Di seguito un video che mostra la scheda Alligator che senza la piggy controlla 3 Bulldog XL. Buon divertimento.

MagoKimbra.

EEPROM cos’è e come si usa

0 votes, average: 0.00 out of 50 votes, average: 0.00 out of 50 votes, average: 0.00 out of 50 votes, average: 0.00 out of 50 votes, average: 0.00 out of 5 (0 votes, average: 0.00 out of 5)
You need to be a registered member to rate this post.
Loading...

Faccio una piccola guida sull’uso della EEPROM sulle schede e come i FW lo usano…
Per quanto riguarda Marlin e MK si abilita con la riga:

#define EEPROM_SETTINGS

Una volta abilitata il fw userà la eeprom per alcuni dati, sopratutto quelli di movimento, per esempio gli step per mm, i feedrate, le accelerazioni etc etc. Più alcuni altri dati come i pid e le geometrie della delta.
Questa eeprom non è altro che una memoria riscrivibile, ma che non si cancella con un nuovo download del fw. Ricordatevelo non si cancella, può essere solo riscritta…
Nelle memorie non c’è scritto il dato a cosa corrisponde è il fw che sa come è catalogato… I dati vengono memorizzati in byte e quindi si leggono o in binario o in esadecimale..
Facciamo un esempio con una memoria da 10 byte:

00 50 00 50 00 50 02 71 01 2C

Ora cosa sono questi dati?
Sono dei valori esadecimali, ma a cosa corrispondono?
Il fw sa come leggerli e li legge. Per esempio legge un step per mm (X, Y, Z, E) sono numeri interi un intero occupa 2 byte, quindi prende i primi due dati e li trasforma in intero, 00 50 in decimale corrisponde a 80, stessa cosa vale per i prossimi due, 00 50 -> 80 e cosi via.
Ma se invece di leggere step per mm leggo altro quei numeri corrisponderanno a altro. Questo non va bene quindi la prima cosa che devo leggere è qualcosa che dice al FW si questa struttura di eeprom l’ho scritta io e quindi conosco la struttura..
Quindi il FW la prima cosa che scrive è una specie di check che poi leggerà e se corrisponde a quella che ha sa che il fw corrisponde..
Se guardate in configuration_store.h trovate:

#define EEPROM_VERSION "V25"

/**
 * V25 EEPROM Layout:
 *
 *  ver
 *  M92   XYZ E0 ...      axis_steps_per_unit X,Y,Z,E0 ... (per extruder)
 *  M203  XYZ E0 ...      max_feedrate X,Y,Z,E0 ... (per extruder)
 *  M201  XYZ E0 ...      max_acceleration_units_per_sq_second X,Y,Z,E0 ... (per extruder)
 *  M204  P               acceleration

Come vedete c’è la struttura, e il primo valore è la versione V25.
Quindi quando il FW legge, se trova come primo valore V25 allora dice è una struttura che conosco e la legge…

Prendiamo una scheda nuova, appena comprata, la EEPROM è vuota. Il FW legge e non trova la sua versione quindi non continua e userà i valori messi nel FW stesso…
A questo punto io modifico un parametro per esempio con M92 cambio gli step di X, nel FW è a 80.

M92 X90

Porto il valore degli step per mm di X da 80 a 90. Poi scrivo la EEPROM M500, a questo punto viene scritta tutta la struttura compresa la versione…

Quando riaccendo la scheda, il fw legge la EEPROM trova il suo valore V25 e a quel punto legge i dati, TUTTI, e li sovrascrive a quelli che ha di default.. Quindi dal momento che ho fatto M500 gli step per mm di X saranno a 90, il resto invece visto che non ho cambiato nulla rimane invariato…

Ma decido di aggiornare i driver da i 4988 agli 8825, cambio i valori in step per mm nel fw da 80 per X Y Z a 160.. Scarico nella scheda e succede che mi sballano tutte le misure e mi chiedo perché???
Il perché è semplice, come ho detto prima, la EEPROM non viene cancellata con un download di un nuovo fw, il fw non è cambiato, ma ho solo cambiato quei valori e quindi leggendo la EEPROM trova la sua versione e legge i dati in EEPROM. I dati in EEPROM sono (90, 80, 80), 90 perché lo avevamo cambiato, e i due 80 che erano quelli di default, ed ecco che non ci combina nulla…

Quindi prima cosa è leggere i dati in modo di verificare che tutto sia ok.
M503 fa la lista di tutti i valori e leggendo Step per mm M92 X90 Y80 Z80 ci dovremmo chiedere come mai visto che li ho cambiati nel FW???
Come si fa a rimettere le cose a posto?
Semplice ci sono altri due comandi M502 e M501:

  • M501 Legge i valori in EEPROM e sovrascrive quelli che ha in memoria.
  • M502 legge quelli scritti nel FW e li sovrascive a quelli che ha in memoria.

Quindi facendo M502 metteremo i valori degli step e di tutto il resto apposto, facendo M503 vedremo i nostri valori giusti M92 X160 Y160 Z160…
Ma nella EEPROM ci sono ancora quelli vecchi… Quindi se questi sono quelli giusti basta fare M500 e memorizzare i nuovi valori in questo modo alla prossima accensione i valori saranno quelli giusti X160 etc etc. Ma se non lo facciamo alla prossima accensione torneranno a essere X90 Y80 Z80 ridandoci i problemi…

A questo punto uno si chiede a cosa serve tutto ciò che porta solo problemi… La risposta è semplice, basta conoscere e sapere come si usa… Perché mai si è rifatto un download del FW modificando gli STEP da 80 a 160 invece di usare il comando M92 X160 Y160 Z160 e poi M500 avremmo risparmiato tempo e problemi.. E’ proprio per questo che si usa la EEPROM cambiare i valori senza dover scaricare tutto, naturalmente laddove è possibile…

Cosa serve invece:

#define EEPROM_CHITCHAT

Serve solo a far si che all’accensione si leggano tutti i valori, avete presente quando vi collegate alla stampante viene fuori la lista dei comandi con i relativi parametri. Ecco serve solo a quello. Cmq è sempre possibile leggere i valori M503

ATTENZIONE M503 non legge i valori in EEPROM, legge quelli che sta usando, quelli contenuti nella memoria del processore…

Ora torniamo un attimo a quel discorso della versione.. In MK siamo arrivati a V25, se dovesse cambiare perché il sottoscritto cambia qualcosa nella struttura ecco che al prossimo riavvio la EEPROM non è letta e quindi si perderebbero i valori, quindi controllate se usate la eeprom e magari salvatevi il log dopo un M503 per poter reinserire i valori corretti…
Un’altra cosa, come ho detto prima la prima cosa che viene scritta è la versione quindi V25 che equivale a 3 byte che saranno tra valori esadecimali della conversione ascii in HEX: V25 in hex è 56 32 35.
Ora se per qualche combinazione strana i primi tre valori della eeprom, per esempio se passo da Repetier a MK sono proprio quelli, che magari in repetier avevano un altro senso ecco che per il FW quella è una EEPROM da leggere, ma tutti i valori successivi saranno sballati, quindi step, feedrate, acc etc etc saranno tutti completamente errati.. Cosa si fa in questo caso? Il solito un bel M502 (ricarica quelli del FW) e un bel M500 che cosi pulisce tutto riscrivendo quelli esatti….

Il misterioso caso delle frecce in Repetier-Host o Printrun!!!

0 votes, average: 0.00 out of 50 votes, average: 0.00 out of 50 votes, average: 0.00 out of 50 votes, average: 0.00 out of 50 votes, average: 0.00 out of 5 (0 votes, average: 0.00 out of 5)
You need to be a registered member to rate this post.
Loading...

Vediamo se riusciamo svelare questo misterioso caso, visto che continuo a leggere di persone che si perdono su questo mistero misterioso, la butto sullo scherzo almeno (spero) non c’è nessuno che si offende!!!

Siamo nel mondo 3D, 3 dimensioni, e anche in questo mondo ci sono delle cose ben definite, una di queste è la posizione di un oggetto nello spazio 3D.
Qualsiasi programma usiamo per progettare il nostro oggettino ha ben definito la sua posizione nello spazio, dato dalla pozione zero dei tre assi cartesiani.
Da questa foto possiamo vedere il nostro oggetto posizionato rispetto ai tre assi.

Il punto zero per X, Y e Z è il punto dove si intersecano i tre assi. Tutto lo spazio che si trova nelle direzioni delle tre frecce è positivo, dall’altra parte abbiamo lo spazio negativo.
A noi interessa solo lo spazio positivo, quindi guardando il piano il nostro punto zero è a sinistra – dietro – basso.
Andando a destra aumenterà positivamente la X, andando avanti aumenterà positivamente la Y, andando in alto aumenterà positivamente la Z.
Fino a qui tutto chiaro? Spero di si. Per molti quello che sto dicendo è elementare quindi me ne scuso e non è mio volere offendere nessuno, anzi se qualcuno ha voglia di ampliare il discorso penso che tutto il forum ne sarà grato.

Ora faccio un piccolo salto di argomento, i modelli radiocomandati, chi non ne ha avuto uno nella sua vita? Bene io ho avuto la fortuna di averne molti e di fare competizioni ad alto livello, ma di questo non ce ne può fregare di meno vero???
Ora immaginiamo di guidare un modello di automobile:

Noi siamo il pilota fermo e la macchina gialla deve andare da A a B, quello che dobbiamo fare è solo mandarla dritta. Se la macchina però deve andare da A a C dovremmo girare a destra, se invece deve andare da A a D dovremmo girare a sinistra. Mi sembra abbastanza intuitivo…
Ora nella nuova foto vi faccio vedere cosa succede quando il modello torna indietro venendoci incontro, lo spazio si gira di 180°.

Noi rimaniamo sempre fermi nella nostra posizione, ma il modello si è girato di 180°. Quando vogliamo andare da B ad A sempre avanti dobbiamo andare non è che spingiamo la leva dell’acceleratore all’inverso… Quando vogliamo andare da B a C è il modello che deve girare a sinistra, ricordo abbiamo ruotato lo spazio di 180° quindi non dobbiamo spingere la leva a destra bensì a sinistra. Stessa cosa per andare da B a D è il modello che gira a destra e noi dobbiamo spostare la leva a destra. Questo è quello che normalmente crea problemi a chi per la prima volta prende una radio in mano e guida un modello. Dice ma io voglio girare a destra, si ma è la tua destra, per il modello è la sua sinistra tu devi immaginare di essere sul modello.
Quindi cosa voglio dire, che la direzione di una freccia dipende dal punto di riferimento e no quello che noi vediamo.

Ma torniamo a noi alle nostre splendide stampanti 3D e alle misteriose frecce nei software, qualcuno avrà già capito dove voglio arrivare, ma andiamo per gradi.
Quello che noi spostiamo nello spazio è quella cosa che dovrà disegnare il nostro cubetto nello spazio, quindi dimenticatevi carrelli, motori, assi etc etc, l’unica cosa che noi muoviamo nello spazio è il nozzle, la punta da dove esce il filamento, la punta della nostra matita che dovrà disegnare il pezzo in 3D.
Solo e solo quello noi muoviamo, il resto a noi non interessa.
Quindi spostiamo la nostra punta dal punto 0,0,0 al punto 10,10,10 cosa succede?
Analizziamo le stampanti una alla volta pariamo dalla più comune cartesiana, tipo prusa.
Spostiamo la nostra punta dal punto X = 0 al punto X = 10, dovremmo spostarla a destra rispetto l’origine degli assi cartesiani. Quindi cliccheremo a destra fino al raggiungimento del punto X = 10.
Ora saltiamo per un attimo Y e passiamo a Z, anche qui dobbiamo passare da Z = 0 a Z = 10, quindi cliccheremo sulla freccia in alto per salire di 10 e la nostra punta salirà di 10.
Torniamo a Y, anche qui volgiamo passare da Y = 0 a Y = 10, rispetto al punto 0 dobbiamo andare in avanti di 10 quindi premiamo la freccia avanti, ma la freccia avanti non c’è, visto che il monitor è una superficie 2D la freccia è verso su.
Ma, c’è un ma, il brutto e cattivo progettista di una cartesiana ha bloccato la nostra matita sull’asse y, da li non si schioda manco con i calci (bhe forse con i calci si, però buttiamo la stampante). E quindi cosa succede?
Succede una cosa che ha del paranormale che paranormale non è, è il piano di stampa che si muove, ma se la punta deve andare in avanti rispetto alla nostra posizione invertendo lo spazio di 180°, come nel caso dei modelli, è il piano che verrà verso di noi!!! Wow!!!
Quindi spingendo la freccia Y in alto (davanti) non è il nozzle che si sposta bensì il piano che viene verso di noi in questo modo è come se il nozzle fosse andato in avanti? E’ chiaro???
Vediamo cosa succede per una coreXY. Spostiamo a destra e la matita va a destra spostiamo in avanti e la matita va avanti, ma cosa succede quando gli diciamo di alzarsi?
Ecco anche qui il cattivone di progettista ha bloccato la nostra matita sull’asse Z, e non si alzerà manco con il v i a g r a!!! Poverina….
E allora cosa succede? Succede che il piano, avendo girato lo spazio di 180° si abbasserà rispetto alla matita, in questo modo è come se la matita si fosse alzata. Quindi spingo la freccia in alto e il piano scende!!! Wow e doppio Wow!!!
Rimangono le Delta. Qui invece per fortuna non c’è stato nessun cattivone a combinarla grossa, se sposto a destra la matita va destra, se spingo avanti la matita va avanti se spingo su la matita va su… Wow e triplo Wow…
Quindi le frecce servono solo ed esclusivamente a spostare il nostro NOZZLE nello spazio 3D non carrelli, piatti etc etc, tutto è riferito al nozzle.
E il punto zero per come sono gli assi cartesiani è e sarà sempre a SINISTRA – DIETRO – BASSO.
Quindi noi ci troviamo come punto di osservazione sul punto 0,0,0 e quello che muoviamo è la matita per disegnare in 3D.

Tutto è riferito a quel punto e alla matita, su una prusa se spingo destra il carrello X si sposta a destra, se spingo avanti (su) non è la matita che si muove bensì il carrello che verrà verso di noi!! Chiaro???
Su una CoreXY se spingiamo Z in su il nozzle che non può muoversi sarà il piano che scenderà, simulando cosi l’alzamento del nozzle stesso…. A richiaro???

Eccovi svelato lo straordinario mistero delle frecce in repetier e printrun!!!