Guida all’utilizzo di pausa e/o advanced pause feature

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...

Per spiegare questa parte un po complessa che in molti faticano a capire bisogna partire da come funziona il firmware nella gestione dei comandi sia seriali che da SD.

Tutti i sistemi seriali hanno una gestione a buffer, per farvi capire la cosa faccio un esempio che può essere più semplice da capire. Avete presente quando vedete un video in streaming, la prima cosa che fa il visualizzatore sul vostro PC è quello di creare un buffer di alcuni secondi del video per poi cominciare a visualizzarlo, questo perché durante il download ci possono essere dei momenti in cui il bitrate diminuisce o addirittura si ferma, in questo modo il buffer permette di continuare a vedere il filmato mentre si ripristina la connessione.

Stessa cosa funzione per la seriale pc board. Ci sono due tipi di buffer quello hardware e uno software.

Quando si mandano i comandi alla board tutti i comandi vengono bufferizzati finché il buffer non è pieno, poi vengono eseguiti uno alla volta e man mano che si svuota il buffer viene riempito da un altro comando.

Quindi se si manda una sequenza di questo tipo:

G1 F1380 X90.759 Y109.209 E66.92575
G0 F4800 X91.295 Y109.239
G1 F1380 X109.239 Y91.295 E67.76978
G0 F4800 X109.239 Y91.861
G1 F1380 X91.861 Y109.239 E68.58719
G0 F4800 X92.427 Y109.239
G1 F1380 X109.239 Y92.427 E69.37797
G0 F4800 X109.239 Y92.993
G1 F1380 X92.993 Y109.239 E70.14214
G0 F4800 X93.558 Y109.239
G1 F1380 X109.239 Y93.558 E70.87972
G0 F4800 X109.239 Y94.124
G1 F1380 X94.124 Y109.239 E71.59069
G0 F4800 X94.690 Y109.239
G1 F1380 X109.239 Y94.690 E72.27503
G0 F4800 X109.239 Y95.255
G1 F1380 X95.255 Y109.239 E72.93279
G0 F4800 X95.821 Y109.239
G1 F1380 X109.239 Y95.821 E73.56393
G0 F4800 X109.239 Y96.387
G1 F1380 X96.387 Y109.239 E74.16845
G0 F4800 X96.952 Y109.239
M0 S0
G1 F1380 X109.239 Y96.952 E74.74639
G0 F4800 X109.239 Y97.518
G1 F1380 X97.518 Y109.239 E75.29771
G0 F4800 X98.084 Y109.239
G1 F1380 X109.239 Y98.084 E75.82241
G0 F4800 X109.239 Y98.649
G1 F1380 X98.649 Y109.239 E76.32053
G0 F4800 X99.215 Y109.239
G1 F1380 X109.239 Y99.215 E76.79203
G0 F4800 X109.239 Y99.781
G1 F1380 X99.781 Y109.239 E77.23691

Questi comandi vengono messi nel buffer ed eseguiti uno alla volta. Quando il parser dei comandi arriva a M0 S0 effettua la pausa, il comando viene eseguito, ma nel frattempo il buffer è già pieno dei successivi comandi.

A questo punto come uscire dalla pausa?

Ci sono due modi il primo è meccanico perché il firmware anche se in pausa continua a controllare pin e altro quindi un pulsante collegato su un pin può dare il consenso, vedi encoder del display. Ma se non abbiamo nessun pulsante? Si potrebbe fare con un comando gcode per esempio, che è il comando M108 che è il comando che sblocca come l’encoder, ma se diamo questo comando da host che dovrà andare in seriale verso la board non è che abbia una corsia preferenziale, farà la stessa strada degli altri comandi quindi si mette in coda nel buffer e visto che la stampante è ferma non verrà mai eseguito, quindi questa strada cosi con è percorribile..

Se stampiamo da SD le cose si mettono in maniera diversa perché il buffer della SD è diverso da quello della seriale, quindi mandando il comando in seriale verso la board il buffer sarebbe vuoto e quindi M108 arriva al processore. Ma quì ci sarebbe un altro problema, come vi ho detto prima ci sono due buffer quello hardware e quello software, quello software che è quello che viene riempito dai comandi che arrivano o dalla seriale o dalla SD e poi eseguiti uno alla volta comunque sarebbe pieno, quindi M108 arriva tramite la seriale al processore, ma non riesce a metterlo nel buffer software perché pieno e anche cosi non verrebbe eseguito.

In quest’ultimo caso il firmware permette una via d’uscita cioè attivare EMERGENCY_PARSER, questa funzione legge il buffer seriale e legge man mano i vari vari comandi che arrivano dalla seriale man mano che arrivano inserendoli in un altro buffer di mezzo che poi sarà svuotato nel buffer principale, visto che stiamo stampando da SD questo buffer di mezzo sarà vuoto, quindi se viene rilevato che il comando che arriva è M108 o altri comandi importanti li esegue subito.

/**
* Enable an emergency-command parser to intercept certain commands as they
* enter the serial receive buffer, so they cannot be blocked.
* Currently handles M108, M112, M410
* Does not work on boards using Arduino DUE processors!
*/
//#define EMERGENCY_PARSER

Perché non metterlo definito di default chiederete voi, perché è memoria in più e tempo processore in più perché comunque ogni volta che arriva un carattere sulla seriale il firmware controlla che carattere è se è una M allora aspetta il prossimo se è un 1, il prossimo, e cosi via se rileva che è un M108 allora esegue se non lo è butta nel buffer principale e lascia al parser l’esecuzione… Quindi è tempo macchinina perso che si attiva solo se si ha la necessità di fare queste pause..

Comunque come già detto utilizzabile solo se si stampa da SD. E se si volesse stampare da Host? Bene gli Host seri vedi repetier o i vari octoprint o repetier server hanno la possibilità di mettere nel gcode il comando @pause che blocca l’host non la stampante, quindi l’host si ferma a mandare comandi e aspetta che voi premiate il tasto play che apparirà sul l’host stesso. Nei setting dell’host si possono mettere dei comandi che verranno inviati alla stampante, che vi ricordo non è in pausa, non ha più comandi da eseguire perché l’host non gliela mandati, quindi eseguirà tranquillamente qualsiasi comando che arriverà dalla seriale. Potrò cosi mettere dei comandi di spostamento per togliermi da sopra il pezzo, eventuali ritrazioni, insomma posso fare quello che voglio.

Ora vediamo cosa succede se ho un display qualsiasi display anche il nextion.

Si può abilitare ADVANCED_PAUSE_FEATURE che è praticamente il vecchio cambio filo M600 il comando annesso che eseguirà una serie di comandi in base alle impostazioni messe.

Ma se uno vuole inserire una pausa senza dover necessariamente fare il cambio filo, allora si abilità PARK_HEAD_ON_PAUSE.

Cosa attiva questa funzione, semplice se si mette in pausa la stampa da SD il firmware parcheggierà il nozzle in una posizione che è la stessa del cambio filo.

#define PAUSE_PARK_X_POS 3 // X position of hotend
#define PAUSE_PARK_Y_POS 3 // Y position of hotend
#define PAUSE_PARK_Z_ADD 10 // Z addition of hotend (lift)

Farà una ritrazione che è sempre uguale a quella del cambio filo:

#define PAUSE_PARK_RETRACT_LENGTH 2 // Initial retract in mm

e attende la pressione del tasto encoder per i display  normali il tastino che appare nel nextion send, oppure il solito comando M108 se è attiva la funzione EMERGENCY_PARSER.

Una volta che si preme l’encoder si riporta sul pezzo estrude della stessa lunghezza della ritrazione di prima e ricomincia la stampa.

Ma se si volesse forzare la pausa senza dover premere pause printer sd, come si fa?

C’è il comando M125 che fa esattamente questo, cioè andare in pausa.

M125 – Save current position and move to pause park position. (Requires PARK_HEAD_ON_PAUSE)

Quindi niente M0 o roba del genere, con questo comando si va in pausa, il nozzle viene parcheggiato e si aspetta le pressione del tasto.

Detto ciò come al solito vi auguro buone stampe e buone pause a tutti.

Mago Kimbra.

Nextion 7″ HMI Diamond Series

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

 

Vediamo come installare questo display nella versione Diamond fatta da Mr.Goblins.

Come mostrato nello schema sovrastante il cablaggio prevede come nodo comune di interfacciamento una schedina di I/O auto-costruita di dimensioni 60 x 21 mm di cui di seguito si riporta la traccia rame:

 

Nell’impossibilità di potersela costruire si può utilizzare il display adapter originale, disponibile sul sito della Itead:  https://www.itead.cc/display/nextion/nextion-io-adapter.html

 

Ovviamente il vantaggio della scheda auto-costruita è quello di avere delle comode morsettiere sia per il cablaggio interno che per i collegamenti esterni del display.

 

Cablaggio:

La scheda di I/O prevede 2 morsettiere a 4 poli per i collegamenti di alimentazione e seriale, 2 morsettiere a 5 poli che portano all’esterno le connessioni  di I/O del display e un connettore SMT a 10 poli per il collegamento tra scheda e display.

Collegare inizialmente tra di loro tutti i pin GND delle schede, filo nero del display e filo nero del cicalino usando come punto comune il relativo morsetto della scheda di collegamento I/O. Successivamente collegare tra di loro tutti i pin VCC delle schede e filo rosso del display usando come punto comune un altro morsetto della scheda di I/O.

Collegare poi i fili giallo e blu del display ai restanti due morsetti della scheda I/O.

Ora andranno collegati l’uscita del sensore PIR, il filo rosso del cicalino e i due ingressi della scheda relè seguendo quanto raffigurato nello schema precedente.

Nel caso si utilizzi la scheda adattatrice originale I collegamenti saranno:

PIR out   → IO_0

Cicalino  → IO_1

Relè IN1 → IO_2

Relè IN2 → IO_3

Dopo di che andrà sistemata nel contenitore la prolunga della scheda SD, fissandola con l’apposita staffetta e, se possibile, frapponendo tra i due un pezzetto di gomma morbida (tipo guarnizione per finestre) facendo passare la piattina di collegamento attraverso l’asola sul fondo del contenitore.

Adesso non rimane che collegare la piattina a 10 poli prima alla scheda di I/O e poi, sovrapponendo l’altra metà del contenitore, al display. Il risultato finale (con il display scollegato) sarà simile a questo:

 

Dall’immagine si nota subito che per orientare verso l’esterno le morsettiere, le schede dovranno necessariamente essere montare sottosopra quindi andranno fissate una volta ultimato il cablaggio.

Si consiglia di piegare il flet-cable a 10 poli come indicato in figura al fine di avere un cablaggio più pulito ma soprattutto per facilitarne l’inserimento dal lato display una volta sovrapposta l’altra metà del contenitore.

 

Controllo e taratura:

Gli unici controlli da fare riguardano i jumper posti sia sul sensore PIR che sulla scheda a relè mentre la taratura riguarderà i due trimmer della scheda PIR.

Iniziamo dal jumper della scheda PIR che dovrà essere posto sulla posizione “H” (modo Retriggered) ovvero verso l’angolo della scheda.

Nota: in commercio è possibile trovare due tipologie di circuito le quali hanno i pin “H” e “L” invertiti.

I due trimmer andranno regolati ambedue a metà della loro corsa.

Quello del Delay Time è poco importante in quanto il tempo di ritardo è impostabile dal software del display, l’importante è che non sia eccessivamente lungo, mentre il Sensitivity Adjust, posto a metà corsa, rileverà la vostra presenza quando sarete a circa due metri dal sensore. In ogni caso potrete regolarlo in base alle vostre esigenze.

Nella scheda relè il jumper dovrà essere posto nella posizione “VCC” (verso l’angolo della scheda).

 

Materiali:

Di seguito sono elencati i materiali occorrenti alla realizzazione con relativi link verso il sito del venditore.

SD Card Extender:

http://www.ebay.it/itm/SD-to-MicroSD-Card-Extension-Cable-PRICE-INCLUDES-VAT-/112389211361?hash=item1a2aeb44e1:g:bhMAAOSwo6lWI09M

Modulo Neuftech a due relè 5V:

https://www.amazon.it/gp/product/B00PIMRGN4/ref=oh_aui_detailpage_o03_s01?ie=UTF8&psc=1

Sensore PIR Foxnovo HC-SR501:

https://www.amazon.it/Foxnovo-HC-SR501-Pyroelectricity-infrarosso-movimento/dp/B00UBUU770/ref=sr_1_1?s=automotive&ie=UTF8&qid=1493659599&sr=1-1&keywords=HC-SR501

Cicalino Kingstate KPEG350A:

http://it.rs-online.com/web/p/buzzer-piezoelettrici/6221512/

Flat-Cable a 10 vie da PCB Molex 98267-0255:

http://it.rs-online.com/web/p/cavi-per-ponticelli-ffcfpc/4589181/

Morsettiera da PCB 5 vie passo 2,54mm:

http://it.rs-online.com/web/p/blocchetti-terminali-da-pcb/2204298/

Morsettiera da PCB 2 vie addizionabili passo 5,08mm:

http://it.rs-online.com/web/p/blocchetti-terminali-da-pcb/4258720/

Connettore SMT 10 vie Molex 52271-1079:

http://it.rs-online.com/web/p/connettori-fpc/5144329/

 

Allegati:

Master circuito stampato dell’adattatore I/O eseguito con Sprint-Layout 6.0

Bitmap della traccia rame (dimensioni del circuito 60x21mm).

File STL Body.

File STL Frame.

File STL SD Fix.

File STL Support.

Sistema multi estrusore MKR6 – Multi Extruder system MKR6

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...

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

Un ringraziamento speciale a angelos del forum reprap Italia.

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

Esempio:

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

Una volta fatto questo abilitiamo nel firmware MK4duo la funzione MKR6, per prima cosa diciamo al FW che abbiamo 6 estrusori:

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

Poi definiamo che abbiamo 2 driver per gli estrusori:

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

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

/***********************************************************************
************************* Multiextruder MKR6 **************************
***********************************************************************
* *
* Setting for more extruder width relay system *
* This is new system for 6 extruder width 2 driver and 6 relay. *
* See Configuration_pins.h for pin command relay *
* *
* Uncomment MKR6 to enable this feature *
* *
* Uncomment INVERTED_RELE_PINS if your relay switches with GND *
***********************************************************************/
#define MKR6
//#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 6 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è. I pin da settare sono EX1_CHOICE_PIN e EX2_CHOICE_PIN:

#define EX1_CHOICE_PIN 5
#define EX2_CHOICE_PIN 6

Questi 2 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 quelli di E1 e li colleghiamo in questa maniera:

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 della seconda coppia andranno al verde e blu del terzo motore E2.

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

La seconda coppia serve per commutare tra E1 e E2.

Ripetiamo lo stesso identico concetto sugli altri 4 relè collegati però con il driver E1 per cosi collegare i motori di E3, E4 e E5.

I relè vanno alimentati con una 5v fissa, 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 con in 5 e 6, l’in 3 e 4 con in 7 e 8. Poi dobbiamo portare i 2 pin scelti per farli scattare EX1_CHOICE_PIN e EX2_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 la prima coppia di relè e anche la terza coppia, 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è insieme alla quarta.

Se passiamo da E2 a E3 vedremo di nuovo tutti i relè tornare nella posizione di quiete, ma verrà usato il driver E1.

Se passiamo da E3 a E4 vedremo scattare di nuovo la prima e la terza coppia, ma usando il driver E1 si muoverà solo il motore di E4.

Se passiamo da E4 a E5 vedremo scattare di nuovo tutti i relé, ma visto che stiamo usando sempre il driver E1 si muoverà solo il motore E5.

A questo punto possiamo provare il tutto. disabilitiamo il controllo di temperatura con il comando M302 P1, 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.

MagoKimbra.

Come regolare i valori step/mm nel firmware

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...

Una delle operazioni fondamentali da eseguire sulla propria stampante 3D, è la regolazione del valore firmware DEFAULT_AXIS_STEPS_PER_UNIT #define DEFAULT_AXIS_STEPS_PER_UNIT   {80, 80, 3200, 625, …

Source: Come regolare i valori step/mm nel firmware

3D-izionario – il mondo è pieno di cose che ancora non esistono …

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...

piccolo dizionario della terminologia usata per descrivere le varie parti di una stampante 3d

Source: 3D-izionario – il mondo è pieno di cose che ancora non esistono …