bdring/grbl_esp32

A port of Grbl CNC Firmware for ESP32

Grbl (CNC Controller) For ESP32

Get the Next Generation!

The next generation of Grbl_ESP32 was such a massive upgrade we decided to change the name. It is called FluidNC and is available here. Please check it out and give us a star. It is compatible with all Grbl_ESP32 hardware.

This version is only being maintained with existing features. All new features are targeted at FluidNC.

Project Overview

Grbl_ESP32 started as a port of Grbl to the ESP32. The power of the ESP32 has allowed this firmware to grow far beyond the limitations of 8-bit AVR controllers. Here are some of the current features

• Motors

  • Control up to 6 coordinated axes (XYZABC)
  • Each axis can have 1 or 2 motors each for a total of 12 motors
  • Dual motors axes can optionally auto square using a home switch and independent control for each motor.
  • Motor drivers can be dynamically assigned to axes, so a 4 motor XYZA controller could be converted to a XYYZ (dual motor Y axis) without any hardware changes.
  • Step rates up to 120,000 per/second.
  • Trinamic (SPI controlled) stepper motors are supported including StealthChop, CoolStep and StallGuard modes. Sensorless homing can be used.
  • Unipolar stepper motor can be directly driven
  • RC hobby servos can be used as coordinated motors with acceleration and speed control.

• Peripherals

  • Limit/Homing Switches with debouncing
  • User input buttons (hold, resume, reset)
  • Coolant control (Mist, Flood)
  • Z Probe (any axis)
  • Safety Door (open door safely retracts and stops spindle, can be resumed)
  • Additional I/O via shift register and I/O expanders supported (on dev branches)

• Job Control

  • Instant feed hold and resume
  • Feed rate override
  • Spindle speed override

• Spindles

  • PWM
  • RS485 Modus
  • DAC (analog voltage) 0-10V
  • Relay Based
  • RC type Brushless DC motors using low cost BESCs
  • Laser PWM with power/speed compensation
  • Easy to create custom spindles

• Connectivity

  • USB/Serial
  • Bluetooth/Serial Creates a virtual serial port on your phone or PC. Standard serial port applications can use Bluetooth.
  • WIFI
    • Creates its own access point or connects to yours.
    • Built in web server. The server has full featured CNC control app that will run on your phone or PC in a browser. No app required.
    • Telnet sending of gcode
    • Push notifications (like...job done, get a text/email)
    • OTA (over the air) firmware upgrades.

• SD card. Gcode can be loaded and run via WIFI.

• Compatibility

  • Grbl_ESP32 is fully backward compatible with Grbl and can use all gcode senders.

• Customizable

  • Easy to map pins to any functions.
  • Custom machines can be designed without touching the main code.
  • Custom initialization
    • Kinematics
    • Custom homing
    • Tool changer sequences
    • Button macros (run gcode sequence, etc.)
    • Custom end of Job sequence
    • RTOS Real time operating system allows background monitoring and control without affecting motion control performance

• Fast boot

  • It boots in about 2 seconds (unlike Raspberry Pi, Beagle Bone). Does not need to be formally shut down. Just kill the power

Test Drive It

Grbl_ESP32 has a test drive mode. If you just compile it and load it onto an ESP32, it will create a virtual machine without any pins mapped. This allows you to safely test drive it without any attached hardware. Everything is functional including the WIFI and web user interface. Things like homing, that require feedback from actual switches cannot be done.

Using It

Important compiling instructions are in the wiki

The code should be compiled using the latest Arduino IDE. Follow instructions here on how to setup ESP32 in the IDE. The choice was made to use the Arduino IDE over the ESP-IDF to make the code a little more accessible to novices trying to compile the code.

I use the ESP32 Dev Module version of the ESP32. I suggest starting with that if you don't have hardware yet.

For basic instructions on using Grbl use the gnea/grbl wiki. That is the Arduino version of Grbl, so keep that in mind regarding hardware setup. If you have questions ask via the GitHub issue system for this project.

Roadmap

The roadmap is now on the wiki.

Credits

The original Grbl is an awesome project by Sungeon (Sonny) Jeon. I have known him for many years and he is always very helpful. I have used Grbl on many projects. I only ported because of the limitation of the processors it was designed for. The core engine design is virtually unchanged.

The Wifi and WebUI is based on this project.

Contribute

There is a Discord server for the development this project. Ask for an invite

FAQ

Start asking questions...I'll put the frequent ones here.

Donation

This project requires a lot of work and often expensive items for testing. Please consider a safe, secure and highly appreciated donation via the PayPal link below or via the Github sponsor link at the top of the page.

grbl_esp32's Issues

Add more supported file extension types

The current types supported are in this code line.

char fileTypes[FILE_TYPE_COUNT][8] = {".NC", ".TXT", ".GCODE"};

".TAP" and ".NGC" are also common types that should be added.

Thanks Colin G

error while compiling

i am using winxp10/64bit with arduino 185 , when i compile i get this error
exit status 1
'client' may be used uninitialized in this function [-Werror=maybe-uninitialized]

Add Feedback to Override Feed Rate

Hello,

I plan to use this grbl port in a Wire-Cut EDM (https://en.wikipedia.org/wiki/Electrical_discharge_machining).

Simply put, Wire-Cut EDM, is a CNC with two axis and a molybdenum or brass wire on which a voltage is applied. Between the wire and the metallic work piece a discharge happens (usually through a dielectric), when the distance between them is adequate. This distance (gap) determines the voltage and the current through the discharge circuit. This current must be kept constant by not allowing the wire to touch the work-piece and by keeping the gap constant.

The value of the current through the circuit would be the feedback needed to override the feed rate.
This would result in a feedback loop that would not allow grbl to increase the speed of x and y motors if this would result in a smaller gap, thus resulting a bigger current (worst case scenario = short circuit).
I believe a PID would be necessary too (not 100% sure, as these systems do not cut wit more than a couple of mm per minute).

I believe that an external circuit that would read the current value (average it over a few milliseconds) and outputting a proportional analog value that would be read using an analog input would work.
Another solution would be to use a digital input pin that would be toggled by this circuit slower or faster depending on the value of the current.

If anybody has other ideas about how this could be better implemented please comment.

(USG) DRO updating is sluggish

I'm reporting this thinking that maybe it's a parameter with the new board that's not quite right.
This is compared to a .9 Grbl Board
The DRO's get significantly behind when using the new board with the same Reporting Setting (3)
Also, USG takes longer to come out of locked mode when the board has completed a move. With the .9Grbl board, control is handed back to the user fairly quickly. Here, The delay is very noticable and becomes annoying quickly

Esp32 CNC board v1. > 24v
8825 Steppers at 400mv vRef
No Homing, No Limits

Suppress esp32 RTOS Startup text

You write in the readme that you want to suppress the esp32 boot messages to avoid confusing senders. You can do this in the standard Arduino/esp build by pulling gpio15 low at startup. I’ll test this today to confirm my recollection of the pin number, and update.

Problems compiling due to function not returning a value

Hi, thanks for putting this port of GRBL up on Github. I found that after downloading and trying to compile there was an error that cancelled the compile process. I think it was due to a warning in a uint8_t function which was not returning a value.

Just wanted to share that by adding the return statement to the function in spindle_control.cpp allowed it to compile so have it running on ESP32 now. I hope to wire something up to test it out over the next week or two.

uint8_t spindle_get_state() { return 0; }

Thanks again for sharing. Nice Port.

Issue during compilation

Hello,
I am trying to upload the Web_UI, and I have an issue with the BTconfig.cpp during compilation. I tried with Arduino IDE versions 1.8.5, 1.8.6 and 1.8.7. Also with Partition Scheme by default, minimal and minimal SPIFFS (modified). Always with the same result.
I am probably making some mistake so help would be great. Thanks.

Here I copy the error message:

Arduino:1.8.7 (Windows 10), Tarjeta:"ESP32 Dev Module, Disabled, Minimal SPIFFS (Large APPS with OTA), QIO, 80MHz, 4MB (32Mb), 921600, None"

BTconfig.cpp:52:23: error: variable or field 'my_spp_cb' declared void

static void my_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)

                   ^

BTconfig.cpp:52:23: error: 'esp_spp_cb_event_t' was not declared in this scope

BTconfig.cpp:52:49: error: 'esp_spp_cb_param_t' was not declared in this scope

static void my_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)

                                             ^

BTconfig.cpp:52:69: error: 'param' was not declared in this scope

static void my_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)

variable or field 'my_spp_cb' declared void

Is there a spindle direction pin assigned?

I was looking at cpu_map file to get pins I have to use and I could not find spindle direction pin.
On atmega version it is usually pin 13.
So is it possible to assign spindle direction to a pin or not yet?

Thank you!

Slack/chat channel

Do you have a slack channel or chat setup somewhere for this project?

Re: Using the SD Card

I am currently working on a driver for a Texas Instruments LaunchPad and have recently managed to run grbl as FreeRTOS-task with ethernet streaming. I am now looking into adding SD card support, and will use the protocol extension you have described.

I think using reset is a bit harsh in order to terminate a running job and see that you are proposing $FQ in order to avoid that. I reckon this implies that the "normal" input stream has to be read (and dispatched for processing) by the protocol primary loop when streaming from the SD card, but isn't that a bit dangerous? Wouldn't it be better to handle termination by issuing a top-bit set real-time command instead? This since such commands never reaches the primary loop, allowing the primary loop to be set to ignore any input not originating from the SD card.

Raspberry PI Hat version

I am really impressed by this whole project. Many Kudos to the author.

Just a heads-up in case anyone is interested.
I am working on a variation, for personal use, that will plug directly in to a Raspberry Pi.
I could use a standard Arduino, but I love the ESP32 for all things
It is mostly a personal challenge for myself, but I have other good reasons:
a) There are many mature software packages such as CNCJS that run well on a Raspberry Pi.
b) You can plug in a monitor, keyboard and mouse.
c) Support for thumb drives.
d) Frees the ESP32 to run GRBL without sharing tasks
as a side note, the CNC that I am building needs drivers more powerful than the on-board kind, so hookup is to external drivers.

Here is my progress so far,, utterly untested and unfinished:

PCB_ESP32-Wroom-to-Pi-Board_20181130205111.pdf
Schematic_ESP32-GRBL-Raspberry-PI-cape_Sheet-1_20181130205219.pdf

LaserWeb 4 and Grbl_Esp32

how to make friends LaserWeb 4 and Grbl_Esp32 via WiFi ?

Issue with eeprom library

I am having a lot of trouble compiling this firmware.
I get a fatal error: EEPROM.h: No such file or directory for a library import line in Grbl.h.

I was thinking maybe library is missing from arduino core libraries, but it was there.

I also copied that lib in the arduino projects folder and in this project folder to be safe, but still not compiling.

I then commented that import line in grbl.h and placed it in Grbl_Esp32.ino, now it passed import but since library is imported before grbl.h I get error that EEPROM.xxx is not defined SO I moved it after import of grbl.h and the "fatal error: EEPROM.h: No such file or directory" error returned.

My guess is that EEPROM.h library is conflicting with eeprom.h that is in this project.

I am probably making some stupid mistake so help would be AWESOME 💃

Leaving door pin floating causes crash loop

When I first compiled and deployed to a breadboard, I received a crash loop.

After fitting pullups to button pins things settled down.

I'll update the README.

Slack invite Please

Hi,
I would like to get a servo working for Z axis.

Promising RTOS experiments

I decided to give another look at using the RTOS better for step generation.

Since, the step generation seems very stable in the current form, I decided to try to transfer some of that code to an RTOS task. It still uses the interrupt for the timing, but virtually all the code in the interrupt is now in a task.

The priority (configMAX_PRIORITIES - 1) task is blocked with a semaphore and the interrupt unblocks it. The task calculates the next time the interrupt occurs. Right now almost everything appears to basically work, except it sounds a little different. I have not profiled an entire job or compared the steps on a logic analyzer. I have run a few complete jobs though.

The one thing I know that does not work is homing. An unhandled exception occurs when it touches the switch. I have not looked into it yet. I have not tried using the RMT feature yet.

I am not sure why I had trouble before. I think I was trying too many new things at once and was not starting with a stable base of code.

Step pulse off timing

I am not sure why the step off pulse timing is not accurate. It is weird that it works, but not accurately. It might be due to how the timer is turned on or restarted.

One solution might be to capture the pulsed on time in microseconds with esp_timer_get_time(), finish the interrupt code and add an empty while loop until another esp_timer_get_time() reaches the off time. I hate while loops in interrupts, but it should only be for a few microseconds, some of which will already have expired running the code before the while loop.

Bart

CO2 Laser controll

I like your work and I want to put a CO2 laser cut with this control instead of Arduino Mega.
I made a test bench. I set the laser mode and what I found information. But while the gcode is running, the laser does not turn on. I measured and output at 0.15 volts at 80%.
If I run the command directly (gcode sender) then it works fine.

Is there any way to attach a nextion display? I would like to experiment with it.

Thanks
I'm sorry but my English is not good.

ESP32-WROOM + RAMPS 1.4 = TRUE

I've at the moment got it up and running on pcb prototyping board and a Arduino Mega prototyping shield attached to RAMPS 1.4 running.

My question is more what inputs/outputs defined would the community prefer ?
My setup is now (ESP32 pin# as default and external pullup when needed):

ESP32 -WROOM RAMPS 1.4
Stepper enable -> X,Y,Z-Enable
X-Dir -> X-Dir
X-Step -> X-Step
Y-Dir -> Y-Dir
Y-Step -> Y-Step
Z-Dir -> Z-Dir
Z-Step -> Z-Step
X-Limit <- X-Min
Y-Limit <- Y-Min
Z-Limit <- Z-Min
Z-Probe <- Z-Max
Spindel-En -> D10 (heater)
Spindel-Dir -> D9 (heater)
Spindel-PWM -> D8 (heater)
Flood -> Servo1
Mist -> Servo2
GBRL-Reset -> X-Max
Door -> Y-Max
Start <- Servo3
Hold <- Servo4

At the moment all Vcc is 3.3 but thinking of making all inputs 5V for easy integration for common limit switches

// Agge

BLOCK_BUFFER_SIZE

BLOCK_BUFFER_SIZE is the number of moves that can be in the planner at once. The current size is 16 which is the most the AVR version can handle (RAM limited).

It would be a good idea to play with this number to see what an optimal size on the ESP32.

Add I2C I/O expander to card

I would suggest adding an I2C I/O expander to the card to allow more flexibility and resolve the limitations when using an SD card etc. An example here from TI.

TCA9555 16bit I2C I/O expander

This adds 16 I/O lines using only 3 pins (SDA, SCL and an interrupt pin) on the ESP32 board that are 5V tolerant, ESD protected and provides open drain outputs. Perfect for limit switches, mist, probe, door etc.

It only adds about a $1.50 to the BOM cost.

Dwell G4 P0.04 Causing a problem

While running over BlueTooth via Grbl Controller on Android, the job was pausing a few lines before the end.

I noticed the last line sent was G4 P0.05. That was not in the original gcode. Grbl Controller was adding G4 P0.05 at certain points. G4 is a dwell, so that line says to pause for 50 milliseconds. The real intent is to sync the planner. Grbl will process all moves in the planner before executing a delay.

It was an experiment that got left in the Grbl controller code. There is a an Issue about it here.

Strangely there is also a G4 at the beginning of the code that did not cause a problem. That comes before any moves, so the planner is already empty.

Regardless, this needs to be fixed in the firmware because that is legal gcode.

ESP32-WROVER support?

Is the wrover chip supported? The extra psram might be really useful for supporting the web UI.

Control of a VFD Spindle over RS485, ie a second serial port.

This is a port from my unpublished, but well used work using grbl-Mega

Background :
I currently use grbl-Mega to control a DIY CNC router with a work area of about 600mm x 900mm.
The spindle I currently use is an 800w spindle controlled by a 1.5KW Huanyang Variable Frequency Drive (HY01D523B) . I was looking for a more convenient platform than the Mega , and stumbled upon the ESP32 port.

Testing :
So far I've tested this with the ESP32 dev module in a breadboard , controlling a single axis , and a RS485 module , connected via a levelshifter breakout board to the ESP32 . (Note , the 3.3v version did not work well for me ) .
This setup was used to connect to the VFD over the RS485 interface.

Implementation:

The RS485 link is a two wire differential half duplex interface. The controller needs to assert a send signal
as it transmits , I've controlled this with a timer interrupt ( I've used timer 3 ) . The timer is restarted as each character is transmitted , so the transmit is held high for 4mS after the last character is send , the response is then awaited for by a task , shamelessly cloned from the main serial task. This task checks for the correct response from the VFD , and in the case of the speed request , holds up any further command processing , until the spindle has reached the required speed. If it fails to reach the required speed, the motor is sent the stop command, and an alarm ( 10) is raised.

All the interface to grbl has been implemented within spindle_control.cpp and is enabled or disabled via the Macro RS485_HUANYANG_MOTORCONTROL , currently defined in config.h. The pins used are defined in cpu_map.h , these could be the same three pins currently used by grbl for pwm control, but I've left this code in place in parallel at the moment.

To run the motor use the G-code command :
M3 S10000
To Stop the Motor use:
M5 S0
grbl doesn't seem to like commands like M5 or M3 without a speed .

Various debugging messages, written to Serial1 , can be enabled by defining DEBUGSERIAL in VFD.h

I've hard coded the BAUD rate to 38400 binary 8N1 , PD164 needs setting to 3 for this
baud rate. similarly PD165 should be set to 3 for binary 8N1 comms.

PD01 and PD02 need setting to 2 to respond to stop/start and speed commands
over RS485.

Repo currently at https://github.com/davehines91/Grbl_Esp32

New PlatformIO Announcement Sounds Exciting

They just released version 1.2.0 that allows debugging of Arduino based ESP32 projects.

• Conditional Breakpoints
• Expressions and Watchpoints
• Generic Registers
• Memory Viewer
• Disassembly
• Multi-thread support (FreeRTOS)
• A hot restart of an active debugging session

I am excited to try it out.

New Grbl_ESP32 PCB

Here is the new PCB I am working on. I will sell it in my Tindie Store as a complete assembly, but not including the plug in modules. (Stepper drivers, ESP32, P/S and SD). Here are the features.

• It has a socket for a NodeMCU 32S ESP32 board
• It has a second set of of pads next to each ESP32 pin for easy test and hacking.
• (3) Standard stepper motor sockets with jumpers for microstep selection.
• Adjustable power supply module connected to power connector. Diode OR'd to ESP32.
• SD module connector for SD testing (not supported by firmware yet)
• All inputs and output have individual ground connection.
• All inputs have R/C filter to reduce noise issues.
• All inputs without ESP32 pullups have external pullups.
• 3.5" x 3.5" size.

Attached are a schematic and rough placement. If you have comments, let me know, I will incorporate all reasonable requests.

schm_esp32_cnc_test_v2.pdf

Schematic for Grbl ESP32 Board

Request to release the schematic of the current Grbl ESP32 test board so others can easily build test units.

Pen Servo Feature

I have added pen servo features to the master branch. This allows you to use a servo as the Z axis to lift the pen. I have written a wiki page on how to use it. The is also some more info on a blog post I wrote.

Nano form factor adapter board

A couple of weeks ago there was a post about an adapter board that would allow an ESP32 module to be plugged into an Arduino Nano form factor. I am currently using STM32 boards in the Nano package and wondered if the board design is available?

I also have a laser etcher that is built in a Core-XY configuration. Works great with a standard Arduino and cheap 4 motor shield. Only issue is the speeds appear to be off by the square root of 2. Easy enough to compensate but would like to migrate this maching to the ESP and wondered if anyone has solved this problem.

WebUI Branch

At @luc-github and I have created a new WebUI branch that allows you to compile both Wifi and Bluetooth at the same time. You can only use one "radio" at a time, but you don't need to recompile to change between them. This was the top item on the roadmap.

You need to use the correct partition scheme. There is also a new command protocol to control all the options. There are details and instructions on the wiki

WiFi Feature Discussion

It is time to start thinking about how to implement WiFi. I see two basic areas to start talking talking about.

WiFi Network Type

• It is an access point (like some action cams)
  • Pros
    • No setup
    • Does not need an existing network
  • Cons
    • You have to switch away from your existing network to use it.
• It is on an existing network
  • Pros
    • You don't have to switch between networks often
  • Cons
    • You need an easy way to give it the SSID and PWD
    • You need an existing network

How do you use it

• Web Socket like LaserGRbl Supports
  • Pros
    • Some software already supports it.
  • Cons
    • This is streaming and the connection needs to be robust.
• Web Interface like very basic Octoprint
  • Pros
    • Totally self contained.
    • No apps required
    • No worry about cross platform issues. You just need a browser.
  • Cons
    • Complex project
    • Could use a lot of memory and performance

Development Board

Any plans to sell the development board?

UGS Setting Idle time to 255 (Lock steppers) 8825's get hot fast at low current (400mv Vref)

I don't have a comparison but the 8825's are very hot to the touch when the steppers are locked with no load
$1 = 255 (Step idle delay, milliseconds)

I have the Vref under 1 amp (24v main power, 400mv at the Pot on the 8825 so a current of .8 Amps).
my laser thermometer is showing the drivers are reaching 100 degrees F.

I'm not 100% that everything is super accurate but they are definitely hot (I have the heat sinks on)

I am just concerned if they are this hot at .8, where will they be when drawing 1.5 or 2 amps holding a load.

Again, I'm not sure if any of this could be caused by the board

Better Serial Data Read Performance

Regular Grbl uses interrupts to read serial data. I did not do this on ESP32 because I expected to add multiple sources of data like BlueTooth and Wifi. I am reading via the main loop. Regular job streaming is fine, but the real time command (status, hold, etc) performance is OK, but not great.

I am experimenting with using a thread on Core0 to read the data. That appears to work better. I'll test a while longer before pushing the code.

If you have issues related to this, let me know and I can post the push sooner.

More I/O Flexibility

The firmware has been changed to allow more I/O flexibility. The I/O is currently limited to the native I/O pins on the ESP32. To allow more flexible use of these pins, you can now comment out many of them.

If you have a pen machine, you could disable the spindle by commenting out #define SPINDLE_PWM_PIN. A pen machine might also use a hobby servo for the Z axis, so you could disable the step and direction pins as well.

In most cases Grbl still keeps track of these features, it just does not output the signals.

There are more details on this on this wiki page.

Note: This is currently only on the dev branch

Missing step pulse behavior

Hello,

Testing out the grbl code on a Nodemcu32s and getting some odd step pulse behavior.
Checking to see how fast x axis step pulse rate is possible with these x axis settings

$100=250
$110=3000

From position X=0
G1X100F2000 moves fine, nice step pulse output seen on the oscilloscope.

When I do a longer
G1X200F2000 move, you see the step pulse acceleration then the pulse train completely disappears and then picks back up again when it decelerates. It drops the middle portion of the move.

When I change the feed rate to a lower value such as 1000, it works fine
G1X200F1000

So at certain combinations of feed rate and move distance, it doesn't work correctly.

Regards,

Jim

Hard limit causes crash when using SD Card

Hard limit ISR calls mc_reset, which calls file close if streaming gcode from an sd card file.
close attempts to take a lock which causes the crash (can't take a lock in interrupt context).

Unsure how best to attack this, but it would be nice to gracefully recover so a software reset could be issued to bring the machine back to operating state once the hard limit switch has been cleared.

Currently requires a hard reset / power cycle to recover.

ESP32 Web-UI

This issue is to discuss the Wifi and ESP3D Web-UI features being added. This topic is for very high level discussion only. Daily discussions are being done on the Slack channel (ask for an invite)

Here is a wifi page to show off some of the features

Any vailable pins for SD card reader ?

Nice Job - congrats ^_^
looking at : https://github.com/bdring/Grbl_Esp32/blob/97407d1fde5b1fdf00663e0f4ed8c20f06874182/Grbl_Esp32/cpu_map.h
it seems like there are some pins available for SPI SD card reader and may be even I2C oled screen , but I may read wrong
Do you have the current pinout somewhere ?

WebUI: jog feed rate limits

WebUI complains if I try to set a jog rate > 9999mm/min.
My laser machine is capable of much higher speeds (with a nano 20000mm/min, but likely higher with esp32)

WebUI should probably read grbl cfg items $110-$112 to set this upper limit dynamically. (LaserGRBL does this.)

or can the limit be increased to 100000mm/min as a temporary measure?

Reading Incoming Commands

I am wondering if it might be better to create a separate task on Core0 to watch for incoming commands. It might be able to process realtime commands like "?" and feedhold better.

Right now it checks for incoming characters in the main protocol loop.

Missing functions for coreXY

Hi,

while trying to compile with coreXY enabled, it apears that system_convert_corexy_to_y_axis_steps function is missing

STEPS :
uncomment :
#define COREXY

compile

regards

pullup lim z not work

Hi,

i have the HW Version 2.1 and i have a problem with the limit switch Z. The Pullup does not work.
Is this a problem only for me or have other people the same problem?
For the next HW Version is a option for an externel pullup a good solution.

Add Probing to the WebUI

This is on the roadmap. If you have any input, please reply on this issue.

There is a public google doc where I will organize the feedback.

Additional Button Actions

I've got buttons hooked up to hold/start/reset but I've got an extra button. I notice that you've made it easy to re-assign pins that aren't being used. Thoughts on the best/easiest way to make a button feed the y-axis +1cm each time it's pressed (or something like that)?

Thanks!

Support RFC2217

rfc2217 is telnet extension for acessing remote serial line. Maybe it would be usefull to implement, because there are drivers (for most operating systems) to attach such terminal server as local serial port, so it can be used by any software which supports local serial ports.

https://tools.ietf.org/html/rfc2217

SD Card

I am getting ready to look into using an SD card to stream files. I need to determine the best command format.

Should I just mimic the marlin commands?

I think I will start with a small feature set and add features as they become necessary. What are the most basic features I need?

• Mounts at boot (no changing on the fly)
• List the files
• Select a file
• Run the file
• Get status (probably needs to follow Grbl reporting style)

Ethernet Support?

See here

https://www.olimex.com/Products/IoT/ESP32/ESP32-GATEWAY/open-source-hardware

could be nice to have also ethernet support in some way...

Add Uploadable Machine Profiles

It was suggested that we add a way to upload machine profiles. If you have any input, please reply on this issue.

There is a public google doc where I will organize the feedback.

BlueTooth Serial

The easiest way to add this feature might be to use this library.

https://github.com/espressif/arduino-esp32/tree/master/libraries/BluetoothSerial

I am not sure how to deal with multiple communications channels. I think just echoing all the traffic on all the communication channels might be best. All messages from Grbl will be sent to both Serial and BlueTooth. Messages sent by either Bluetooth or Serial will be acted upon.

This would allow you to use either without having to change a setting or recompiling. It is up to the user to not try to stream from both at the same time.

That way you won't get locked out of a channel, like if you set control to Serial, do you need a Serial console to change it to BlueTooth? That sounds like a problem.