Calificación:
  • 1 voto(s) - 5 Media
  • 1
  • 2
  • 3
  • 4
  • 5
APORTE Autoapagado con Marlin (Editado).
#1
Hace algún tiempo implementé un sistema de apagado mediante un relé termostático, colocando la sonda de temperatura que incorporaba bajo la cama. Por si a alguien le interesa, puede verlo aquí.

Hace unos meses, @Nitemare indicó que quería modificar ese montaje para utilizar el sensor del hotend en lugar de la sonda colocada en la cama y en mi respuesta le comentaba las complicaciones que eso tenía, dado las diferencias de los dos sensores.

Pero la idea me pareció muy interesante y me hizo reflexionar sobre el tema. De ahí ha surgido la solución que expongo a continuación (así que gracias @Nitemare ).

Antes he de decir, que sistemas para que la impresora se apague sola hay muchos, pero la mayoría necesitan que la impresión en curso termine correctamente, ya que suelen implementar las órdenes para realizar el apagado mediante comandos gcode incluidos en el script de finalización de la pieza.

En la solución que yo planteo lo realiza el firmware por la temperatura del hotend, lo que hace que funcione incluso si la impresión se para por cualquier otro motivo (siempre que se enfríe el hotend, por supuesto).

Para ello, hay que utilizar un firmware que se pueda modificar y el hardware necesario para realizar físicamente el apagado.

El hardware.

Lo mínimo necesario es un relé de estado sólido (SSR), un interruptor y los cables para conectarlo todo.

El relé tiene que ser del tipo DA (que quiere decir control en continua y corte en alterna) y con uno de 25A como este es más que suficiente:

resim

Este es el esquema para conexionarlo todo:

resim

En el caso de las Anet, el cable de GND se puede conectar directamente a una de las salidas negativo de la fuente de alimentación, pero para otras placas habrá que comprobar que funciona.

Los cables para conectarlo a la placa dependen de cual sea esta: si es para las placas tipo RAMPS (RAMPS, MKS, OVM20, etc.), solo hay que usar un conector de los que usan este tipo de placas y conectar a cualquier pin de control que esté libre (suelen tener muchos).

Si es una placa Anet, la cosa se complica un poco, ya que esta placa solo tiene un pin de control libre y está en el conector LCD de la pantalla, por lo que hay que confeccionar un cable plano modificado para poder utilizar ese pin.

Si se tiene la pantalla alfanumérica de la A8, el número de pin es el 27, que se corresponde con el cable número 3 (el 1 es el de color). Si la pantalla es de la A6, entonces el pin es el 29 y se corresponde con el cable número 7.

Hay que cortar con cuidado con un cutter y separar el cable que corresponda. Para la pantalla de la A8 quedaría tal que así:

resim

Después, habrá que prolongar convenientemente ese cable para llegar hasta donde pongamos el relé. Este cable es el que hay que conectar al relé, donde pone CONTROL en el esquema.

Aunque es obvio diré, por si alguien anda despistado, que el conector que se ve en la foto es el que hay que conectar en la salida LCD de la placa. El conector del otro extremo es el que va a la pantalla.

Por cierto, si se tiene instalado un sensor de contacto (tipo BLTouch-3DTouch), se estará utilizando para controlarlo ese pin libre, por lo que no se podrá tener al mismo tiempo también el autoapagado. O uno u otro.

El firmware.

Para el firmware utilizaré Marlin en su última versión (en este momento la 1.1.8). Doy por supuesto que todo el que realice este montaje, sabe utilizar el IDE de Arduino para modificar Marlin y como se sube a la impresora. Si no es así, pueden verlo aquí, por ejemplo.

He de decir que mi fuerte no es el C++, por lo que seguramente la implementación que hago no será muy “pulcra”, pero mi intención es que sea lo más sencillo posible de cara a evitar que crezca mucho el tamaño del archivo compilado y para que haya que modificar los menos archivos posibles. Quizá lo incluyan los de Marlin (como hicieron, supongo que por casualidad, con la modificación que realicé para separar la limitación de movimiento del eje Z para el autolevel) y seguro que harán un trabajo mucho más profesional que yo.
 
En las placas con ATMega2560 hay memoria de sobra, pero el ATMEGA1284P que integran las Anet anda muy justo si se tiene también el autolevel instalado.

Con la pantalla alfanumérica de la A8 no hay problema, pero con las de tipo gráfico (A6) no cabe (a no ser que se tenga el bootloader Optiboot), ya que hay que incluir la librería U8Glib.

En ese caso, la mejor opción para ganar algo de memoria libre es comentar la línea //#define EEPROM_CHITCHAT, en el archivo configuration.h.

Las modificaciones necesarias las haremos en los archivos configuration.h y ultralcd.cpp.

Aunque no es necesario para el funcionamiento del autoapagado, yo prefiero cambiar también en el language_es.h los siguientes valores para mejorar la visibilidad en el menú:

#define MSG_ON                              _UxGT("SI")
#define MSG_OFF                             _UxGT("NO")


En el configuration.h, añadiremos al final del mismo la siguientes líneas (las que están en color verde son las que hay que incluir, las otras son para saber donde hay que hacerlo (por supuesto, los comentarios son opcionales):

...
// Servo deactivation
//
// With this option servos are powered only during movement, then turned off to prevent jitter.
//#define DEACTIVATE_SERVOS_AFTER_MOVE

/**
 * Autoapagado
 * Implementado por Simemart.
 *
 * Si está definido, durante la impresión será accesible el menú de autoapagado,
 * con opciones para configurar la temperatura de apagado y para activarlo/desactivarlo.
 * Si está activado, la impresora se apagará cuando la temperatura del fusor baje del valor que se haya indicado (por defecto 80ºC).
 * La alimentación de la impresora tiene que estar controlada por un relé de estado sólido (SSR),
 * con el positivo de su circuito de control conectado al pin definido para AUTOAPAGADO_NUM_PIN y el negativo a GND.
 *
 */

#define AUTOAPAGADO
#if ENABLED(AUTOAPAGADO)
  #define AUTOAPAGADO_NUM_PIN 27  // Pin para el control del relé
#endif


#endif // CONFIGURATION_H


En el archivo ultralcd.cpp, hay que insertar líneas en varios puntos.

El primero:


  #define lcd_implementation_drawmenu_setting_edit_bool(sel, row, pstr, pstr2, data)                    DRAW_BOOL_SETTING(sel, row, pstr, data)
  #define lcd_implementation_drawmenu_setting_edit_callback_bool(sel, row, pstr, pstr2, data, callback) DRAW_BOOL_SETTING(sel, row, pstr, data)
  #define lcd_implementation_drawmenu_setting_edit_accessor_bool(sel, row, pstr, pstr2, pget, pset)     DRAW_BOOL_SETTING(sel, row, pstr, data)
#endif // ULTIPANEL

#if ENABLED(AUTOAPAGADO)
  bool autoapagado_activo = false;
  uint8_t autoapagado_pin = AUTOAPAGADO_NUM_PIN;
  int16_t autoapagado_temp = 80;  //Temperatura de corte por defecto a 80 ºC
#endif


// The main status screen
void lcd_status_screen();


El segundo:


  #if ENABLED(DELTA_CALIBRATION_MENU) || ENABLED(DELTA_AUTO_CALIBRATION)
    void lcd_delta_calibrate_menu();
  #endif

  #if ENABLED(AUTOAPAGADO)
    void lcd_autoapagado_menu();
  #endif


  ///////////////////////////////////////////////////
  //////////// Menu System Actions ///////////
  //////////////////////////////////////////////////


El tercero:


/**
 *
 * "Info Screen"
 *
 * This is very display-dependent, so the lcd implementation draws this.
 */

void lcd_status_screen() {

  #if ENABLED(AUTOAPAGADO)
    if (autoapagado_activo) {
       if (thermalManager.degHotend(active_extruder) < autoapagado_temp) {
          pinMode(autoapagado_pin, OUTPUT);
          digitalWrite(autoapagado_pin, 0);
          analogWrite(autoapagado_pin, 0);
       }
       else {
          pinMode(autoapagado_pin, OUTPUT);
          digitalWrite(autoapagado_pin, 255);
          analogWrite(autoapagado_pin, 255);
       }
    }
    else {
       pinMode(autoapagado_pin, OUTPUT);
       digitalWrite(autoapagado_pin, 0);
       analogWrite(autoapagado_pin, 0);
    }
  #endif
 

  #if ENABLED(ULTIPANEL)
    ENCODER_DIRECTION_NORMAL();
    ENCODER_RATE_MULTIPLY(false);
  #endif


El cuarto:


/**
   *
   * "Main" menu
   *
   */

  void lcd_main_menu() {
    START_MENU();
    MENU_BACK(MSG_WATCH);

    #if ENABLED(CUSTOM_USER_MENUS)
      MENU_ITEM(submenu, MSG_USER_MENU, _lcd_user_menu);
    #endif

    //
    // Debug Menu when certain options are enabled
    //
    #if HAS_DEBUG_MENU
      MENU_ITEM(submenu, MSG_DEBUG_MENU, lcd_debug_menu);
    #endif

    //
    // Set Case light on/off/brightness
    //
    #if ENABLED(MENU_ITEM_CASE_LIGHT)
      if (USEABLE_HARDWARE_PWM(CASE_LIGHT_PIN)) {
        MENU_ITEM(submenu, MSG_CASE_LIGHT, case_light_menu);
      }
      else
        MENU_ITEM_EDIT_CALLBACK(bool, MSG_CASE_LIGHT, (bool*)&case_light_on, update_case_light);
    #endif

    if (planner.movesplanned() || IS_SD_PRINTING) {
      #if ENABLED(AUTOAPAGADO)
        MENU_ITEM(submenu, "Autoapagado", lcd_autoapagado_menu);
      #endif

      MENU_ITEM(submenu, MSG_TUNE, lcd_tune_menu);
    }
    else {
      if (autoapagado_activo) {
        MENU_ITEM(submenu, "Autoapagado", lcd_autoapagado_menu);
      }
 
           #if ENABLED(AUTOAPAGADO)
             if (autoapagado_activo || thermalManager.degHotend(active_extruder) > EXTRUDE_MINTEMP) {
               MENU_ITEM(submenu, "Autoapagado", lcd_autoapagado_menu);
             }
           #endif

      MENU_ITEM(submenu, MSG_PREPARE, lcd_prepare_menu);
    }
    MENU_ITEM(submenu, MSG_CONTROL, lcd_control_menu);


El quinto y último:


  // Refresh the E factor after changing flow
  inline void _lcd_refresh_e_factor_0() { planner.refresh_e_factor(0); }
  #if EXTRUDERS > 1
    inline void _lcd_refresh_e_factor() { planner.refresh_e_factor(active_extruder); }
    inline void _lcd_refresh_e_factor_1() { planner.refresh_e_factor(1); }
    #if EXTRUDERS > 2
      inline void _lcd_refresh_e_factor_2() { planner.refresh_e_factor(2); }
      #if EXTRUDERS > 3
        inline void _lcd_refresh_e_factor_3() { planner.refresh_e_factor(3); }
        #if EXTRUDERS > 4
          inline void _lcd_refresh_e_factor_4() { planner.refresh_e_factor(4); }
        #endif // EXTRUDERS > 4
      #endif // EXTRUDERS > 3
    #endif // EXTRUDERS > 2
  #endif // EXTRUDERS > 1
 
  /**
   *
   * "Autoapagado" submenu
   *
   */
  void lcd_autoapagado_menu() {
    START_MENU();
    MENU_BACK(MSG_MAIN);
    #if ENABLED(AUTOAPAGADO)
       MENU_ITEM_EDIT(int3, "Temperatura", &autoapagado_temp, 50, EXTRUDE_MINTEMP-20);
       MENU_ITEM_EDIT(bool, "Activado", &autoapagado_activo);
    #endif
    END_MENU();
    }


  /**
   *
   * "Tune" submenu
   *
   */
  void lcd_tune_menu() {
    START_MENU();


Con eso quedaría completa la modificación.

En el configuration.h, comentando o descomentando la línea #define AUTOAPAGADO, se incluye o no la opción de autoapagado en la compilación del firmware.

El pin de control se define en la línea #define AUTOAPAGADO_NUM_PIN 27  // Pin para el control del relé.. En este caso, está configurado para una A8 con pantalla de serie.

Una vez compilado y subido a la impresora el firmware, la utilización es como sigue:

En el transcurso de una impresión, en el menú general nos aparecerá un nuevo submenú denominado Autoapagado:

resim

Si entramos en él, veremos dos opciones:

resim

La primera es para modificar la temperatura del hotend, por debajo de la cual se apagará la impresora si está activo el autoapagado.

Tal y como lo he configurado, por defecto la temperatura de corte es 80º y puede variarse entre 50º y 20º menos que la que tengamos fijada en la línea #define EXTRUDE_MINTEMP en el configuration.h.

La segunda opción, es para activar o desactivar el autoapagado.

Cuando lo hacemos, la acción tendrá efecto cuando volvamos a la pantalla de información de la impresora, activándose o desactivándose el relé en cada caso.

Hay que tener en cuenta que si cuando está activo el autoapagado, interrumpimos nosotros la impresión en curso, el mismo seguirá activo por lo que si no lo desactivamos, la impresora se apagará a la temperatura fijada de todas formas. Para ello, el menú de Autoapagado seguirá accesible mientras esté activo.

Los pasos a seguir para utilizar el autoapagado serían como sigue: una vez comenzada la impresión, iremos al menú de Autoapagado, seleccionamos la temperatura (si queremos cambiarla) y activamos el mismo.

Al volver a la pantalla de información se activará el relé (se encenderá su luz piloto), con lo que podremos apagar el interruptor de encendido de la impresora, pasando el relé a controlar la alimentación de la misma.

Cuando el hotend baje de la temperatura fijada, bien por que termine la impresión o por cualquier otra causa, el relé se desactivará y la impresora se apagará.

Dado que el interruptor de encendido está en posición de apagado, la impresora no se encenderá hasta que lo hagamos nosotros de forma manual (para el caso de cortes en el suministro, por ejemplo).

Y eso es todo. Como digo, está probado en una A8 con pantalla de serie y funciona correctamente. De todas formas, como siempre, decir que el que decida hacer este montaje será por su cuenta y riesgo.

Estoy terminando el montaje de una impresora con Arduino Mega 2560+RAMPS 1.4. Lo probaré también con ella y comentaré el resultado (si no se me adelanta alguien).

Edito 1: He cambiado las líneas que están tachadas por las que están en color azul.
Primero para evitar un error de compilación que se producia si no se habilitaba el autoapagado en el archivo configuration.h.
Y aprovechando, he añadido la posibilidad de que se active el menú de autoapagado si la temperatura del hotend se encuentra por encima de la temperatura mínima de extrusión.
Citar
#2
Me alegro de haberte servido de inspiración, jajajaja, impresionante trabajo...
Nitemare
Citar
#3
Y asi señores se implementa un marcha-paro en una impresora 3D.
Muy buena explicacion e idea, yo llevaba ya tiempo dandole vueltas a hacer algo similar, aunque yo personalmente en este caso usaria un rele mecanico en lugar de un SSR... los SSR estan muy bien para gestionar cosas como camas calientes por pwm, pero para esta aplicacion una placa de rele para arduino casi es mas economica (No se necesita un rele de mucho amperaje... al ser alimentacion a 240v, el amperaje necesario disminuye mucho debido a la tension... con 5 amperios vamos sobrados ya que seria equivalente a una potencia de mas de 1000w)


Buena idea lo de gestionar la señal de control con la temperatura del nozzle, es una pena que yo utilice dos circuitos de alimentacion diferentes... si no lo aplicaria. Quiza aplique tu idea, pero modificandola para mi caso particular (La impresora va a 12v, la cama caliente a 24v, y la fuente de 12v esta conectada al Sai del ordenador... asi si se me va la luz o hay un pequeño corte no se va todo al traste, por eso lo de los dos circuitos)

Cuando tenga tiempo le echare un ojo.
Citar
#4
(01-04-2018, 02:01 AM)Nitemare escribió: Me alegro de haberte servido de inspiración, jajajaja, impresionante trabajo...

A cada uno lo suyo  Icon_e_wink . Gracias por el comentario.

(01-04-2018, 04:30 AM)Shellmer escribió: Y asi señores se implementa un marcha-paro en una impresora 3D.
Muy buena explicacion e idea, yo llevaba ya tiempo dandole vueltas a hacer algo similar, aunque yo personalmente en este caso usaria un rele mecanico en lugar de un SSR... los SSR estan muy bien para gestionar cosas como camas calientes por pwm, pero para esta aplicacion una placa de rele para arduino casi es mas economica (No se necesita un rele de mucho amperaje... al ser alimentacion a 240v, el amperaje necesario disminuye mucho debido a la tension... con 5 amperios vamos sobrados ya que seria equivalente a una potencia de mas de 1000w)


Buena idea lo de gestionar la señal de control con la temperatura del nozzle, es una pena que yo utilice dos circuitos de alimentacion diferentes... si no lo aplicaria. Quiza aplique tu idea, pero modificandola para mi caso particular (La impresora va a 12v, la cama caliente a 24v, y la fuente de 12v esta conectada al Sai del ordenador... asi si se me va la luz o hay un pequeño corte no se va todo al traste, por eso lo de los dos circuitos)

Cuando tenga tiempo le echare un ojo.

Gracias por el comentario.
Sobre lo que indicas del relé, dado que yo tenía uno del otro montaje no me planteé otras opciones. La verdad es que son baratos estos SSR y van muy bien.
Supongo que un relé mecánico optoacoplado para Arduino es también una buena opción.
Citar
#5
Si, no digo que un SSR no sirva, lo único... hay que diferenciarlos entre los de alterna y los de continua. No son iguales ya que están compuestos por elementos totalmente diferentes. Te recomiendo que especifiques muy bien en el post que ha de ser un SSR de alterna o seguro habrá alguien que se compre uno de continua y no le funcione.
Citar
#6
(01-04-2018, 06:11 PM)Shellmer escribió: Si, no digo que un SSR no sirva, lo único... hay que diferenciarlos entre los de alterna y los de continua. No son iguales ya que están compuestos por elementos totalmente diferentes. Te recomiendo que especifiques muy bien en el post que ha de ser un SSR de alterna o seguro habrá alguien que se compre uno de continua y no le funcione.

Está claramente especificado que tiene que ser del tipo DA y por eso puse también la foto.
Pero tienes razón, lo acabo de poner por si acaso.
Citar
#7
Acabo de editar el post para corregir un error y para activar el menu de autoapagado cuando la temperatura del hotend esté por encima del límite de extrusión.
Citar
#8
Como apuntaba al final del post, ya tengo funcionando este sistema en ArduinoMega2560+RAMPS1.4.
En este caso, el cable de señal lo he conectado a la salida del servo1 de la RAMPS (pin 4). El cable de GND directamente a la fuente.
Tambien he colocado un led en paralelo con la entrada de control del relé, como indicador del estado activado del autoapagado.

resim   resim

Saludos.
Citar


Temas similares...
Tema Autor Respuestas Vistas Último mensaje
  ANET A6 y MARLIN 2.x Desmoly 4 196 18-10-2018, 07:46 AM
Último mensaje: Desmoly
  Autolevel, paso a paso (III): configuración (ACTUALIZADO y EDITADO). Simemart 193 21,485 15-10-2018, 03:30 PM
Último mensaje: Simemart
  CONSULTA Problema con marlin Vicente48 2 167 01-10-2018, 05:42 PM
Último mensaje: Escocés
  anet a8 fallor marlin sansuy 2 201 10-08-2018, 03:20 PM
Último mensaje: Simemart
  DUDA Instalar Marlin en ANET E10 Panxy 2 552 07-06-2018, 06:10 PM
Último mensaje: garfieldf