spindle at speed active at zero speed

#first, load the COMP function so we can compare the spindle speed vs the min (1,000 RPMs)
loadrt comp names=spindle-speed-not-zero

#add this to the servo thread
addf spindle-speed-not-zero servo-thread

#create our AND.  Our end goal is to only show spindle.0.at-speed when the spindle is at speed AND the spindle is over 1,000 RPMs
addf and2.6 servo-thread


#set minimum RPM to 1000 as COMP argument 1, below this the spindle is considered NOT at speed, even if the speed is 0 and the spindle is at 0
setp spindle-speed-not-zero.in0 1000

# hijack the spindle speed out pin from CL, and pipe it to our signal, as well as pipe it to COMP argument 2
net spindle-hijacked-speed <= classicladder.0.floatout-00 => spindle-speed-not-zero.in1

#Now, COMP will only return true if the spindle currently, according to the VFD, spinning faster than 1,000 RPMs
#Great, the last thing we need to do is to verify our spindle is currently AT-SPEED, which is reported via MODBUS
#from our VFD.  The pin is classicladder.0.out-01

#The first input to our AND function is the output of the COMP function above.  This will ONLY be true when
#the spindle's ACTUAL reported RPM from the VFD is greater than 1,000 RPMS, AND the spindle is currently
#at full speed according to the VFD

#This prevents the issue of the spindle being at-speed at 0 RPMs
#This command creates a signal called is-spindle-speed-over-zero and then
#takes the output of our comparator and inserts it into and2.6.in0
net is-spindle-speed-over-zero and2.6.in0 spindle-speed-not-zero.out

#Finally, we put the output of our VFD saying the spindle is at full RPMs
#and we pass that into and2.6.in1
net is-spindle-at-speed and2.6.in1 classicladder.0.out-01 

# FINALLY FINALLY, we take the output of our and2.6, and we pipe
#that into spindle.0.at-speed.  Now spindle.0.at-speed will only be true
#when the spindle is at the commanded speed, AND it is at a speed greater
than 1,000 RPMs.  At rest (0 RPMs), spindle.0.at-speed will always read FALSE
net spindle-ready <= and2.6.out => spindle.0.at-speed

#create our and2
loadrt and2

#create our edge thing here
loadrt edge

#add to servo threads
addf and2.0 servo-thread
addf edge.0 servo-thread


#create a signal that reflects the spindle.0.speed-out, which is what LCNC sets when it commands a spindle speed.  This speed will be set #immediately on the GCODE call and will NOT be delayed by the VFD.  Then pipe this data into our edge function.
net lcnc-spindle-speed <= spindle.0.speed-out => edge.0.in

#now, edge_inverted is going to be outputting TRUE at idle, but when we command the spindle speed to be something other than 0 we
#want it to output a signal for a certain amount of time to block off the spindle.0.at-speed pin

#set the output pulse to 2 seconds, so when the edge is detected it will output FALSE for 2 seconds before outputting true.  this way we still get #spindle.0.at-speed = TRUE at 0 RPMs (which I think is good for any GCODE macros that use G1 commands)
sets spindle-signal-edge.0.out-width-ns 2000000

#pipe both of these into input 1 of our and2 function
net edge-detect and2.0.in <= edge.0.out-invert

#now pipe spindle.0.at-speed into input 2 of our and2 function
net spindle-speed-achieved and2.1.in <= spindle.0.at-speed

#finally, take that value and pipe it into our spindle.0.at-speed function
net spindle-ready <= and2.0.out => spindle.0.at-speed

#Create our oneshot thing here
loadrt oneshot

#Add to servo threads (I already am using a bunch of and2s so I had to start at and2.6)
addf and2.6 servo-thread
addf oneshot.0 servo-thread

#Create a signal that reflects the spindle.0.speed-out, which is what LCNC sets when it commands a spindle speed.  
#This speed will be set immediately on the GCODE call and will NOT be delayed by the VFD.  Then pipe this data into our oneshot function.
net lcnc-spindle-speed <= spindle.0.on => oneshot.0.in

#Now, oneshot.out-not is going to be outputting TRUE at idle, but when we command the spindle speed to be something other than 0 we
#want it to output FALSE for a certain amount of time to block off the spindle.0.at-speed pin, otherwise it can cause a race
#condition where the spindle is still TRUE because the VFD hasn't had time to process
#the spindle speed command


#This is where we set the output pulse length.  You can set this to whatever you want, but in my case I set it to 2 seconds
#because I did a bunch of tests on my VFD and it never took more than 500ms to recognize the input signal, so I multiplied that
#by 4x for safety.  If your VFD is slower, then you may need to lengthen this.

#The logic of this function is that the absolute instant a newly-commanded spindle speed is detected, this signal will output FALSE for 
#2 seconds before outputting true.  this way we still get  spindle.0.at-speed = TRUE at 0 RPMs
#(which I think is good for any GCODE macros that use G1 commands)
setp oneshot.0.width 2

#pipe this signal into input 1 of our and2 function
net oneshot-detect and2.6.in0 <= oneshot.0.out-not 

#now pipe the VFD spindle-at-speed output pin into input 2 of our and2 function
#This is my CL pin, if you use a different pin or something like VFDMod you'll need to 
#update this to use your pin
net vfd-says-spindle-speed-achieved and2.6.in1 classicladder.0.out-01 

#finally, take the output value of our and2 function, and pipe it into our spindle.0.at-speed function
net spindle-ready <= and2.6.out => spindle.0.at-speed