¶ Spindles
FluidNC supports multiple spindles on one machine. Spindles can be controlled by different hardware interfaces like relays, PWM, DACs, or RS485 serial interfaces to VFDs. Lasers are treated as spindles.
Each spindle is assigned a range of tool numbers. You change spindles by issuing the GCode command "M6 Tn", where n is the tool number. Tool numbers within the assigned range for a given spindle will activate that spindle - and the detailed number within the range could be used to select the specific tool on the spindle. This lets you have, for example, a single machine with an ATC spindle and a laser. A single GCode file could allow you to etch and cut out a part. Most CAM programs support tool numbers. You could also have a gantry with both a low-speed high-torque pulley spindle and also a high-speed direct drive spindle.
¶ 0-10V
0-10V control is designed for spindle controllers that have a 0-10V control input as well as separate pins for forward and reverse direction. The ESP32 cannot directly generate a 0 to 10V signal, but some FluidNC controllers have an adapter circuit that generates a 0 to 10V analog voltage from an ESP32 GPIO that is pulsed with a pulse-width modulation (PWM) waveform. The basic PWM spindle type can also be used with such such hardware adapters, but it does not support separate forward and reverse direction pins. If you don't need that style of direction control, you can use the PWM spindle type.
-
- Type: Pin
- Range: gpio or i2so
- Default: NO_PIN
- Detail: This is used to signal forward rotation if you have separate pins for forward and reverse. It may remain on after M5, but will turn off after M4.
-
- Type: Pin
- Range: gpio
- Default: NO_PIN
- Details: This is the pin that the output PWM signal is put on. It turns off with M5. The s0_with_disable value can affect this pin.
-
- Type: Pin
- Range: gpio or i2so
- Default: NO_PIN
- Details: This pin can be used as an enable pin. The disable_with_s0 value can affect this pin.
-
- Type: Integer
- Range: 0 to 20000 (milliseconds)
- Default: 0
- Details: This is the time that will be given for the spindle to spin up to maximum RPM as defined in the speed map. The gcode following the speed change will wait until the spin up has completed. The time is proportional to the RPM change. If the change in RPM is only half of the full scale, the delay will only be half of the spinup_ms value.
-
- Type: Pin
- Range: 0 to 255
- Default: 0
- Details: This sets the range of tool numbers for this spindle. If you have multiple spindles you should set up a range for both spindles. When you specify a tool number with the M6 Tnnn gcode command it will switch to the tool that covers that range. The max value is 255. See more here
- With 1 Spindle: It does not matter what the value is, but set it to 0.
- With Multiple Spindles: Set the first spindle to 0 and the other spindles at higher values. Each spindle should have a unique number. If you have a relay spindle with tool_num: 0 and a laser with tool_num: 100, all tool numbers from 0 to 100 will use the relay and all tool numbers from 100 to 255 will use the laser. Send M6T100 to use the laser.
- speed_map:
- Type: Speed Map
- Details: This allows you to fine tune the speeds. You can linearize the RPM vs. PWM across the range and you can set things like minimum speeds. It is a very comprehensive feature that has its own page.
- off_on_alarm:
- Type: Boolean
- Default: false (works like standard Grbl)
- Details: Setting this to true will turn off the spindle whenever an alarm occurs. If you are using a safety door, you may want to enable this because the parking feature does not work in alarm mode.
Example
10V:
forward_pin: gpio.13
reverse_pin: gpio.17
pwm_hz: 5000
output_pin: gpio.4
enable_pin: NO_PIN
direction_pin: NO_PIN
disable_with_s0: false
s0_with_disable: true
spinup_ms: 0
spindown_ms: 0
tool_num: 0
speed_map: 0=0.000% 1000=0.000% 24000=100.000%
off_on_alarm: false
¶ Huanyang Registers for 0-10V control
- PD001 (Source of Run Commands) Value 1: (External Terminal)
- PD002 (Source of Frequency) Value 1: (External potentiometer)
¶ DAC
The DAC uses the ESP32's built in DAC hardware. This can only be used on gpio.25 and gpio.26. It outputs a 0-3.3V analog voltage (not PWM). In most cases a PWM will be better. The DAC resolution is only 8 bit (0-255) and a PWM can be up to 16 bit (0-65535).
example
DAC:
output_pin: gpio.25
enable_pin: NO_PIN
direction_pin: NO_PIN
disable_with_s0: false
s0_with_disable: true
spinup_ms: 0
spindown_ms: 0
tool_num: 100
speed_map: 0=0.000% 255=100.000%
off_on_alarm: false
¶ Using RS485 to Control Spindles
Unless your controller has built-in RS485 outputs, you must use a UART to RS485 adapter board to turn the serial messages of the controller to RS485 messages and vice versa. UART to RS485 adapter boards are inexpensive, and typically run on either 3.3V or 5V DC.
You must specify the UART parameters in a uart_section of the config file. We strongly recommend you specify this as a separate uart<number> section and refer to the UART number in the configuration of your spindle using uart_num. The legacy way of specifying the UART parameters inside the spindle section did not allow you to set the UART number and could cause conflicts if you defined multiple UARTs.
uart1:
txd_pin: gpio.14
rxd_pin: gpio.15
rts_pin: gpio.13
baud: 9600
mode: 8N1
The rts_pin is used for communications direction control. Some RS485 adapter chips automatically control the direction and do not need an rts_pin.
You should power your RS485 adapter with 3.3v. Otherwise the return signals to the ESP32 could be damaged.
¶ RS485 Wiring
RS485 terminals can be labeled A and B or + and -. Typically (A connects to -) and (B connects to +), but many people have found that the 2 wires need to be swapped. Often there is a ground wire. Most people have better luck without a ground connection between the controller and VFD. RS485 is a differential signal, so it does not need a ground reference.
You should use a 20 - 22 AWG twisted pair of wires. If the cable is shielded connect the shield wire to ground at one end only.
¶ LEDs
If you have Tx and Rx LEDs at the controller side the Tx should blink a few times per second. The Rx LED should blink right after. It does so so quickly that they may appear to blink at the same time. If the Rx LED stays on, try swapping A and B at the controller end.
¶ Variable Frequency Drives (VFD) controlled with RS485
These spindles are controlled with a RS485 connection. Add a top-level definition for one of the supported VFD models to your config file:
HuanyangYL620H100H2ANowForever- Danfoss VLT 2800
- Siemens v20
VFDs controlled with RS486 are a little more complicated to set up compared to PWM control, but they offer several advantages. They constantly monitor the spindle. If it appears the spindle is not working at the specified speed, the job will be stopped. It is important that the VFD is fully powered on before the the ESP32 is powered on. Some take several seconds before they are ready to communicate. Do not power cycle the VFD when the ESP32 is on. It may interrupt the communications and cause problems.
We recommend the Huanyang VFD for new users. The FluidNC firmware developers have this VFD and can help debug problems. We cannot help too much with the other types.
Most VFD can also be controlled by a 0-10V signal. This method is easier to debug by new users with a simple voltmeter.
Most problems are due to hardware, wiring, or VFD setup issues. Double check the RS485 wiring. Try swapping the data lines. Sometimes it works better without the ground wire. Be sure the VFD parameters are set correctly and the RS485 is the primary control source. RS485 can be tricky and the FluidNC developers will likely refuse to help with cheap hardware and hacky wiring.
VFD RS485 Unresponsive Message This is normal if your VFD is not connected, not powered on, or connected correctly. RS485 can be complicated for non-engineers. We cannot help you fix this for free (seriously donate big before you ask). Please read the internet on how RS485 works and how to wire it. If you want a simpler interface, try 0-10V control.
¶ The best way to get started.
-
Get your VFD and spindle running in manual control mode. It makes no sense to try RS485 until you know the VFD is working correctly. Test everything, like min RPM, max RPM, spin up and down times, forward and reverse.
-
Wire your RS485 adapter to the VFD. Devices are typically labeled with the symbols A and B or + and -. Wire the same symbols together. If you have A/B at one end and +/- at the other, A goes to - and B goes to +. Wire ground to ground.
-
If things don't work, try swapping the A/B or +/- wires at one end. If that does not work, try removing the ground connection wire with both combinations of the A/B, +/- wiring.
-
Double check that you are in RS485 control mode. Check that the baud rate setups match on each end.
¶ Huanyang VFD with RS485
This is the standard Huanyang VFD (all power levels). Part numbers start with Hy, like HY02D223B-T. The control is via RS485.
The VFD registers need to be set up prior to use. FluidNC will not change any of the registers. Read your VDF documentation on how to do that. Here are some typical values that work for most spindles.
| Register | Value | Description |
|---|---|---|
| PD001 | 2 | RS485 Control of run command |
| PD002 | 2 | RS485 Control of frequency |
| PD004 | 400.00 | Base frequency as rated on spindle |
| PD005 | 400.00 | Maximum frequency Hz (400Hz * 60sec/min = 24000rpm) |
| PD011 | 100.00 | Minimum speed in Hz (Typ. Air cooled 120, Water cooled 100) |
| PD014 | 6.0 | Acceleration time in seconds |
| PD015 | 6.0 | Deceleration time |
| PD023 | 1 | Enable reverse |
| PD141 | 220.0 | Spindle Voltage |
| PD142 | 3.7 | Max current (typ. 0.8kw=3.7) |
| PD143 | 2 | Poles |
| PD144 | 3000 | Revolutions at 50Hz |
| PD163 | 1 | RS485 Modbus address |
| PD164 | 1 | Baud rate of 9600 |
| PD165 | 3 | RS485 Mode RTU, 8N1 |
The min and max speeds set in the VFD will be displayed in the startup messages. They might be spread out through the messages, because they are coming from a separate task.
[MSG:INFO: Huanyang PD011,PD005 Freq range (100,400) Hz (6000,24000) RPM]
[MSG:INFO: Huanyang PD144 Rated RPM @ 50Hz:3000]
[MSG:INFO: Huanyang PD143 Poles:2]
[MSG:INFO: Huanyang PD014 Accel:6.000]
[MSG:INFO: Huanyang PD015 Decel:6.000]
A minimum speed is typical with VFD spindles because they lack power and can overheat at lower speeds. A good speed linearization setting for the values above would be...
speed_map: 0=0% 0=25% 6000=25% 24000=100%
The minimum speed of 6000 is 25% of the max speed of 24000. This setting would mean all values between 0-6000 would still result in 6000 RPM.
Check your RS485 adapter documentation for proper wiring methods and connections. Here is some information on the RS485 module.
uart1:
txd_pin: gpio.14
rxd_pin: gpio.15
rts_pin: gpio.13
baud: 9600
mode: 8N1
Huanyang:
uart_num: 1
modbus_id: 1
tool_num: 0
speed_map: 0=0% 0=25% 6000=25% 24000=100%
off_on_alarm: false
The VFD provides feedback to FluidNC. We use this to make sure the spindle is running at the right speed. If it is not running at the speed requested, it will shut down with an alarm after a few seconds. This could be due to many reasons. One reason is that the VFD has a max and min frequency setting. If you request a speed lower than the min it will run at the minimum. The same condition applies to the maximum. Therefore, if you request a speed above 0, but outside the range. The reported speed will not match your requested speed and will shut down. You will get a warning message at the serial console why this is happening. This issue can be fixed by using the correct type of speed_map.
¶ YL620 (RS485)
YL620 is a Chinese VFD made by Yalang.
They can be controlled by 0-10V analog or by RS485 (Modbus). The following notes are for RS485 use.
The VFD registers need to be set up prior to use. FluidNC will not change any of the registers. Read your VFD documentation on how to do that. Here are some typical values that work for most spindles.
The Hz values given below indicate the frequency that is sent to the motor. A typical
2-pole motor will rotate once per Hz, so to get RPMs you multiply Hz (cycles/sec) times
60 (sec/min). So a 2-pole motor at 400 Hz runs at 400 * 60 = 24,000 RPM nominally. In
practice it will run slightly slower due a real-world factor called "slip". A 24,000
nominal motor might actually run at 23,500 with no load and 23,000 RPM under load.
| Register | Value | Description |
|---|---|---|
| P00.00 | 4000 | Main frequency in deci-HZ - 4000 is 400.0 Hz |
| P00.01 | 3 | Command Source. 3 is for control via RS485 |
| P03.00 | 3 | RS485 Baud Rate. 3 is for 9600 |
| P03.01 | 1 | Modbus Address. Typically you want to use 1. |
| P03.02 | 2 | RS485 Data format. 2 is 8 data bits, 1 stop bit, no parity |
| P03.08 | 1000 | Lowest frequency in deci-Hz - 1000 is 100.0Hz |
A minimum speed is typical with VFD spindles because they lack power and can overheat at lower speeds. A good speed linearization setting for the values above would be...
speed_map: 0=0% 0=25% 6000=25% 24000=100%
The minimum speed of 6000 is 25% of the max speed of 24000. This setting would mean all values between 0-6000 would still result in 6000 RPM.
Check your RS485 adapter documentation for proper wiring methods and connections. Here is some information on the RS485 module.
uart1:
txd_pin: gpio.14
rxd_pin: gpio.15
rts_pin: gpio.13
baud: 9600
mode: 8N1
YL620:
uart_num: 1
modbus_id: 1
tool_num: 0
speed_map: 0=0% 0=25% 6000=25% 24000=100%
off_on_alarm: false
Important notes The VFD provides feedback to FluidNC. We use this to make sure the spindle is running at the right speed. If it is not running at the speed requested, it will shut down with an alarm after a few seconds. This could be due to many reasons. One reason is that the VFD has a max and min frequency setting. If you request a speed lower than the min it will run at the minimum. The same condition applies to the maximum. Therefore, if you request a speed above 0, but outside the range. The reported speed will not match your requested speed and will shut down. You will get a warning message at the serial console why this is happening. This issue can be fixed by using the correct type of speed_map.
¶ H100 (RS485)
This is the standard H100 VFD (all power levels). Part numbers typically look like H100-xxx.
The VFD registers need to be set up prior to use. FluidNC will not change any of the registers. Read your VDF documentation on how to do that.
The most relevant sections are:
F011 (min frequency)
F005 (max frequency)
The min and max speeds set in the VFD will be displayed in the startup messages. They might be spread out through the messages, because they are coming from a separate task.
[MSG:INFO: VFD: Max speed:24000rpm]
[MSG:INFO: VFD: Min speed:6000rpm]
A minimum speed is typical with VFD spindles because they lack power and can overheat at lower speeds. For speed_map, feedback and the RS485 adapter settings, see the Huanyang section for more details.
If you don't specify the speed_map, the firmware will automatically put in the default values based on the frequencies that are set in the VFD. Only specify a speed_map if you use a gearbox or other contraption.
uart1:
txd_pin: gpio.26
rxd_pin: gpio.16
rts_pin: gpio.4
baud: 9600
mode: 8N1
H100:
uart_num: 1
modbus_id: 1
tool_num: 0
speed_map: 0=0% 0=25% 6000=25% 24000=100%
¶ P2 series inverters (RS485)
The Huanyang P2 series inverters, also dubbed 'H2A/H2B/H2C' or sometimes 'P2A' inverters are supported as well. This product was designed to be the 2nd generation of the popular Huanyang inverter from hy-electrical.com. These VFD's are small, and low power VFD's are usually white or gray. The sticker on the side of the inverter clearly tells that this is the inverter in question.
The manual can unfortunately be a bit confusing at times when it comes to setting up the RS485 connection.
At the top of the box is a RS485 connector with a 4-wire screw terminal. Wiring should use these 4 pin:
- GND = GND of Arduino
- A = RS+485
- B = RS-485
- VCC = 5V of Arduino
Prefer to use a shielded wire for the connector, and never run this wire next to a 220V, stepper or spindle wire. Also, ground one end of the shielding.
ALWAYS read the manual for VFD's! This is imperative to get motor speed etc. all correct. The H2x series inverters use real RPM values, so you need to set these accordingly, or the device won't work correctly. Next to that, you need to set certain settings to get RS485 working correctly, most notably:
| Setting | Value | Description |
|---|---|---|
| F0.02 | 7 | Set RS485 mode |
| F0.04 | 2 | Set RS485 mode |
| F0.09 | 4 | Set RS485 mode |
| F9.00 | 4 | 19200 baud |
| F9.01 | 0 | 8,N,1 parity |
| F9.02 | 1 | ModBus address |
| F9.05 | 0 | Non-standard modbus mode |
| F9.07 | 0 | Write operations responded |
We recommend setting 19200,8N1 for this VFD. During spindle sync, there can be quite a bit of communication, and 2400 baud might get you in trouble. 19200 is more than enough for anything you want to throw at a VFD. Using even higher baud rates will probably just result in errors.
¶ NowForever (RS485)
Manufacturer: Shenzhen NowForever Electronics Technology CO.,LTD.
Website: http://www.nowforever.cn/
The D series of VFDs can be found in the control box of Chinese CNC6040 cnc routers.
Unfortunately there is no manual for the D series so all of this information is based on the manual for the E series.
However there is a comparison chart made by someone else that shows that almost all parameters are the same.
The manual for the E series can be found online in various places by searching for NowForever e100 manual using your preferred search engine.
Comparison chart (german, also contains link for e series manual): http://moh-computer.de/frequenzumformer-parameter/
The current implementation for supporting NowForever VFDs has been tested against the D100S1R5B (D series, 1PH AC 220V 50/60hz input, 8A output) inverter.
It should work for other VFDs in the D series too as well as the E series since its manual has been used for reference of the parameters and protocol details.
If controlling the VFD through RS485 isn't working for some reason both the D and E series support a 0-10V interface as well.
This includes controlling the direction through another input of the VFD. (See manual for details)
Here is a selection of the parameters needed to make the VFD (D and E series) communicate with FluidNC:
Selection of RS485 as control and frequency source:
| Register | Value | Description | Possible Values |
|---|---|---|---|
| P0-000 | 2 | Command source | 0: Keypad 1: Control inputs 2: RS485 |
| P0-001 | 0 | Frequency source | 0: main frequency source 1: auxiliary frequency source 2: main + aux 3: max(main, aux) 4: selectd by control input |
| P0-002 | 6 | Main frequency source selection | 0: Keypad Potentiometer 1: Keypad Up Down Arrow 2: AIN1 3: AIN2 4: Multistep speed 5: PID 6: RS485 7: Internal PLC |
RS485 parameters:
| Register | Value | Description | Possible Values |
|---|---|---|---|
| P0-055 | any free address between 1 and 31 | Address of VFD | 1- 31: slave addresses 2: master address |
| P0-056 | 2 works just fine | Baudrate | 0: 2400bps 1: 4800bps 2: 9600bps 3: 19200bps 4: 38400bps |
| P0-057 | 0 | Data framing | 0:1 start bit, 8 data bits, no parity, 1 stop bit 1: 1 start bit, 8 data bits, even parity, 1 stop bit 2: 1 start bit, 8 data bits, odd parity, 1 stop bit |
Setting min and max speed:
| Register | Value | Description | Possible Values |
|---|---|---|---|
| P0-007 | Whatever your spindle can handle | Max frequency | Min frequency - 600hz |
| P0-008 | Whatever your spindle can handle | Min frequency | 0 - Max frequency |
The following registers are read / written to by FluidNC:
Read access only:
| Register | Description |
|---|---|
| 0x007 | Max frequency in hz * 100, same as config parameter P0-007 |
| 0x008 | Min frequency in hz * 100, same as config parameter P0-008 |
| 0x300 | Current fault number 0 = no fault 1-18 = fault number |
| 0x500 | VFD status Bit 0: run, 1=run, 0=stop Bit 1: direction, 1=ccw, 0=cw Bit 2: control, 1=local, 0=remote Bit 3: sight fault, 1=fault, 0=no fault Bit 4: fault, 1=fault, 0=no fault Bit 5-15: reserved |
| 0x502 | Current output frequency in hz * 100 |
Write access only:
| Register | Description |
|---|---|
| 0x900 | VFD control Bit 0: run, 1=run, 0=stop Bit 1: direction, 1=ccw, 0=cw Bit 2: jog, 1=jog, 0=stop Bit 3: reset, 1=reset, 0=dont reset Bit 4-15: reserved |
| 0x901 | Speed to be set in hz * 100 |
Example YAML config:
uart1:
txd_pin: gpio.14
rxd_pin: gpio.15
rts_pin: gpio.13
baud: 9600
mode: 8N1
NowForever:
uart_num: 1
modbus_id: 1
tool_num: 0
speed_map: 0=0% 24000=100%
off_on_alarm: false
¶ Danfoss VLT 2800
Contributed via this PR
¶ Siemens v20
Contributed via this PR
uart1:
txd_pin: gpio.17
rxd_pin: gpio.16
rts_pin: gpio.4
baud: 9600
mode: 8E1
SiemensV20:
uart_num: 1
modbus_id: 1
tool_num: 0
speed_map: 0=0% 24000=100%
¶ (Generic) ModbusVFD (RS485)
FluidNC lets you use RS485 VFDs that are not already supported by specifying the format of certain Modbus commands via config items. You can specify the format of each Modbus command by including the config items in the ModbusVFD section. For some VFD types, we already know what the command formats should be, so instead of specifying all the commands, you can just set the model item to the VFD's name, and the command config items will be pre-populated - but you can override them. The relevant config items are:
- model: A string naming the VFD model. If the model value matches one of the predefined VFD models that FluidNC knows, the various _cmd items will be pre-populated with the values that we think are correct, so you need not specify them. If you do specify such a _cmd item, it will override the system-supplied value. If model does not match a known model, you must specify all of the _cmd items explicitly. The known models at the time of this writing are "Huanyang", "YL620", "H2A", "H100", "NowForever", and "SiemensV20". The name matching is case-insensitive, so the capitalization does not matter.
- cw_cmd: A Modbus command template telling the VFD to run in the clockwise (forward) direction.
- ccw_cmd: A Modbus command template telling the VFD to run in the counterclockwise (reverse) direction.
- off_cmd: A Modbus command template telling the VFD to stop running.
- set_rpm_cmd: A Modbus command template telling the VFD to run at a given speed.
- get_max_rpm_cmd: A Modbus command template for retrieving the maximum speed for which the VFD is configured.
- get_min_rpm_cmd: A Modbus command template for retrieving the minimum speed for which the VFD is configured.
- get_rpm_cmd: A Modbus command template for retrieving the VFDs current running speed.
- debug: An integer that controls debug messages from the VFD subsystem. Its default value of 0 means no extra debugging. Setting it to 3 enables extra messages showing Modbus commands that are sent and received. debug applies not only to the generic ModbusVFD driver, but also to other RS485 VFDs. If you set debug to a higher level, you will also need to send $message/level=debug to allow debug-level messages to show up.
- poll_ms: An integer that controls the time between VFD polling and retries. Its default value of 250 is good for working VFDs but when debugging a new VFD, it can be better to set it to much larger value like 4000 to prevent too-frequent messages when things are not working and thus causing lots of retries.
- **retries:: An integer that controls the number of retries of a failing command before the VFD is deemed unresponsive. Its default value is 5.
Speeds are given in RPM, converted to and from device-specific units via scaling specifiers in the command templates. Most VFDs specify speeds in units of Hz, possibly scaled by a factor of 10 or 100. To convert from Hz to RPM, you would multiply by 60 (seconds per minute). If the VFD uses deciHz (Hz*10), you would multiply by 60 and divide by 10 - or you could just multiply by 6.
¶ Modbus Command Templates
In general, a standard Modbus command consists of a one-byte "modbus ID" followed by a few command and data bytes, followed by two CRC check bytes. The modbus ID and CRC are handled by common code so the command template does not specify them.
The Modbus standard defines a few common command formats, but different VFDs are very loose in their interpretations of how to use them, so the Command Template format lets you specify the exact bytes to send and receive. Here is an example of a simple command that does not contain any variable data:
cw_cmd: 06 20 00 00 12 > echo
The ModbusVFD driver would send the modbus_id byte, then the hex bytes 0x06, 0x20, 0x00, 0x00, 0x12, followed by the CRC. It would then expect to receive a VFD response that is the same as the command, hence "echo'. In general, the received sequence is not necessarily the same as the command, so you will often need to specify something other than "echo".
Commands can send or receive RPM speed values. In this example, we send the speed scaled to device units of deciHz (the VFD represents 400 Hz as 4000).
set_rpm_cmd: 06 20 01 rpm*10/60 > echo
The driver would send the modbus_id byte, followed by the hex bytes 0x06, 0x20 and 0x01. It would convert the requested speed in RPM to the device units by multiplying by 10 (deciHx per Hz) and dividing by 60 (seconds per minute) and send the resulting (two-byte) number, followed by the CRC check bytes. In scaling specifiers, multiplication, if present, must precede division. Both are optional. In this example, *10/60 is equivalent to /6, so you could write just rpm/6 . "> echo" again means that this VFD responds to such commands by repeating them back.
This example receives a speed value:
get_rpm_cmd: 03 20 0b 00 01 > 03 02 rpm*60/10
The driver would send the fixed command modbus_id, 0x03, 0x20, 0x0b, 0x00, 0x01, CRC, then expect to receive the response modbus_id, 0x03, 0x02, (2-byte data), CRC. The two data bytes are combined into a 16-bit integer and scaled back from device units to RPM by multiplying by 60 and dividing by 10 - the inverse of the scaling from RPM to device units.
In addition to "rpm", you can specify "minrpm" in the get_min_rpm command and "maxrpm" in the get_max_rpm_command. For some VFDs, it is possible to get both the min and max speeds with a single command. This example works for one VFD:
get_max_rpm_cmd: 03 03 08 00 02 > 03 04 minrpm*6 maxrpm*6
If you can get both min and max in one command, it is not necessary to specify get_min_rpm_cmd; just use get_max_rpm_cmd for both. For most VFDs this will not be possible so you will need both commands.
The generic ModbusVFD driver can in fact be used to run most of the already-supported ones. Here is a complete example for YL620:
ModbusVFD:
uart_num: 1
modbus_id: 1
model: YL620
cw_cmd: 06 20 00 00 12 > echo
ccw_cmd: 06 20 00 00 22 > echo
off_cmd: 06 20 00 00 01 > echo
set_rpm_cmd: 06 20 01 rpm*10/60 > echo
get_max_rpm_cmd: 03 03 09 00 01 > 03 02 maxrpm*60/10
get_min_rpm_cmd: 03 03 08 00 01 > 03 02 minrpm*60/10
get_rpm_cmd: 03 20 0b 00 01 > 03 02 rpm*60/10
Other common Spindle config items like tool_num, spinup_ms, spindown_ms, m6_macro, atc, disable_with_s0 and s0_with disable can also be specified. If get_rpm_cmd is present, spinup_ms and spindown_ms are ignored, since the driver will use get_rpm_cmd to determine when the VFD has reached the target speed.
It is not necessary to specify speed_map, since the driver will automatically construct an appropriate speed_map base on the min and max RPM values.
If your VFD is unable to report min and/or max RPM values, it is possible to specify them explicitly via min_rpm and/or max_rpm config items with integer values given in RPM units. This is an unusual case; of the VFDs I have studied, all can report max RPM, and all but one can report min RPM.
¶ Scaling Specifiers
The named data items "rpm", "minrpm" or "maxrpm" can be scaled to VFD device units with a "scaling specifier" of the form:
[%][*N][/N]
where [...] indicates that the field is optional and N is a decimal integer. If the data item appears in the outgoing command - before the '>' - the scaling is applied to the value in RPM to convert to device units, and the converted value is inserted into the outgoing packet. The only item name that can be used for outgoing data is "rpm", in **set_rpm_command". If the data item appears in the response - after the '>' - the device unit value is retrieved from the response packet and then scaled to RPM. All of the item names are available for responses.
*N causes multiplication by the decimal number N. /N causes division by the decimal number N. For the few VFDs that represent speed values as a percentage of the maximum speed, % multiplies by 100 and divides by maxRPM, thus calculating the percentage, which can then be multiplied and/or divided by a constant. % only works correctly in set_rpm_command, for outgoing commands.
¶ Details of Scaling Operations
- For get.. commands, the 16-bit value is extracted from the VFD response packet. The divisor is set to 1. If the scaling specification starts with '%', the value is multiplied by 100. Then, if the next item in the scaling specifier is '*N', the value is multiplied by N. Then, if the next item in the scaling specifier is '/N', the value is divided by N. Finally, the value is stored in the named variable (minrpm, maxrpm, or rpm). (The '%' notation is rarely used for get operations.)
- For set_rpm_command, the divisor is set to 1. If the scaling specification starts with '%', the input value is multiplied by 100 and the divisor is set to maxRPM. Then, if the next item in the scaling specifier is '*N', the value is multiplied by N. Then, if the next item in the scaling specifier is '/N', the divisor is multiplied by N. Finally, the value is divided by the divisor and then stored in the VFD copmmand packet. (Deferring the actual division until the end prevents loss of integer precision.)
¶ More examples of using ModbusVFD
¶ Huanyang (tested)
ModbusVFD
uart_num: 1
modbus_id: 1
model: Huanyang
cw_cmd: 03 01 01 > echo
ccw_cmd: 03 01 11 > echo
off_cmd: 03 01 08 > echo
set_rpm_cmd: 05 02 rpm*100/60 > echo
get_min_rpm_cmd: 01 03 0b 00 00 > 01 03 0B minRPM*60/100
get_max_rpm_cmd: 01 03 05 00 00 > 01 03 05 maxRPM*60/100
get_rpm_cmd: 04 03 01 00 00 > 04 03 01 rpm*60/100
¶ NowForever (untested)
ModbusVFD
uart_num: 1
modbus_id: 1
model: NowForever
cw_cmd: 10 09 00 00 01 02 00 01 > 10 09 00 00 02
ccw_cmd: 10 09 00 00 01 02 00 03 > 10 09 00 00 02
off_cmd: 10 09 00 00 01 02 00 00 > 10 09 00 00 02
set_rpm_cmd: 10 09 01 00 01 02 rpm/60 > 10 09 01 00 02
get_max_rpm_cmd: 03 00 07 00 02 > 03 04 maxrpm*60 minrpm*60
get_rpm_cmd: 03 05 02 00 01 > 03 02 rpm*60
¶ H100 (untested)
ModbusVFD
uart_num: 1
modbus_id: 1
model: H100
cw_cmd: 05 00 49 ff 00 > 05 00 49 ff 00
ccw_cmd: 05 00 4a ff 00 > 05 00 4a ff 00
off_cmd: 05 00 4b ff 00 > 05 00 4b ff 00
set_rpm_cmd: 06 02 01 rpm*100/60 > echo
get_max_rpm_cmd: 03 00 05 00 01 > 03 02 maxrpm*60/100
get_min_rpm_cmd: 03 00 0b 00 01 > 03 02 minrpm*60/100
get_rpm_cmd: 03 02 20 00 01 > 03 02 rpm*60/100
¶ H2A (untested)
ModbusVFD
uart_num: 1
modbus_id: 1
model: H2A
cw_cmd: 06 20 00 00 01 > echo
ccw_cmd: 06 20 00 00 02 > echo
off_cmd: 06 20 00 00 06 > echo
set_rpm_cmd: 06 10 00 rpm%*100 > echo
get_max_rpm_cmd: 03 b0 05 00 01 > 03 00 02 maxrpm*60
get_min_rpm_cmd:
get_rpm_cmd: 03 70 0c 00 01 > 03 00 02 rpm*??
¶ SiemensV20 (untested)
Note: The register number mapping in the Siemens documentation is very confusing so I am not sure about the min and max rpm commands.
ModbusVFD
uart_num: 1
modbus_id: 1
model: SiemensV20
cw_cmd: 06 00 63 0c 7f > echo
ccw_cmd: 06 00 63 04 7f > echo
off_cmd: 06 00 63 0c 7e > echo
set_rpm_cmd: 06 00 64 rpm > echo
get_max_rpm_cmd: 03 10 82 00 01 > 03 02 rpm*60/100
get_min_rpm_cmd: 03 10 80 00 01 > 03 02 rpm*60/100
get_rpm_cmd: 03 00 6e 00 01 > 03 02 rpm
Note: According to this issue, Siemens V20 requires 8E1 mode fot the UART.
¶ Folinn BD600
board: 6x CNC Controller
name: PortalCnc by MP (@snoozemoose on Discord)
## Begin Folinn_BD600_24kRPM_@800Hz
##
# Manual where all commands are specified: https://cononmotor.com.au/wp-content/uploads/2017/09/BD600-Manual.pdf
# Initial note: This spindle defines CCW as forward running.
#
### GENERIC FORMULA FOR ANY AC MOTOR ###
# RPM = 60 x 2 x Hz / NumPoles
# Hz = RPM x NumPoles / 120
#
# This GPenny spindle has 4 poles, max Hz is 800, max rpm is 24k.
# 4 poles gives Hz = RPM * 4 /120 = RPM / 30
#
### Device speed _SET_ operation ###
# The value to send is the percentage of max Hz * 100 which is calulated as:
# targetHz / maxHz * 100 * 100
# Note; The RPM percentage of max RPM is exactly the same as the Hz percentage of max Hz.
# Note2; 100 percent is here defined as 100, not 1.0
#
# Example; setting a speed of 3k RPM (same as 100 Hz in this case)
# calculates to (3 / 24 * 100) * 100 = 1250.
# Using Hz we get the same result: (100 / 800 * 100) * 100 = 1250
#
# The set_rpm_cmd command therefore shall send the value RPM / maxRPM * 100 * 100 which is defined as:
# rpm%*100 using the syntax of FluidNC Generic ModbusVFD
#
### Device speed _GET_ operation ###
# The value received from the VFD for all fetch operations are defined as:
# currentHz * 10
# Given that this VFD and Spindle has the formula RPM = Hz * 30 (see above),
# the RPM is calculated from the received value as follows:
# receivedValue = currentHz * 10
# currentHz = receivedValue / 10
# And since RPM = Hz * 30
# RPM = receivedValue / 10 * 30
# RPM = receivedValue * 3
# Therefore, the get rpm commands defines the value calculation as:
# rpm*3 using the syntax of FluidNC Generic ModbusVFD
uart1:
txd_pin: gpio.15
rxd_pin: gpio.16
rts_pin: gpio.14
cts_pin: NO_PIN
baud: 9600
mode: 8N1
ModbusVFD:
spinup_ms: 500
spindown_ms: 1000
uart_num: 1
modbus_id: 1
model: Folinn_BD600_24kRPM_@800Hz
cw_cmd: 06 10 00 00 02 > echo
ccw_cmd: 06 10 00 00 01 > echo
off_cmd: 06 10 00 00 06 > echo
set_rpm_cmd: 06 30 00 rpm%*100 > echo
get_min_rpm_cmd: 03 F0 05 00 01 > 03 02 minRPM*3
get_max_rpm_cmd: 03 F0 04 00 01 > 03 02 maxRPM*3
get_rpm_cmd: 03 30 01 00 01 > 03 02 rpm*3
¶ PWM
The M4 (spindle reverse on) command will only be accepted if a direction pin is assigned to an I/O pin.
- output_pin:
- direction_pin:
- enable_pin:
- pwm_hz:
- disable_with_s0:
- s0_with_disable:
- spinup_ms:
- spindown_ms:
- tool_num:
- speed_map:
pwm:
pwm_hz: 5000
direction_pin: NO_PIN
output_pin: gpio.14
enable_pin: NO_PIN
disable_with_s0: false
s0_with_disable: true
spinup_ms: 0
spindown_ms: 0
tool_num: 0
speed_map: 0=0.000% 10000=100.000%
off_on_alarm: false
¶ BESC
BESC means "Brushless Electronic Speed Controller" of the type used to power propeller motors for hobby-type radio-controlled planes, helicopters, and drones. Those motors can be used for high-speed spindles on light-duty machines that do not have substantial tool side loads. They use the same type of PWM signal as an RC servo. Conventional PWM controls power by adjusting the duty cycle between 0% and 100%, whereas RC servo PWM adjusts the pulse length between (typically) 1 ms (for motor off) and 2 ms (motor full on) within a pulse repetition period of about 20 ms. Only one PWM-capable I/O pin is required. It must be a digital output pin that presents the raw PWM waveform, not a PWM-to-analog output that creates a variable DC voltage by lowpass filtering the PWM waveform.
Earlier versions of FluidNC had a special BESC spindle type, but we realized that, with suitable config settings for pwm_hz and speed_map, the PWM spindle type works perfectly for BESCs.
The usual pulse repetition rate for BESCs is 20ms which is 50 Hz in frequency units, so set the pwm_hz config item to 50 (some BESCs can operate with higher pulse repetion rates, up to perhaps 200Hz). Let's assume that the minimum pulse time is the typical 1ms (motor off) and the maximum time is 2 ms (motor full on). 1ms is 5% of 20ms and 2ms is 10%. Let's also assume that you wish to set the motor speed with GCode S values between 0 and 1000. Therefore, the speed_map config item would have the value "0=5% 1000=10%".
pwm:
output_pin: gpio.4
pwm_hz: 50
speed_map: 0=5% 1000=10%
You can fine-tune those values as needed for your specific hardware. If you want to use S values in units of RPM, and your motor runs at 20000 RPM at full power, just replace "1000" with "20000" in speed_map. Most hobby RC motors do not have speed sensors so their speed control is not precise; the RPM value would just be an approximation.
The config settings shown above are the ones that are absolutely necessary for a BESC. You can set other PWM config items for things like spinup and spindown delays.
This could also be used to control a hobby servo in an application like a pen plotter. With this setup you could use move the pen down with the GCode
M3 S1000and lift it withM5orM3 S0.
Also see the RC servo feature under motors axes.
Hobby BESCs often have a "programming mode" that can be entered by powering up the BESC with the radio control transmitter's throttle stick in specific positions, then moving the throttle to other positions after hearing beep patterns from the BESC. It is sometimes possible to do that from GCode, using commands like "M3 S0" for minimum throttle, "M3 S1000" for full throttle, and "M3 S500" for mid-throttle. Typically you would issue the first M3 command for the initial throttle position with the BESC powered off, then power it on and go through the specified sequence as the BESC responds with beeps or LED flashes.
¶ HBridge
This is like a PWM spindle except that you have separate PWM signals for clockwise (CW) and counterclockwise (CCW) rotation. This was specifically designed to directly control a H bridge circuit.
- output_cw_pin:
- Type: Pin
- Range: gpio
- Default: NO_PIN
- Details: This is the pin that the output PWM signal is put on for CW rotation. It turns off with M5.
- output_ccw_pin:
- Type: Pin
- Range: gpio
- Default: NO_PIN
- Details: This is the pin that the output PWM signal is put on for CCW rotation. It turns off with M5.
- enable_pin:
- pwm_hz:
- disable_with_s0:
- s0_with_disable:
- spinup_ms:
- spindown_ms:
- tool_num:
- speed_map:
HBridge:
pwm_hz: 5000
output_cw_pin: gpio.4
output_ccw_pin: gpio.16
enable_pin: gpio.26
disable_with_s0: false
spinup_ms: 1000
spindown_ms: 1000
tool_num: 100
speed_map: 0=0.000% 10000=100.000%
off_on_alarm: false
¶ Laser
A laser is considered a spindle because gcode does not have laser specific codes. It uses the RPM value as a power level. Lasers also have special requirements.
-
They always operate like the advanced laser mode of Grbl
- They will only operate in G1, G2, or G3 motion modes. They will not operate during G0, Jog, Homing etc. If you need it to operate in those modes, use a PWM spindle.
- They turn off when idle or doing a rapid move.
- M3 is constant power and M4 is dynamic power mode (scales linearly with speed during accel/decel)
-
speed_map: final xxx=100% can be whatever you want, but it is typically 255 or 1000. This would need to be used in the CAM software as the max power number.
-
off_on_alarm: true: is recommended from a safety point of view to ensure the laser is switched off when movement is stopped due to triggered alarm.
The 2 modes are quite different and each optimized for different types of work.
M3 Mode
This mode is primarily used for cutting through parts. The laser operates whenever you are in a feed rate controller mode (G1, G2 or G3). It will stay on at all times at the full Snnn value. This includes when there is no motion. To stop the laser you must send M5, G0 or S0. This gives you full control. For example, you may want to dwell a fraction of a second at the start or end of a cut.
Here is an example of a macro to test the laser at minimal power
M3 S1 ; lowest power
G1 F100 ; set G1 and an arbitray feedrate to turn on the laser
G4 P0.50 ; wait 0.5 seconds
G0 ; turn off the laser
M5 ; keep it off.
M4 Mode
M4 mode is primarily used for engraving. It compensates to lower the power of the laser during acceleration and deceleration to prevent darkening those sections. It will stay off when there is no motion.
Config example
Laser:
pwm_hz: 5000
output_pin: gpio.4
enable_pin: NO_PIN
disable_with_s0: false
s0_with_disable: true
tool_num: 0
speed_map: 0=0.000% 255=100.000%
off_on_alarm: true
¶ Relay
This is like a PWM signal except that the pin will be full on for any speed above 0 that you select. PWM signals can quickly destroy a relay.
- direction_pin:
- output_pin:
- enable_pin:
- disable_with_s0:
- s0_with_disable:
- spinup_ms:
- spindown_ms:
- tool_num:
- speed_map:
relay:
direction_pin: NO_PIN
output_pin: gpio.26
enable_pin: NO_PIN
disable_with_s0: false
s0_with_disable: true
spinup_ms: 0
spindown_ms: 0
tool_num: 0
speed_map: 0=0.000% 0=100.000% 1=100.000%
off_on_alarm: false
¶ Plasma
¶ NoSpindle
This is a default spindle that is automatically created if you did not specify a spindle in your config file.
NoSpindle:
¶ Using multiple spindles and tool numbers
You can define as many spindles as your hardware will support. They will act totally independently. You must use separate I/O pins for each one. Simply add each spindle definition to the config file.
Each must have a unique tool_num: If you have a gap in numbers, like the first spindle is tool_num: 0 and the second spindle is tool_num: 10, numbers 0 through 9 would belong to the first spindle. This allows any spindle to be an ATC (automatic tool changing) spindle.
If you only have 1 spindle defined you should use tool_num: 0. The spindle will accept all tool numbers.
You switch between tools with the tool change gcode (M6). M6 T2 would switch to the spindle that covers tool number 2. If the spindles are offset in one or axis, you will need to deal with that yourself.
Ways to rezero the new spindle.
-
You could use a separate coordinate system like G54 for one spindle and G55 for another.
-
You could create a little macro that zeros the machine based on the known offset, like move to zero, move the offset amount and rezero.
¶ Troubleshooting
- I get Error 20 Unsupported command for M4 M4 will only work on spindles that support reversing or lasers. If there is a direction pin for the spindle type you are using it must be assigned a pin