Best posts made by cjm

The following macro uses some conditional G-code and spindle RPM feedback via the Fan[0].RPM pin to wait for the spindle to spin up to speed after running an M3/M4 command:

; WaitForSpindle.g

; If the spindle is stopped or not configured then break
if {spindles[0].state == "stopped"} || {spindles[0].state == "unconfigured"}
	break;

; initial delay to allow the VFD to start the spindle
G4 S2

var reached_speed = false;
while var.reached_speed == false	
	var old_rpm = fans[0].rpm
	G4 S1
	var delta = {fans[0].rpm - var.old_rpm}
	set var.delta = {abs(var.delta)}
	if var.delta < 5
		set var.reached_speed = true
	if iterations > 30
		break;
		
echo "Spindle rpm reached" 

Many Variable Frequency Drives (VFD) used to control CNC spindles have a spindle speed output giving one pulse per revolution.

I’d like to propose a firmware option that would configure one of the micro’s timers to measure the frequency of this signal and hence the actual RPM of the spindle.

Why would that be useful?

Well, it could be used to do things like:

a) ensuring the spindle is fully up to speed after an M3/M4 (this is most important as it avoids the risk of trying to cut metal with a too low spindle speed);

b) closing the loop around the spindle speed, to improve the loss of accuracy one usually gets using PWM/analogue speed control with low cost VFD; and

c) enabling DWC to display the actual spindle RPM.

To be fair, point a) could equally be addressed by enabling an M3/M4 dwell time in the M453 CNC mode setup command, but this wouldn’t give you b) and c)....

I’ve been using the preview version for a few jobs and find it a big improvement on the standard DWC for CNC. A couple of thoughts from this experience are:

The X and Y are displayed to 1 decimal place. For me it would be useful to be able to see 2 decimal places, perhaps selectable as a machine specific option, or maybe just on the DRO plug-in screen?

In the jog plug-in screen, buttons to set X,Y and Z to zero in the current work coordinate system would be very useful (as has been mentioned by others).

However, perhaps a better option might be to provide access to macro buttons on the right hand side of either the jog screen or DRO screen and then we can define our own macros to set XY, do Z-probing etc.?

@t3p3tony To answer your question about what "everything" is, the circuit below is an example of a very simple opto-isolated interface that delivers all the key output signals needed to control pretty much any low cost VFD (as far as I can see):

VFD Speed
VFD Run/Stop
VFD Direction
VFD Reset

It is powered on the VFD side by the +12V supply commonly available from such VFD and on the Duet side by the +3.3V supply.

The circuit also provides an opto-isolated input so the Duet can read the tacho pulse from the VFD Frequency connection.

As identified by several people across the Duet3D CNC forum, this would allow:
a) display of the actual spindle RPM on the Duet Web Interface;
b) M3, M4 and M5 commands to wait for the spindle to get to speed before moving to the next G-code command; and
c) adding a feedback loop to be implemented around the VFD to improve spindle RPM stability and control during machining.

The current limit and current feedback connections that Sam mentions certainly sound useful, but I haven't come across them in the low cost VFD I've investigated or worked with, so I'm afraid I can't comment on how they could be implemented.

Schematic_VFD Interface_2020-11-19.pdf

I developed this for my own personal use and if it's helpful, anyone may use/develop it as they wish - but no warranties are offered or implied!

@cjm
Update to add VFD spindle feedback

The AskPower provides a signal, labelled “Fout 5V”, that can be filtered to generate a voltage that is proportional to spindle speed. One way of getting this data into a Duet is to use an Arduino (e.g. mini pro) to convert this signal (called VFD_FREQ in this schematic) into a frequency that can be fed back to the Duet via an opto-isolator as illustrated below.

By connecting the opto-isolated square wave to pin exp.pb6 and configuring Fan 0 as below, the spindle rpm can be read as fan rpm using the Duet.

; Fans
M950 F0 C"!fan0+^exp.pb6" Q1000 					; Fan 0 uses the Fan0 output. inverted for PWM, and PB6 as a tacho input with pullup resistor enabled

An arduino script to do the voltage to frequency conversion is:

//  VFD_Sketch_0.03
//
//  License: GPL-3.0
//
//  Helpful reference: https://playground.arduino.cc/Code/FastPWM/
//
//  Sketch to measure a 0 to 5.0V VFD frequency output and generate a 
//  tacho pulse whose frequency is proportional to the spindle RPM.
//
//  The VFD frequency output range is 0 -> 5.0V.
//  Using the 16MHz/5V version of the Mini Pro this will
//  deliver an ADC range of 1024 LSB (i.e. 0->1023)
//
//  Revs per Second (RPS) = 400 * adcValue_lsb / 1024 
//
//  Using Timer2 and with F_CPU = Arduino CPU frequency 
//
//  timerClock = F_CPU / (2 * prescaler)
//  frequency = timerClock / (OCR1A + 1)
//
// So:
//  400 * adcValue_lsb / 1024 = F_CPU / (2 * prescalar * (OCR1A + 1))
//
//  and:
//  [prescaler * (OCR1A + 1)] = (F_CPU * 1024 / (2 * 400))/ adcValue_lsb
//  
// Product [prescaler * (OCR1A + 1)] is the required period expressed as a  
// number of F_CLK clock cycles  


float const calibrationFactor = 399.129F/400.0F;  //(adjust as necessary)
float const timerScale = calibrationFactor * (F_CPU / 800.0) * 1024.0;   
float adcFilter = 0.05;
float adcFilter_flsb; 

void setup() 
{
 // initialize pin 9 as an output (driven by timer 2).
 pinMode(9, OUTPUT);

 //Configure Timer 2 for fast PWM mode, 10bit resolution
 TCCR1A = _BV(COM1A0) | _BV(WGM11) | _BV(WGM10); 

 //Serial for debug
 Serial.begin(9600);
 Serial.print("F_CPU=");
 Serial.println(F_CPU);  
}

// the loop function runs over and over again forever
void loop() 
{
  
 // read and filter the input on analog pin A3 (adding 1 to avoid division by zero later)
 float adcValue_lsb = analogRead(A3)+1.0;    
 adcFilter_flsb = adcValue_lsb * adcFilter + adcFilter_flsb * (1.0 - adcFilter);
 
 //Calculate the required period in F_CLK clock cycles
 float period_clk = timerScale / adcFilter_flsb;

//Kludge: divide the period by 2 because the Duet expects 2 fan tacho pulses per rev:
// Comment this out for frequency = RPM 
 period_clk =  period_clk /2;

 //Determine the prescaler
 long prescaler = (period_clk / 65536);
 if(prescaler == 0)      // prescaler -> 1
 {  
     TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); 
     prescaler = 1;
 }
 else if(prescaler <8)   // prescaler -> 8
 {
     TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS11); 
     prescaler = 8;
 }
 else if(prescaler <= 64) // prescaler -> 64
 {
     TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS11) | _BV(CS10); 
     prescaler = 64;
 }
 else if(prescaler <= 256)  //prescaler -> 256
 {
     TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS12); 
     prescaler = 256;
 }      
 else 
 {
     TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS12) | _BV(CS10); 
     prescaler=1024;
 }

 //set timer2 period
 OCR1A = (period_clk / prescaler) - 1;

 delay(1);  
}

Hopefully at some point there'll be a firmware update to display the actual spindle speed....

If you use CamBam to generate g-code .nc files, you might like to try a new plug-in that allows these .nc files to be uploaded directly to a Duet3D board from CamBam’s Tools menu:

https://cambamcnc.com/forum/index.php?topic=9227

As you’ve already figured out, M950 allows one of the PWM capable pins on the Duet2 to be designated as the input to a PWM to analogue converter board for spindle RPM control. However, not all Duet2 pins are PWM capable so it’s best to refer to the Duet2 wiring diagram to check. IIRC various of the fan pins as well as the heated bed and extruder heater outputs are PWM capable.

With RRF3.3 and newer firmware, once the spindle control pin has been defined using M950, you then assign it to a tool using M563 and enable CNC mode, like this, for example:

M950 R0 C"exp.13" Q2000 L0:20000   ; Create spindle index 0, PWM frequency 2KHz, 
                                                  ; Lmin:max rpm ranges from 0rpm at PWM=0% to 20000rpm at 100% PWM
                                                  ; spindle speed PWM pin	: exp.13 

M563 P0 R0 S"Spindle"                             ; Create Tool 0 with Spindle 0 and call it Spindle
T0						  ; Select Tool 0 (or make sure generated by CAM)
 
; CNC Mode
M453

After this a M3 S8000 command will set the spindle RPM to 8000 rpm (for example) and M3 S0 stops the spindle. It’s possible that M5 may also stop the spindle with this setup but I haven’t checked this, so someone else would need to comment.

However, if your spindle VFD has a RUN input, then M950 can be used to define a Duet pin to control the RUN state and in this case the M5 command can definitely be used to stop the spindle:

M950 R0 C"exp.13+exp.8" Q2000 L0:20000   ; Create spindle index 0, PWM frequency 2KHz, 
                                                  ; Lmin:max rpm ranges from 0rpm at PWM=0% to 20000rpm at 100% PWM
                                                  ; spindle speed PWM pin	: exp.13 
                                                  ; spindle run pin 		: exp.8

If your VFD has a DIR input then M950 can also be used to configure a pin for this too:

M950 R0 C"exp.13+exp.8+exp.14" Q2000 L0:20000   ; Create spindle index 0, PWM frequency 2KHz, 
                                                  ; Lmin:max rpm ranges from 0rpm at PWM=0% to 20000rpm at 100% PWM
                                                  ; spindle speed PWM pin	: exp.13 
                                                  ; spindle run pin 		: exp.8
                                                  ; spindle direction pin 	: exp.14

With the DIR pin connected, M3 S8000 runs the spindle in a clockwise direction at 8000rpm and M4 S8000 runs the spindle at 8000rpm in a counterclockwise direction.

A couple of other points to note:

A) VFDs generally require higher control voltages than the Duet outputs provide, so some extra circuitry (e.g relays or opto-isolators) is needed to match the Duet control outputs to the VFD inputs

B) Some VFDs have FWD and REV inputs instead of RUN and DIR inputs. In my case (an “AskPower” unit from eBay) I found that wiring RUN -> FWD and DIR -> REV worked fine. However, this may not be a universal solution.

Edit 7/8/2021 - Closing quotation marks corrected - thanks to @Wurke for spotting this.

@sinned6915 The suggestion of using a mode 1 Z-probe certainly sounds an interesting solution.

However, are we absolutely certain that it does give a controlled deceleration, rather than just forcing a stop like all the other Z-probe options?

I ask because this appears to be an undocumented feature, although I might well have misread the Duet dictionary!

@educatingsavvas Yes, indeed.
You might be interested in the most recent post in here:
https://forum.duet3d.com/topic/19968/duet-integration-with-an-askpower-a131-vfd
This explains a way to convert the VFD analogue output voltage into a tacho pulse whose frequency is proportional to the spindle speed.

This frequency can be easily read by one of the fan tacho inputs on a Duet, using an opto isolator to keep the VFD interface electrically isolated from the Duet.

So, if M950 allowed a spindle tacho input and scale factor to be defined the Duet could use this to display actual spindle RPM and the other things suggested above like waiting after M3/M4 for the spindle to have got up to speed.

As an addendum, having had more time to explore the depths of this forum I realise I’m playing catch-up and see that similar concepts were discussed during the genesis of CNC mode: e.g.

https://forum.duet3d.com/topic/1662/running-gcode-cnc-on-duet-wifi?_=1596960514625

Nonetheless, I’d still like to suggest M3/4/5 macros as, to my mind, controlling the VFD/spindle is machine specific and so is analogous to homing, where the RRF “g-code for everything philosophy”, as implemented through the home all.g and related macros, is simple and works to great effect.

Whilst it’s also possible to implement the extra spindle machine specific commands by modifying each CAM post processor, this seems a backward step as otherwise the simple M3/4/5 are universal across different CAM applications.

Anyway, just my ha’pennies worth...

Regarding a larger panel for display of bigger coordinates, I’d definitely vote for that for CNC use. It’s a distinguishing feature of other popular CNC interfaces (Mach 3, Linux CNC etc) and I guess reflects the fact that CNCs are generally bigger than 3D printers so when setting up a job you are much further away from the control panel.

My question about spindle speed was probably a bit off-topic as I was more thinking about monitoring and displaying the actual RPM of the spindle, rather than what it is set to.

I do use M453 in my CNC config, but note that what is displayed as spindle RPM in DWC is just what the spindle has been commanded to run at, rather than what it is actually running at. This is not the same thing, particularly whilst the spindle ramps up/down in speed and if PWM/analogue control is used to set the speed.

Many spindles have a spindle speed output giving one pulse per revolution, so in principle a Duet board could use one of the micro’s timers to measure the frequency of this signal and hence the actual RPM of the spindle.

Why would that be useful? Well, it could be used to do things like ensuring the spindle is fully up to speed after an M3/M4, closing the loop around the spindle speed and enabling DWC to display the actual speed.

This is analogous to measuring and then controlling and displaying the actual extruder/heated bed temperature in a 3D printer.

@neilo The behaviour does look odd.
It is interesting that some of the part (e.g. the upper left quadrant) is machined OK over multiple layers.
As mentioned by others, this implies something is loose, perhaps a drive block, so that when the axis is driven in one direction the slack is taken up and the movement is controlled, but when there is a change of direction, the slack needs to be taken up in the other direction before movement control is restored. i.e. backlash, but with much more movement (around 4-5mm by the looks of the part) than normal.
With the spindle/router powered down and unplugged for safety, if you send the machine to XY coordinates in the middle of its range and then manually try move the spindle/axes carriages in X and Y directions what do you feel?
Everything should be tight, with no knock or play.

I'm not sure it will help but as requested here's my config.sys file:
config.g

In case they're useful for people, here are notes regarding integration of a Duet 2 with a low cost 1.5KW air cooled spindle from Ebay, controlled by an “AskPower A131” variable frequency drive (VFD) inverter.

Warning
Wiring up a VFD involves high, potentially lethal, voltages and shouldn't be undertaken without appropriate knowledge and experience.

1 VFD Mains Wiring
The VFD was connected to 240V mains power via a switch and fuse (13A) using the L and N terminals in accordance with this diagram:

2 Duet to VFD Interface
To enable the speed and direction of the spindle to be controlled by the Duet, a simple interface was built on matrix-board using parts to hand. The schematic is as follows:

Opto-isolators U1 to U4 electrically isolated the VFD controller from the Duet to avoid ground loops and reduce the risk of damage to the Duet board in the event of a fault/breakdown in the VFD. In addition, they provide the necessary level shifting from the 3.3V logic levels provided by the Duet.

Emergency Stop is provided by a normally closed button on the control pendant. In normal operation, this switch holds the Duet Emergency Stop Input low and LED in U1 is held off via D1.
When the Emergency Stop button is pressed, the switch contacts open, applying current to the LED in U1 via R3. This asserts the VFD_RESET line to rapidly stop the spindle. In addition, D1 allows R2 to pull an Emergency_Stop input to the Duet high, so it can pull the spindle up in the Z axis and halt the CNC X-Y stepper motors.

The Spindle_Run and Spindle_Dir signals control the spindle ON/OFF state and direction of rotation and drive the VFD's VFD_RUN and VFD_DIR inputs via U2 and U3 respectively.

Light emitting diodes DS1 through DS3 indicate the status of the VFD_RESET, VFD_RUN and VFD_DIR inputs and provided useful for test purposes.

The Spindle_PWM signal from the Duet is passed through U4. R10 and R11 act to limit the PWM signal generated by U4 to an amplitude of 10V, as required by the VFD. The PWM signal is passed through a second order low pass filter formed by R12, R13, C3 and C4 and a unity gain buffer (U5) to drive the VFD_Speed input. A linearity error of around 4% at 5.0V output was measured. This gives a spindle speed of around 12,480 rpm for a 12,000 rpm setting, which was felt to be OK for now. Ideally, the VFD’s frequency output signal would be used to reduce this error.

It may be noted that this circuit is generic and could be used with other VFD such as the HuanYang units.

Duet 2 Connections
The interface board was connected to the Duet 2 expansion connector using the following pins:

VFD Connections
The interface board was wired to the VFD as shown in the photo below. Note that the brown and red wires are both wired to the 12V OUT terminal and the blue and black wires are both wired to the GND terminal.

VFD Configuration
To enable external control, the VFD must be configured using its control panel.

The basic method is as follows:
a) Ensure the VFD is powered and the Spindle is stopped.
b) Press SET to put the VFD into the “Parameter Set” mode.
c) Press the up/down buttons to choose the parameter to be adjusted.
d) Press the SET button again to select the chosen parameter.
e) Press the up/down and left/right buttons to adjust the parameter value to the desired setting. The left/right buttons are used to select which digit of the numeric value is to be changed and the up/down buttons enable the value of the digit to be incremented or decremented. Holding down Up or Down will cause the selected digit to scroll through the values 0 to 9.
f) Once the value has been set correctly, press SET to store the new value. Alternatively, press STOP to cancel the operation.

Using this approach the following parameter values were configured, with all others left at their default values:

Duet Firmware Configuration
The following settings were used for the Firmware Version 3.2 Beta to take advantage of the new CNC spindle control options. However, the settings used for previous versions are included for reference, but commented out.

; Tools
M563 S"Spindle" P0 D0 H		        ; Define Tool 0 (our Spindle)
G10 P0 X0 Y0 Z0			        ; Set tool 0 axis offsets
G10 P0 R0 S0				; Set initial tool 0 active and standby temperatures to 0C

; CNC Emergency Stop
M950 J0 C"exp.e2stop"			; Define exp.e2stop as P0 to use as an emergency stop input
M581 P0 T0 S1 R0			; emergency stop (T0) when P0 (E0 end stop) edge occurs

; CNC Mode (Updated for Firmware 3.2)
M453 C"exp.13+exp.8+exp.14" Q1000 R24000 T0	; CNC Mode, PWM frequency 1KHz, max rpm = 24K 
						; spindle speed PWM pin 	: exp.13  
                                                ; spindle run pin 		: exp.8
                                                ; spindle direction pin 	: exp.14

; CNC Mode (Pre Firmware 3.2)
; M950 P1 C"exp.8"			; use pin 8 on the expansion connector as the VFD enable pin
                                        ; M42 P1 S1.0 ; to turn the spindle on 
					; M42 P1 S0.0 ; to turn the spindle off
; M453 C"exp.13" F1000 R24000     	; spindle speed PWM control using exp.13 pin, 
                                        ; PWM frequency 1KHz, max rpm = 24K
 

Update for Firmware version 3.3RC1

; Configure Tool 0 as the CNC Spindle (Firmware 3.3RC1)
M950 R0 C"exp.13+exp.8+exp.14" Q2000 L500:26200   ; Create spindle index 0, PWM frequency 2KHz, 
                                                  ; Lmin:max rpm = tweaked to match actual to target spindle RPM on 
                                                  ; and the following connections:
                                                  ; spindle speed PWM pin	: exp.13 
                                                  ; spindle run pin 		: exp.8
                                                  ; spindle direction pin 	: exp.14
M563 P0 R0 S"Spindle"                             ; Create Tool 0 with Spindle 0 and call it Spindle 
G10  P0 X0 Y0 Z0                                  ; Set Tool 0 axis offsets
M568 P0 F0					  ; Set Tool 0 to default RPM of 0
T0						  ; Select Tool 0 (or make sure generated by CAM)

; CNC Emergency Stop
M950 J0 C"exp.4"                   ; Define exp.4 as P0 to use as an emergency stop input
M581 P0 T0 S1 R0                   ; emergency stop  (T0) when P0 (E0 end stop) edge occurs

; CNC Mode (Firmware 3.3RC1)
M453    

Hope this helps someone!

@t3p3tony
RS485/Modbus is definitely a good option if its available.

Unfortunately my experience is that whilst the manuals for the cheaper VFDs available on ebay quote RS485, in practice it's not fitted, leaving analogue control as the only option.

Although written for an AskPower VFD, the following notes might be helpful as the interfaces are quite generic between different low cost VFDs.

https://forum.duet3d.com/topic/19968/duet-integration-with-an-askpower-a131-vfd?_=1619463819814

My experience is that spindle speed regulation is pretty good provided the control voltage is stable and delivered from a low impedance source. However, this may be because I'm typically machining aluminium and this may not place great demands on the VFD control loop?

The control linearity (PWM -> RPM) is around 5% which is good enough, but using the VFD feedback pulse to gently close the loop would be neat.

@o_lampe The normal approach to measure the frequency of a repetitive pulse like the VFD tacho with a micro-processor would be to connect it as the clock input to a counter/timer configured to count pulses within a given time window (e.g. 0.1 second). At the end of each time window the timer generates an interrupt and the micro reads the count which is directly proportional to the tacho pulse frequency. In this way, the processor only needs to read the timer count infrequently, without being limited by the micro's code execution.

@T3P3Tony This link describes how to attach a fan with tacho pulse output to either a Duet 2 or 3 so, as you mention, there appears to be hardware provision to read a tacho signal and RPM already:

https://duet3d.dozuki.com/Wiki/Connecting_and_configuring_fans

I wonder if the fan RPM is accessible through the Duet Object Model? If so, then for CNC use, it should be relatively straightforward to repurpose the fan RPM value for spindle speed display on the CNC version of Duet Web Control.

@samlogan87 The motivations for using a tacho pulse rather than voltage were:
a) it is easier to opto-isolate;
b) if the tacho pulse is derived from the VFD motor drive signal then in principle, the tacho frequency should be precisely related to spindle speed; and
c) it's what I had understood was being output by my VFD's frequency output terminal.

However, a little bank holiday tinkering has shown that what my low cost VFD actually provides on its frequency output is not a tacho pulse but a voltage (kudos to Sam!).

It's not a very clean voltage:

Nonetheless, the DC level appears to be proportional to the displayed spindle RPM:

A simple linear fit indicates that the RPM could be calculated from the voltage with an error of roughly +/-300 rpm:

A second order fit roughly halves the error, reducing it to +/-0.6% of full speed:

So, it looks as though this analogue VFD frequency output could give a useful indication of actual spindle RPM.

This leaves the question for "me and my CNC" of how to get this voltage into the Duet, preferably via an opto-isolated interface...

voltage to frequency converter (e.g. LM331) -> opto-isolator -> Duet exp.b6?
Σ-Δ modulator ADC -> isolator -> Duet exp.b6 -> digital filter?
ADC -> isolated spi/i2c? -> Duet spi/i2c?
?
?

@samlogan87 @T3P3Tony
I used an old Arduino to convert my VFD's "frequency output" (0-5.0V) voltage signal into a square wave whose frequency is proportional to the spindle RPM i.e.
VFD 24000 rpm -> 5.0V -> 400Hz square wave.
This square wave drives the Duet's ext.b6 pin via an opto-isolator.

The fans[0].rpm object model key gives the following results compared to the demanded M3 rpm and the RPM displayed on the VFD:

M3 S	VFD	Fans[0].rpm
24000	24000	12000
20000	20154	10150
16000	16169	8123
12000	12118	6103
8000	8154	4117
4000	4083	2090
0	0	0

The fans[0].rpm result look to be half the expected result, presumably due to fans normally having 2 pulses per revolution?

Allowing for this factor of 2, fans[0].rpm tracks the VFD/spindle frequency quite well (~0.3% error).

Ideally one would like to use config.g to define a pin as the spindle tacho source (and an associated scale factor) so that the "Current RPM" could be properly displayed. Might this make be added to a future Duet firmware update?

@sindarius Many thanks for the quick answer!

@sindarius Thanks very much - all seems to be working now.
The updated jog plug-in looks good too!

@sindarius
Somewhat ironically, I found the DRO and jog pages easier to read/use whilst the machine position panel was absent because this made the DRO text and jog buttons bigger on my screen…

Based on this, perhaps it might be interesting to be able to choose which panels are displayed on each page somewhere in the setup menus or have something like a dwc.config file for users?