This forum uses cookies
This forum makes use of cookies to store your login information if you are registered, and your last visit if you are not. Cookies are small text documents stored on your computer; the cookies set by this forum can only be used on this website and pose no security risk. Cookies on this forum also track the specific topics you have read and when you last read them. Please confirm whether you accept or reject these cookies being set.

A cookie will be stored in your browser regardless of choice to prevent you being asked this question again. You will be able to change your cookie settings at any time using the link in the footer.

  • 0 voto(s) - 0 Media
  • 1
  • 2
  • 3
  • 4
  • 5
Cambiar tamaño de cama mediante Gcode o pantalla.
#1
Buenas tardes, estoy llevando a cabo un proyecto que se basa en convertir a mi Ender 3 pro en un router CNC para la fabricación de placas PCB.

Hasta ahora tengo todo funcionando OK, diseñé un soporte para mi Dremel 3000 y modifiqué la cama de impresión mediante unos perfiles 2020 de aluminio, para así poder sujetar las placas PCB.

Además tuve que adaptar el fin de carrera del eje Z de manera que detecte cuando la punta de la fresa que esta en el Dremel, toque el cobre de la placa PCB.

Todo funciona OK, ya hice una placa y queda muy bien. Pero tengo un inconveniente, necesito realizar Mesh Bed Leveling solo en la superficie de la placa.

Edité Marlin y active el MBL, y la nivelación de la superficie total de la cama la puedo hacer sin inconvenientes. El problema surge cuando el PCB que necesito fabricar es mas chico que la superficie de la cama.

La única forma que encontré para adaptar el MBL al tamaño del PCB es editando las dimensiones de la cama desde el firmware de la impresora. Pero no es práctico tener que editar el firmware para cada tamaño de placa PCB.

Es por eso que quisiera saber si es posible realizar esa modificación, ya sea mediante un menú adicional (estuve agregando y editando los custom menús desde Marlin, pero no logre poder cambiar el tamaño de la cama desde el menú que cree) o mediante un GCODE.

Busqué información sobre este tema en internet y no encontré nada que me pueda ayudar a editar Marlin para poder realizar esa modificación como un parámetro mas de impresión.

Desde ya, muchas gracias por leer mi inquietud.
  Responder
#2
Hola @Damian Marcelo, bienvenido al foro.
La forma más sencilla de implementar la funcionalidad que deseas, sería creando un menú específico para ello, pero no para variar el tamaño de la cama sino los límites del área del MBL.
Dichos límites vienen definidos por los parámetros MESH_MIN_X, MESH_MIN_Y, MESH_MAX_X y MESH_MAX_Y a los que, por defecto, se les asigna su valor en función del que hayamos asignado al parámetro MESH_INSET, aplicado sobre los límites de dichos ejes (sumado a los inferiores y restado de los superiores).
En todo caso, nada nos impide definirlos directamente nosotros mismos: por ejemplo, en el menú indicado antes.
La forma de implementar ese menú, dependerá de la versión de Marlin que se utilice (1 o 2).
  Responder
#3
Hola @Simemart, muchas gracias por responder tan rápido. La versión de Marlín que tengo instalada es la 2.0, en realidad es un firmware de TH3D que esta basado en la 2.0.9.1, y  que me funciono muy bien cuando usaba la Ender como impresora.
El MESH_INSET vi que se define como  EZABL_PROBE_EDGE, este parámetro lo edite para que comience a sensar desde un punto cercano al origen de coordenadas, lo hice de la siguiente manera: #define EZABL_PROBE_EDGE 10... antes estaba fijado en 35mm y me quedaba muy lejos del origen de coordenadas.

Después vi que los parámetros MESH_MAX_X y MESH_MAX_Y  dependen, como bien dices, de MESH_INSET y de los valores  del tamaño máximo de la cama.... y vi que se define así:  #define MESH_MAX_X X_BED_SIZE - (MESH_INSET)
                          #define MESH_MAX_Y Y_BED_SIZE - (MESH_INSET)

Es por eso que mi idea era  modificar mediante un menú los valores del tamaño de la cama, pero ahora que veo lo que dices es mejor definir los valores máximos y mínimos de la matriz de sensado.

Lo que hice es lo siguiente, cree un menu activando la opcion CUSTOM_MENU ( es muy basico lo que hice, y dentro de los GCODE, puse el "T" de las herramientas, como para poner algo) y edite los opciones que aparecen al entrar en ese menu.

[Imagen: Captura.jpg]

Y el menu en pantalla quedo de la siguiente manera:

[Imagen: Jpeg.jpg]

Y el menu de opciones

[Imagen: Jpeg.jpg]

Ahora bien, mi idea era la siguiente: mediante este ultimo menú, detectar la opción del menú que se encuentra seleccionada. Esto lo quería hacer leyendo la posición de la rueda de menú ( el encoder rotatorio), y una vez sabiendo la posición del encoder, que seria la de la opción seleccionada en pantalla, aplicar un lazo "IF" dentro de lazo "IF" de "CUSTOM_MENU", que modifique los parametros de MESH_MAX_X y MESH_MAX_Y, para que luego al hacer click en la rueda de seleccion, aplique estos cambios a esas variables ( no seria necesario en primera instancia guardar en memoria los nuevos valores de estas variables, dado que no me costaria nada seleccionar el tamaño de la placa cada vez que inicie la impresora)
Para hacer esto, estuve investigando y encontré la función "ui.encoder_position", que creo que corresponde a la lectura de la posición de la rueda del menú. El inconveniente, viene ahora...... no entiendo mucho de programación en Python, y veo que Marlín tiene un montón de ficheros, que se relacionan entre si, y cuando quiero llamar a esta función me indica el compilador que no la reconoce... lo que hice fue agregar con la función "include" los ficheros en los que creo que esta definida esta función, pero me sigue marcando error. Se programar en Arduino, y vi que Marlín es casi lo mismo no? Y en Arduino a lo sumo realizo el llamado a librerías y cosas así, pero acá en Marlín se me esta complicando.

Resumiendo y sin querer hacer mas larga la explicación, lo que se me ocurrió hacer mediante programación en el archivo CONFIGURATION_ADV.H que es donde se encuentra la opción de CUSTOM_MENU, es algo como lo siguiente:

#if ENABLED(CUSTOM_MENU_MAIN)

  #define CUSTOM_MENU_MAIN_TITLE "Tamaño de Placa"
  #define CUSTOM_MENU_MAIN_SCRIPT_DONE "M117 Tamaño elegido"
  //#define CUSTOM_MENU_MAIN_SCRIPT_AUDIBLE_FEEDBACK
  #define CUSTOM_MENU_MAIN_SCRIPT_RETURN    // Return to status screen after a script
  //#define CUSTOM_MENU_MAIN_ONLY_IDLE        // Only show custom menu when the machine is idle

  #define MAIN_MENU_ITEM_1_DESC "Placa 5x5"
  #define MAIN_MENU_ITEM_1_GCODE "T3"

  #define MAIN_MENU_ITEM_2_DESC "Placa 5x10 "
  #define MAIN_MENU_ITEM_2_GCODE "T1"


  #define MAIN_MENU_ITEM_3_DESC "Placa 10x10"
  #define MAIN_MENU_ITEM_3_GCODE "T2"
   

  #define MAIN_MENU_ITEM_4_DESC "Placa 15x10 "
  #define MAIN_MENU_ITEM_4_GCODE "T3"


if (int16_t(ui.encoder_position)==1) ;  leo la posicion del encoder y si....posicion 1 del menu
{
MESH_MAX_X = 50; ; 50 mm para el largo de la placa en el eje x
MESH_MAX_Y = 50; ; 50 mm para el largo de la placa en el eje y
}

if (int16_t(ui.encoder_position)==2) ;  leo la posicion del encoder y si....posicion 2 del menu
{
MESH_MAX_X = 100; ; 100 mm para el largo de la placa en el eje x
MESH_MAX_Y = 50; ; 50 mm para el largo de la placa en el eje y
}

...... y siguiendo con las demás condiciones y luego cerrar el lazo IF principal

Seguramente estoy errando en varias cosas, mas que nada porque no se programar en Marlin, pero la idea en si no es complicada de hacer.. es generar un nuevo menú, leer la posición en pantalla y luego modificar los valores de unas variables.
Bueno, perdon por hacer tan larga la explicacion y muchas gracias por su tiempo. Les paso una foto de como esta quedando mi Ender 3 modificada para CNC.

[Imagen: Jpeg.jpg]

Vi que varias personas hicieron modificaciones parecidas. Yo tome lo mejor que me parecio de cada una, y le agregue diseños propios a la mia, como sensar la punta de la fresa con el fin carrera del eje z. En mi caso quiero hacer el MBL como lo relizaria cuando estoy imprimiendo y no mediante el uso de un micrometro o calibre digital, lo cual seria engorroso de realizar y no tendria la misma precision.
Bueno ahora si, termino muchisimas gracias por leer el mensaje y perdon por hacerlo tan largo. Saludos desde Mar del Plata, Argentina!!!!
  Responder
#4
Hola, no es necesario programar a ese nivel para realizar lo que pretendes, ya que Marlin tiene suficientemente implementado el control de menús para no necesitar comprobar uno mismo la posición del encoder.
Por otra parte, la forma que has pensado para hacerlo no funcionaría por varios motivos: el código para la ejecución de un proceso no puede colocarse en ese archivo ( como puedes comprobar intentando encontrar algo que hayan puesto en él sus programadores y que no sea una definición de un parámetro) y ui.encoder_position (tal y como la escribes es una variable, no una función) no está definida en Marlin 2.
El código que debe procesarse tiene que incluirse en el bucle de inicialización de Marlin (si solo se realiza una vez) o en el bucle de programa (si debe repetirse): ambos bucles se encuentran en el archivo MarlinCore.cpp, que se encuentra en la ruta Marlin\src\.
Tampoco creo que sea muy apropiado tener varias opciones de tamaños de placas para seleccionar, pues eso te limita a las que hayas programado y en caso de tener una nueva medida, tendrías que modificar y volver a compilar el firmware: es más sencillo y práctico definir sus dos medidas, lo que te permitirá utilizar cualquier tamaño sin necesidad de cambiar el código.
Para hacer todo este proceso, yo crearía un menú para modificar los valores de las medidas de la placa y lo enlazaría al árbol de menús de Marlin.
Resumiendo, los pasos a seguir serían los siguientes:
1- Definir las variables que se utilizarán para los valores del tamaño del PCB en el menú y el código que realizará la asignación de los valores de dichas variables a los parámetros que almacenan el tamaño de la malla del MBL, teniendo en cuenta la posición de la placa respecto al origen de la impresora (lo más sencillo y lógico sería que estuviese colocada en el origen).
Dicho código debe ser lo más corto posible, para que no interfiera demasido en las demás tareas que realiza Marlin: en este caso, solo es necesario que sea una asignación del valor actual de las variables a los parámetros que almacenan los límites de la malla.
Lo más "profesional" en estos casos, es crear un archivo .h para definir las variables y una función que realice la asignación en un archivo .cpp, cuya llamada se colocará dentro del bucle de programa, en el archivo MarlinCore.cpp.
Dado que en este caso solo son dos variables y dos sentencias de asignación, se puede obviar lo anterior y programar su código directamente en el archivo principal de Marlin.
2- Crear el menú de selección del tamaño del PCB para editar el valor de esas dos variables, para lo que hay que crear un archivo para él con el nombre que se utilizará para enlazarlo al árbol de menús (por ejemplo, en el menú de configuración, que se encuentra en el archivo Marlin\src\lcd\menu\menu_configuration.cpp).
Ese archivo deberá contener, además de la opción de retorno al menú anterior, las sentencias de menú necesarias para modificar las variables y en ellas deben utilizarse cadenas predefinidas para cualquier texto que aparezca (no se pueden utilizar cadenas de texto directamente), por lo que hay que definirlas (si no existen ya) en el archivo del idioma que se tenga configurado.

Para que todo funcione de forma correcta, en C++ (Marlin está programado casi en su totalidad en este lenguaje, no en Python) todos los objetos, variables y funciones que se utilicen deben estar en el alcance (scope), por lo que hay que colocar todos los includes que sean necesarios.
  Responder
#5
Hola, gracias por responder. Veo que tengo que investigar mucho sobre como programar en Marlín. Voy a empezar de a poco e ir probando para ver como responde lo que programo. Me voy a orientar en como explicaste como hacerlo, y en base a eso comenzar a programar de a poco, asi de paso tambien aprendo como se programa en Marlin. Lo que programo en Arduino son cosas basicas, como leer sensores, mostrar esos datos en pantalla y llegado el caso activar algun actuador en base a un algoritmo. Pero veo que me falta practicar mucho mas de programacion, me voy a poner con esto y se que voy a hacer que funcione. Muchas gracias por orientarme en como encarar la idea. Cuando tenga algo ya bien armado y que sepa que funcione lo publico por si alguien mas lo precisa. Muchas gracias!!!
  Responder
#6
Como te comentaba, Marlin está escrito en C++ y por tanto se programa con las reglas de dicho lenguaje, por lo que aprendiendo algunas de sus nociones básicas no tendrás problema para hacerlo.
Pero Marlin es un desarrollo muy complejo, con infinidad de procesos y funciones, lo que implica gran cantidad de código distribuido en multitud de archivos: para poder realizar cambios significativos en él, hay que comprender esto y familiarizarse con su filosofía de programación, lo que solo se consigue investigando en sus interioridades: no es tarea fácil, pero sí muy interesante y formativa.
En todo caso, no dudes en preguntar lo que necesites y si ves que no lo consigues, puedo indicarte de forma más detallada cómo realizarlo.
  Responder
#7
Buenas tardes, estuve programando y avance bastante. Ya tengo funcionando el menu para cambiar los valores de las medidas de la placa. Para hacerlo estuve viendo como estaban programados otros menues similares ( como el de configuracion de temperatura de hotend y cama) y en base a eso lo pude hacer. Coloque la opcion de cambiar el tamaño de la placa en "menu_main.cpp".  El menu funciona bien. pero no me termino de darme cuenta como hacer para asignar los parametros de la pantalla a las medidas MESH_X_ MAX y MESH_Y_MAX... Estuve probando de varias maneras y siempre el compilador me tiraba error, casi siempre era porque me decia que los parametros MESH, ya estaban definidos en otros archivos. Lo que hice para eso fue editar tambien los otros archivos para asignarles a esos parametros los valores de las variables de pantalla, pero en todas las ocasiones  no lo pude hacer. Tampoco me termino de dar cuenta de que manera asigno el valor de las variables a los parametros MESH, lo hice con #define..... y con simbolos aritmeticos dentro del lazo loop() de marlincore.cpp y nunca me funciono. Perdon que vuelva a preguntar, seguro que es algo basico, pero es lo ultimo que me faltaria entender como hacerlo, y quiero ver si lo puedo hacer yo, pero necesito saber los conceptos que me están faltando. Paso el archivo *.cpp del menu que cree. y fotos de como quedo. El menu esta funcionando bien, varia los valores dentro de los parametros que defini, y vuelve al menu anterior correctamente.


#include "../../inc/MarlinConfigPre.h"

#if HAS_LCD_MENU

#include "menu.h"
#include "menu_item.h"
#include "../../Firmware/Marlin/Configuration.h"
#include "menu_placa.h"                                                                        // archivo donde defini las dos variables de x e y
#include "../../Firmware/Marlin/src/lcd/language/language_es.h"                // para agregar los mensajes en pantalla en español

void menu_placa()
  {
  START_MENU();
  BACK_ITEM(MSG_PLACA);
  EDIT_ITEM_FAST(uint8, MSG_TAMANO_X, &tamano_x, 20, 190);
  EDIT_ITEM_FAST(uint8, MSG_TAMANO_Y, &tamano_y, 20, 155);
  END_MENU();
}

#endif


[Imagen: Jpeg.jpg]


[Imagen: Jpeg.jpg]

Desde ya muchas gracias, y perdon por preguntar lo que seguro son cosas basicas, pero viendo que pienso que me falta poco para terminarlo queria saber si alguien me puede terminar de orientar. Yo mientras tanto voy a seguir intentando,
  Responder
#8
Hola, no te preocupes por preguntar todo lo que necesites, para eso está el foro.
Yo tampoco soy un experto en programación C++ y como tú, aprovecho el código de Marlin para salir del paso cuando realizo modificaciones en él, pues me da mucha pereza ponerme a estudiar ese lenguaje de programación como debería, asi que quizá pueda estar equivocado en algo de lo que te voy a indicar.
A los parámetros (constantes), como MESH_X_ MAX y MESH_Y_MAX, solo se les puede asignar valores al definirlos, por lo que hay que hacerlo con sentencias #define: para evitar los errores de definición duplicada, solo tienes que colocar antes de dicha definición una sentencia #undef, tal que así:

...
#undef MESH_X_ MAX
#define MESH_X_ MAX valor
...


C++ es un lenguaje muy estricto y para no tener errores de compilación, hay que realizar una programación muy ordenada, para lo que lo mejor es colocar la definición de variables y funciones en un archivo .h y el código en un archivo .cpp, para así poder realizar de forma fácil solo los includes necesarios: por ejemplo, en el código que indicas, el include del archivo Configuration.h es innecesario.
Solo con la información que has aportado me es imposible indicarte si tienes algún problema que impida un funcionamiento correcto de ese menú: no sé si estás inicializando las variables (no son parámetros) tamano_x y tamano_y  que utilizas en el menú (que debería hacerse en el entry-point de Marlin) y cómo estás asignando los valores a MESH_X_ MIN, MESH_Y_MIN, MESH_X_ MAX y MESH_Y_MAX (¿tienes colocadas las placas físicamente en el origen de la impresora?).
Una cosa que debes tener en cuenta, es que debes definir como externas (extern) las variables que utilizas para contener los valores que modificas en el menu.
Para no tener errores de compilación y ejecución, deberías hacer lo siguiente: definir en un archivo .h las variables a utilizar en el menú (como externas) y la función que se encargará de modificar los valores de los parámetros MESH; colocar includes de ese archivo .h en el archivo .cpp donde pongas el código de esa función, en MarlinCore.cpp y en MenuMain.cpp; incializar las variables en el entry-point de Marlin y colocar una llamada a la función en el bucle de espera (idle routine), que se encuentran ambos en MarlinCore.cpp.
  Responder
#9
Buenas tardes, yo de nuevo. Sigo probando, y sigo sin hacer que funcione el menú. Hice lo siguiente como me recomendó Simemart y ya no tengo errores de compilacion, ( lo cual no indica que lo que hice este funcionando bien) pero no logro que se asignen los valores que selecciono en el menú en los parámetros de MESH_ MAX
La placa esta colocada en el origen de coordenadas de la impresora, y los valores de MESH_MIN según vi son iguales a MESH_INSET, el cual lo edite y coloque un valor de 10mm. En ese sentido los valores de MESH_MIN funcionan bien y no necesito editarlos.
El tema viene ( y sigue) conque no puede terminar de asignar los valores del menú a los parámetros MESH_MAX de cada eje. Hice lo siguiente en cada parte del firmware:

1-. Cree un archivo *.h en el cual defino las variables del menú de selección y las variables de la funciona que tendría que modificar los parámetros:

[Imagen: image.png]

Probé con dos funciones, una que solo asigne valores mediante #DEFINE.... y la segunda funcion que devuelva también los valores de MESH_MAX.  Con ninguna función logre modificar los parámetros originales.

2-. Cree un archivo *.cpp, el cual genera el menu de selección y a su vez invoca a la funcion del archivo *.h anterior......
Esta parte del programa función bien ( al menos eso parece en pantalla) porque varia los parámetros dentro del rango que quiero, y a su vez los parametros en pantalla aparecen inicializados con los valores que definí en VOID SETUP.

[Imagen: image.png]

3-. En VOID SETUP inicialice y definí las variables de la siguiente manera ( la inicialización funciona bien, ya que los valores que defino son con los que aparace cada variable la primera vez que ingreso al menú de selección.

[Imagen: image.png]

4-. Luego realice el llamado a la función en las rutinas VOID IDLE y VOID LOOP  del archivo Marlincore.cpp
[Imagen: image.png]

[Imagen: image.png]


Lo que me di cuenta es que los valores que eligo en el menu de seleccion de tamaño, nunca se asignan a los parametros MESH_MAX de cada eje, por mas que agregue la linea #UNDEF antes de cada definicion
Estos estan definidos en el archivo Configuration_adv.h :

[Imagen: image.png]

Despues lo que hice fue editar este archivo Configuration_adv.h de la siguiente manera:

[Imagen: image.png]

Esto ultimo que hice seguramente esta mal por muchas razones, pero me sirvio para darme cuenta que los valores de TAMANO_X y  TAMANO_Y nunca varian como indica el menu en pantalla o si varian, no se ven reflejados al final. Es mas, editar el archivo de esta manera, es como que si los valores de MESH_MAX_X y MESH_MAX_Y valieran cero, ni siquiera les asigna el valor 20 que edite en VOID SETUP.... 

Voy a seguir investigando, porque creo que lo puedo terminar y hacer que funcione bien. Muchas gracias de antemano.
  Responder
#10
Hola, no lo estás realizando de forma correcta por varios motivos y además no es necesario complicarlo tanto: por ejemplo, no necesitas dos variables para contener los valores que se modifican en el menú y otras dos distintas para asignarlos a los parámetros MESH, con dos sería suficiente (las mismas que se modifican en el menú, se asignan a los parámetros, es para esto que se definen como externas).
Y, por supuesto, prohibido colocar código en los archivos de configuración de Marlin: ahí solo deben definirse parámetros (constantes).
Según indicas, colocaste en él ese código para ver si se modifican los valores MESH, pero esa asignación solo se realiza cuando arranca Marlin y solo si no se tiene habilitado el uso de la EEPROM, pues sino se asignarán a los parámetros los valores almacenados en ella, no los definidos aquí y en cualquier caso, no se volverá a ejecutar en este punto esta asignación hasta que no se reinicie de nuevo Marlin.
Como ya te indiqué anteriormente, la llamada a la función que asigna a los parámetros los valores modificados, debes ponerla en el bucle IDLE de Marlin (aquí se encuentra el código que se ejecuta contínuamente cuando no se está imprimiendo) y ese código que estás utilizando para la función es más complicado de lo que debería: solo necesitas definir las asignaciones y no es necesario, ni pasar las variables en la llamada, ni retornar los parámetros.
Si te cansas de intentarlo (no quiero estropearte la satisfacción de conseguirlo por uno mismo), no tengo inconveniente en indicarte el código que creo debería funcionar para realizar todo esto y que sigue el esquema que te indiqué al final de mi respuesta #8.
Por otro lado, si tienes las placas colocadas en el origen de la máquina, ¿para qué utilizas un INSET? Con eso solo estás reduciendo la malla del MBL, cuando puedes hacer que esta sea el total de la placa (pues utilizas la herramienta como sensor, ¿no?): fija los valores MESH_MIN_X y MESH_MIN_Y a 0 en el archivo Configuration_adv.h y los valores MESH_MAX_X y MESH_MAX_Y serán los que indiques en el menú, con lo que la malla del MLB tendrá el tamaño de la placa.
En todo caso, si el contacto de la fresa es problemático en el borde, fija los valores mínimos a la distancia que asegure un buen contacto (uno o dos milímetros) y al asignar los valores MAX resta ese mismo valor.
  Responder
#11
Buen día, anoche seguí probando como me comentaste y ahora a la mañana también y sigo sin poder asignar los valores. Con respecto al valor  MESH_INSET, no lo coloque a cero porque los soportes que sujetan a  la placa me restan unos 2mm del borde de la misma, y además agregue un pico aspirador cerca de la fresa que no me permite colocar MESH_INSET a cero, dado que de ser asi, el pico aspirador chocaria con los soportes. El valor de 10mm talvez lo podría llevar a 6mm o 7mm, para como bien decís tener una malla que abarque mas superficie en la placa y al momento de que se genere la interpolacion lineal de los valores de la matriz de 3x3, conseguir un  mejor resultado al menos en la cercania al borde de la placa, pero creo que esos 3mm que ganaria por cada borde no generaria un cambio muy significativo, y ademas me aseguro de que no se produzcan golpes ni en la fresa ni en el pico aspirador.
Con respecto a la programacion te paso las modificaciones que hice, la verdad que hay cosas que sigo sin entender y te pido disculpas por seguir consultando algo que se que es basico pero que no me termina de funcionar.

Realice los siguientes cambios, y en cierto modo logre un código mas "limpio". Al costado de cada código comente lo que me llamo la atencion.

1-. Modifique el archivo *.h con su función, para que sea mas sencilla:
Aqui no pude definir a las variables como "extern", no me reconocia las variables que definia en este mismo archivo.
[Imagen: image.png]

2-. En el archivo MenuMain.cpp, si agrego el #include de mi archivo *.h, me indica un error. Sin saber mucho creo que es porque ya estoy llamando a este archivo, al momento de llamar al menu de Tamaño de Placa.
El void menu_placa(), lo agregue cuando empece a programar, mas que nada porque vi como se programaban los otros menues
[Imagen: image.png]

Aca es cuando genero el menu y llamo al archivo menu_placa.cpp que a su vez ya tiene el #include de menu_placa.h. La ruta de acceso al archivo es la correcta.
[Imagen: image.png]

Y es aqui cuando quiero llamar al #include de menu_placa.h en el archivo menu_placa.cpp y el compilador me marca error.
[Imagen: image.png]

3-.Algo parecido me ocurre con el archcivo MarlinCore.cpp, si agrego la linea #include con el archivo *.h, el compilador me indica un error de compilacion.
[Imagen: image.png]

4-. Programacion en void setup() de MarlinCore.cpp para inicializar las variables. Aca paso algo que no entiendo ( entre un monton de cosas mas que no termino de entender )
[Imagen: image.png]

No entiendo porque aqui si tengo que definir como "extern" a las variables para que puedan inicializarse bien. De hecho, probé anulando la definición de variables aqui, y luego agregar la linea de #include con el archivo *.h que ya las define, pero me luego el compilador me indica que las variables "tamano_x" y "tamano_y"  "no estan definidas en este scope". 

5-. Por ultimo realice el llamado a la función en el lazo IDLE ROUTINE y eso lo compilo sin problemas. 
[Imagen: image.png]

El tema viene a que no se si en realidad llama a la función, porque en ningún momento puedo hacer referencia al archivo "menu_placa.h" en donde se encuentra la misma, por las fallas de compilación que comente antes si agrego esa linea #include

Si me podes seguir orientando te lo agradezco, porque ya probe y sigo probando un monton de cosas y sigo sin poder terminarlo. Muchisimas gracias en serio por responder las otras veces.
  Responder
#12
Hola, siento darte malas noticias, pero hay un problema que desconocía (por no estudiar C++ como debería, tendré que ponerme a ello) en la forma en que se ha planteado la solución para esta funcionalidad que quieres realizar, relacionado con la sentencia #define: los parámetros que se definen con ella no son constantes propiamente dichas, sino directivas para el compilador, que le indican que sustituya todas las apariciones de ese parámetro, por su valor asignado en el #define directamente en el código, por lo que no tiene ningún efecto asignarles ningún valor durante la ejecución del programa.
En todo caso, sigo pensando en una posible solución y como ya tenía la respuesta preparada, la pongo de todas formas para que veas como sería el código para realizarlo, si funcionase la asignación de los valores de las variables a los parámetros del MESH.

"Para implementar todo esto, habrá que crear archivos nuevos y modificar algunos que ya existen en Marlin, en cuyo caso indicaré los cambios a realizar en ellos con el código en color verde.
Primero decir que es una buena práctica de programación en Marlin, utilizar parámetros de control para implementar las funcionalidades que pueden o no estar definidas a voluntad del usuario (el parámetro HAS_PLACA en tu caso), pero lo más habitual es simplemente comprobar si está definido, no siendo necesario asignarle ningún valor en especial.
Para ello, solo hay que utilizar la función ENABLED() que existe para esta finalidad: en el código que voy a indicar, utilizaré este método con un parámetro denominado DEF_PLACAS.
Estos parámetros de control se utilizan para ahorrar memoria flash, evitando que se compile el código que no esté definido, por lo que debe comprobarse antes de cualquier código relacionado con ese parámetro: no tendría mucha lógica quitar partes de código y dejar otras.
También es muy recomendable, utilizar la estructura de directorios que tiene Marlin para ubicar los archivos nuevos, de esa forma será mucho más fácil mantener el código.
El lugar apropiado para definir el parámetro de control y los valores iniciales de los parámetros que indican las medidas por defecto de la malla del MBL, es el archivo Configuration.h.
Una cosa a tener en cuenta es que si se definen sus valores, Marlin no aplicará en ellos el MESH_INSET, por lo que hay que darles directamente el valor definitivo que queramos que tengan.
El código lo incluiré al final del archivo y quedaría así:

Archivo: Marlin\Configuration.h

...

// Disable servo with M282 to reduce power consumption, noise, and heat when not in use
//#define SERVO_DETACH_GCODE

/**
* Habilita la definición del tamaño de placa
*/
#define DEF_PLACAS

#if ENABLED(DEF_PLACAS)
  #define MESH_MIN_X 10
  #define MESH_MIN_Y 10
  #define MESH_MAX_X 20
  #define MESH_MAX_Y 20
#endif



Siguiente paso: declarar las variables que utilizaremos para cambiar las medidas de la placa y la función donde se asignará el valor de dichas variables a los parámetros de la malla, en un nuevo archivo .h que se incluirá en donde sea necesario utilizar esos objetos: lo denominaré placa.h y lo colocaré en la carpeta [b[feature[/b]. Dado que estas variables se tendrán que modificar fuera del ámbito donde se van a definir, habrá que declararlas como externas.
El código sería así:

Archivo: Marlin\src\feature\placa.h

/**
* Marlin 3D Printer Firmware
* Copyright © 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright © 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once

extern uint8_t tamano_x, tamano_y;

void calculo();



Siguiente paso: definir el código de la función que asignará los valores actuales de las variables a los parámetros MESH, en un nuevo archivo .cpp que denominaré placa.cpp: (Aquí es donde está el problema)

Archivo: Marlin\src\feature\placa.cpp

/**
* Marlin 3D Printer Firmware
* Copyright © 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright © 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <https://www.gnu.org/licenses/>.
*
*/

#include "../inc/MarlinConfig.h"

#if ENABLED(DEF_PLACAS)

#include "placa.h"

void calculo(){

#undef MESH_MAX_X
#define MESH_MAX_X tamano_x;
#undef MESH_MAX_Y
#define MESH_MAX_Y tamano_y;

}

#endif //DEF_PLACAS



Siguiente paso: Definir en el archivo de lenguaje que estemos utilizando, las cadenas de caracteres que se utilizarán en el menú. En este caso, utilizamos tres:

Archivo: Marlin\src\lcd\lenguage\lenguage_es.h

...

/**
* Spanish
*
* LCD Menu Messages
* See also https://marlinfw.org/docs/development/lcd_language.html
*/

namespace Language_es {
  using namespace Language_en; // Inherit undefined strings from English

  constexpr uint8_t    CHARSIZE                            = 2;
  PROGMEM Language_Str LANGUAGE                            = _UxGT("Spanish");
 
  #if ENABLED(DEF_PLACAS)
PROGMEM Language_Str MSG_PLACA = _UxGT("Tamaño de Placa");
PROGMEM Language_Str MSG_TAMANO_X = _UxGT("Tamaño X");
PROGMEM Language_Str MSG_TAMANO_Y = _UxGT("Tamaño Y");
#endif


...


Siguiente paso: definir el menú donde se seleccionará el tamaño de la placa, en un nuevo archivo .cpp que denominaré menu_placa.cpp. En el solo hay que poner las sentencias necesarias para que funcione, definiendo los valores mínimo y máximo que podrán tener las variables (en este caso he utilizado las que tú habías puesto anteriormente), quedando así:

Archivo: Marlin\scr\lcd\menu\menu_placa.cpp

/**
* Marlin 3D Printer Firmware
* Copyright © 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright © 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <https://www.gnu.org/licenses/>.
*
*/

/**
* Menú Placa
*/

#include "../../inc/MarlinConfig.h"

#if ENABLED(DEF_PLACAS)

#include "menu_item.h"
#include "../../feature/placa.h"

uint8_t tamano_x = MESH_MAX_X;
uint8_t tamano_y = MESH_MAX_Y;


void menu_placa() {

START_MENU();
BACK_ITEM(MSG_MAIN);

EDIT_ITEM_FAST(uint8, MSG_TAMANO_X, &tamano_x, 20, 190); 
EDIT_ITEM_FAST(uint8, MSG_TAMANO_Y, &tamano_y, 20, 155); 

END_MENU();

}

#endif //DEF_PLACAS



Siguiente paso: enlazar ese menú que hemos creado con el menú general de Marlin, cosa que puede hacerse en cualquier punto de él, en este caso lo haré directamente en el menú general, que se encuentra en el archivo menu_main.cpp. Hay que incluir varias cosas en distintos puntos del archivo, quedando así:

Archivo: Marlin\src\lcd\menu\menu_main.cpp

...

//
// Main Menu
//

#include "../../inc/MarlinConfigPre.h"

#if HAS_LCD_MENU

#include "menu_item.h"
#include "../../module/temperature.h"
#include "../../gcode/queue.h"
#include "../../module/printcounter.h"
#include "../../module/stepper.h"
#include "../../sd/cardreader.h"

#if ENABLED(DEF_PLACAS)
#include "../../feature/placa.h"
#endif



...

void menu_temperature();
void menu_configuration();

#if ENABLED(DEF_PLACAS)
void menu_placa();
#endif


#if HAS_POWER_MONITOR
void menu_power_monitor();
#endif

...

void menu_main() {
  const bool busy = printingIsActive()
    #if ENABLED(SDSUPPORT)
      , card_detected = card.isMounted()
      , card_open = card_detected && card.isFileOpen()
    #endif
  ;

  START_MENU();
  BACK_ITEM(MSG_INFO_SCREEN);

  #if ENABLED(DEF_PLACAS)
SUBMENU(MSG_PLACA, menu_placa);
  #endif


  #if ENABLED(SDSUPPORT)

    #if !defined(MEDIA_MENU_AT_TOP) && !HAS_ENCODER_WHEEL
      #define MEDIA_MENU_AT_TOP
    #endif

...
[/color]


Siguiente paso: inicializar las variables y colocar la llamada a la función que asigna sus valores actuales a los parámetros MESH. Como lo primero solo es necesario realizarlo cuando se reinicia Marlin, lo colocaremos en el bucle de inicialización (Setup); para los segundo, dado que no sabemos en que momento se utilizará el menú para cambiar los valores, pero sí que será mientras la impresora está en espera (sin imprimir), lo colocaremos en el bucle precisamente de espera (IDLE), con lo que se asignarán los valores en la primera ejecución posterior a su modificación. Los dos bucles indicados, se encuentran en el archivo MarlinCore.cpp y quedaría así:

Archivo: Marlin\src\MarlinCore.cpp

...

/**
* About Marlin
*
* This firmware is a mashup between Sprinter and grbl.
*  - https://github.com/kliment/Sprinter
*  - https://github.com/grbl/grbl
*/

#include "MarlinCore.h"

#if ENABLED(DEF_PLACAS)
#include "feature/placa.h"
#endif


#include "HAL/shared/Delay.h"
#include "HAL/shared/esp_wifi.h"

...

*  - Auto-report Temperatures / SD Status
*  - Update the Průša MMU2
*  - Handle Joystick jogging
*/
void idle(bool no_stepper_sleep/*=false*/) {

  #if ENABLED(DEF_PLACAS)
calculo();
  #endif


  #if ENABLED(MARLIN_DEV_MODE)
    static uint16_t idle_depth = 0;
    if (++idle_depth > 5) SERIAL_ECHOLNPGM("idle() call depth: ", idle_depth);
  #endif

...

*  - Init TFT LVGL UI (with 3D Graphics)
*  - Apply Password Lock - Hold for Authentication
*  - Open Touch Screen Calibration screen, if not calibrated
*  - Set Marlin to RUNNING State
*/
void setup() {

// Medidas iniciales placas
  #if ENABLED(DEF_PLACAS)
    int8_t tamano_x = MESH_MAX_X;
    int8_t tamano_y = MESH_MAX_Y;
  #endif

 
  #ifdef FASTIO_INIT
    FASTIO_INIT();
  #endif

...


Como es lógico, he comprobado que lo anterior compila sin errores, pero eso no es garantía de que funcione correctamente: tendrás que probarlo y ya me dices."

Como he idicado, ya he comprobado que no funciona.
  Responder
#13
Buenas noches, acabo de probar y tampoco me funciona. Muchísimas gracias por el tiempo y la dedicación, es una lastima que no se pueda hacer. Lo que voy a hacer es que cada vez que cambie el tamaño de la placa, reinstalar el firmware para cada tamaño en particular, son 5 minutos nada mas. Igualmente voy a seguir investigando, habia visto cuando empece a pensar en hacer el menu, un foro en ingles que preguntaban lo mismo, y lo trataron de hacer con comandos G y M de marlin, y segun ellos funcionaba, pero yo lo probe y no hacia nada.
De nuevo muchas gracias, y si se me llega a ocurrir algo para hacerlo, aunque creo que va a ser dificil, lo publico. Muchas gracias!!!!!!
  Responder
#14
Utilizando las rutinas de autolevel que trae programadas Marlin, no hay forma sencilla de cambiar el tamaño de la malla, su programación está muy intrincada.
Seguiré pensando sobre ello, así que date una vuelta por aquí de vez en cuando: si se me ocurre algo, lo pondré en este post.
Un saludo.
  Responder
#15
Gracias!! Yo voy a seguir intentando. Por lo pronto lo que se me ocurrio y estoy probando ahora, es definir a MESH_MAX de cada eje como variables del tipo float, y anular todas las definiciones de MESH_MAX como directvivas del compilador. El tema es que tiene relaciones con otras directivas, y tambien las estoy definiendo como variables. Pero no se si eso puede funcionar, al menos me sirve para probar y practicar algo de C++ y tratar de entender como funciona Marlin. Saludos
  Responder
#16
Sí, eso fue lo primero que se me ocurrió, pero hay algunas "trampas" que hacen que se complique un poco la cosa.
Si solo se utilizasen los parámetros por su nombre, no sería complicado hacer un cambio por variables, mediante la función reemplazar en VSC, pero en algunas partes del código se utilizan esos parámetros denominados mediante una función de sustitución de la letra del eje correspondiente en el nombre del parámetro, por ejemplo en el archivo ubl.cpp, línea 70:

#define _GRIDPOS(A,N) (MESH_MIN_##A + N * (MESH_##A##_DIST))

Al ver eso abandoné la idea, porque puede que haya cosas como esa en alguna otra parte y revisar todo el código me parece mucha tela.
  Responder
#17
Buenas, yo de nuevo jaja. Bueno pude hacer lo que queria, pero sin implementar los menues. Lo que hice fue lo siguiente:
- Actualice Marlin a la ultima version, con el bugfix inluido.
-Despues active la funcion AUTO BED LEVELING BILINEAR desde el archivo configuration.h
- Luego lo unico que tengo que hacer es manejarme con comandos Gcode... por ejemplo con G29 indico el "tamaño" de la placa, con el origen de la misma como el origen del home de la impresora.

Es muy sencillo de implementar, lo unico que tengo que hacer es agregar algunas lineas de codigo en el archivo gcode de la placa y listo.
Hay algo importante, si se usa la punta de la fresa como punta de prueba, para que haga contacto con el cobre de la placa, y determinar cuando toca la fresa a la placa, hay que configurar el endstop de Z como true. Y activar FIX_MOUNTED_PROBE desde marlin.
Estoy probando y la verdad que funciona muy bien. No use la funcion UBL ( unified bed level) porque no me permite modificar el "tamaño" de la placa.
La verdad que era mucho mas facil de lo que pensaba, me sirvio muchisimo todo lo que me explicaste, porque asi puede entender algo de como funciona y se configura marlin. Si alguien llega a necesitar que detalle mas el proceso, subo todo paso a paso, pero esta bueno hacerlo uno mismo. A mi me sirvio mucho, programar no se cuantas veces la impresora para darme cuenta de un monton de cosas, que ya ahora no me las olvido. Eso si, siempre es conveniente ir haciendo copias de seguridad de la ultima version del firmware que les funcione, porque a mi me paso que en un momento modifique muchos parametros juntos de Marlin, y despues fallo la compilacion,y me costo mucho darme cuenta donde estaba la falla.
SImemart, muchisimas gracias por la dedicacion y el tiempo. Saludos desde Argentina!!!
  Responder
#18
Bueno, dado que habías propuesto usar el MBL, orienté las pesquisas por ese camino, aunque la opción de utilizar otro tipo de autolevel siempre ha estado ahí.
En todo caso, me alegro que hayas llegado a una solución.
Un saludo.
  Responder


Posibles temas similares…
Tema Autor Respuestas Vistas Último mensaje
  Cambiar drivers A4988 por TMC2209 v4 Luisdjnas 154 3,365 15-07-2024, 10:23 AM
Último mensaje: Luisdjnas
  Cambiar el Z_SAFE_HOMING del autolevel a una esquina de la cama Hugo43 6 1,097 05-07-2024, 03:13 PM
Último mensaje: Caballo Loco
  problemas con universal gcode sender Jose55 6 538 14-05-2024, 12:42 AM
Último mensaje: Pedriza
  Ayuda con prusaslicer al generar gcode multicolor Miyi3D 2 142 01-04-2024, 05:55 PM
Último mensaje: Miyi3D
  CONSULTA cambiar posicion del extrusor luego de cambiar a guia lineal cesargomezp 1 92 25-02-2024, 12:12 PM
Último mensaje: Simemart