############ constants #############

set CARD "hm2_5i22"

#set pin(LIMIT_X_NEG)			"$CARD.0.gpio.049.in"
set pin(LIMIT_X_POS)			"$CARD.0.gpio.051.in"
#set pin(LIMIT_Y_NEG)			"$CARD.0.gpio.053.in"
set pin(LIMIT_Y_POS)			"$CARD.0.gpio.055.in"
#set pin(LIMIT_Z_NEG)			"$CARD.0.gpio.052.in"
set pin(LIMIT_Z_POS)			"$CARD.0.gpio.054.in"

set mosfet(POWER)			"$CARD.0.gpio.064"
set mosfet(CW)				"$CARD.0.gpio.065"
set mosfet(FLOOD)			"$CARD.0.gpio.066"
set mosfet(CCW)				"$CARD.0.gpio.067"
set mosfet(MIST)			"$CARD.0.gpio.068"
set mosfet(LIGHT_GREEN)			"$CARD.0.gpio.069"
set mosfet(OIL)				"$CARD.0.gpio.070"
set mosfet(LIGHT_RED)			"$CARD.0.gpio.071"

set reverse_spindle_in			"$CARD.0.gpio.089.in"

#set pin(SPINDLE_PWM)			"$CARD.0.gpio.091"

#set pin(BUTTON_SPINDLEOVERRIDE_RESET)	"$CARD.0.7i69.0.0.input-04"
#set pin(BUTTON_FEEDOVERRIDE_RESET)	"$CARD.0.7i69.0.0.input-05"

set pin(JOG_A_PLUS)			"$CARD.0.7i69.0.0.input-00"
set pin(JOG_A_MINUS)			"$CARD.0.7i69.0.0.input-01"
set pin(JOG_W_PLUS)			"$CARD.0.7i69.0.0.input-02"
set pin(JOG_W_MINUS)			"$CARD.0.7i69.0.0.input-03"
set pin(JOG_Z_MINUS)			"$CARD.0.7i69.0.0.input-04"
set pin(JOG_Z_PLUS)			"$CARD.0.7i69.0.0.input-05"
set pin(JOG_Y_MINUS)			"$CARD.0.7i69.0.0.input-06"
set pin(JOG_Y_PLUS)			"$CARD.0.7i69.0.0.input-07"
set pin(JOG_X_MINUS)			"$CARD.0.7i69.0.0.input-08"
set pin(JOG_X_PLUS)			"$CARD.0.7i69.0.0.input-09"
set pin(ENCODER_FEEDOVERRIDE_A)		"$CARD.0.7i69.0.0.input-10"
set pin(ENCODER_FEEDOVERRIDE_B)		"$CARD.0.7i69.0.0.input-11"
set pin(ENCODER_JOGSPEED_B)		"$CARD.0.7i69.0.0.input-12"
set pin(ENCODER_JOGSPEED_A)		"$CARD.0.7i69.0.0.input-13"
set pin(ENCODER_SPINDLEOVERRIDE_A)	"$CARD.0.7i69.0.0.input-14"
set pin(ENCODER_SPINDLEOVERRIDE_B)	"$CARD.0.7i69.0.0.input-15"
set pin(ENCODER_MAXVELOCITY_B)		"$CARD.0.7i69.0.0.input-16"
set pin(ENCODER_MAXVELOCITY_A)		"$CARD.0.7i69.0.0.input-17"
set pin(PROGRAM_PAUSE)			"$CARD.0.7i69.0.0.input-18"
set pin(CLEAR_ERRORS)			"$CARD.0.7i69.0.0.input-19"
set pin(PROGRAM_STEP)			"$CARD.0.7i69.0.0.input-20"
set pin(PROGRAM_STOP)			"$CARD.0.7i69.0.0.input-21"
set pin(PROGRAM_RUN)			"$CARD.0.7i69.0.0.input-22"
set pin(MACHINE_ON)			"$CARD.0.7i69.0.0.input-23"
set pin(MPG_AXIS_SELECT_Z)		"$CARD.0.7i69.0.0.input-24"
set pin(MPG_AXIS_SELECT_6)		"$CARD.0.7i69.0.0.input-25"
set pin(MPG_AXIS_SELECT_5)		"$CARD.0.7i69.0.0.input-26"
set pin(MPG_AXIS_SELECT_4)		"$CARD.0.7i69.0.0.input-27"
# BAD PIN OF 7i69
set pin(MPG_AXIS_SELECT_Y)		"$CARD.0.7i69.0.0.input-29"
set pin(MPG_AXIS_SELECT_X)		"$CARD.0.7i69.0.0.input-30"
set pin(MPG_SCALE_2)			"$CARD.0.7i69.0.0.input-31"
set pin(MPG_SCALE_1)			"$CARD.0.7i69.0.0.input-32"
set pin(MPG_SCALE_0)			"$CARD.0.7i69.0.0.input-33"
set pin(FLOOD_MIST_OFF)			"$CARD.0.7i69.0.0.input-34"
set pin(FLOOD)				"$CARD.0.7i69.0.0.input-35"
set pin(MIST)				"$CARD.0.7i69.0.0.input-36"
set pin(SPINDLE_STOP)			"$CARD.0.7i69.0.0.input-37"
set pin(SPINDLE_FORWARD)		"$CARD.0.7i69.0.0.input-38"
set pin(SPINDLE_REVERSE)		"$CARD.0.7i69.0.0.input-39"
set pin(ENCODER_SPINDLESPEED_A)		"$CARD.0.7i69.0.0.input-40"
set pin(ENCODER_SPINDLESPEED_B)		"$CARD.0.7i69.0.0.input-41"
set pin(HOME)				"$CARD.0.7i69.0.0.input-42"
set pin(G28)				"$CARD.0.7i69.0.0.input-43"
set pin(G54)				"$CARD.0.7i69.0.0.input-44"
#
#
set pin(ESTOP)				"$CARD.0.7i69.0.0.input-47"

#set encoder(X)				"$CARD.0.encoder.00"
set encoder(X)				"$CARD.0.encoder.08"
#set encoder(Y)				"$CARD.0.encoder.02"
set encoder(Y)				"$CARD.0.encoder.09"
set encoder(Z)				"$CARD.0.encoder.04"
#set encoder(Z)				"$CARD.0.encoder.10"
set encoder(A)				"$CARD.0.encoder.06"
#
set encoder(SPINDLE)			"$CARD.0.encoder.12"
### for testing on servo
#set encoder(SPINDLE)			"$CARD.0.encoder.00"
### for testing on servo
set encoder(MPG)			"$CARD.0.encoder.13"

set pwmgen(X)				"$CARD.0.pwmgen.00"
set pwmgen(Y)				"$CARD.0.pwmgen.01"
set pwmgen(Z)				"$CARD.0.pwmgen.02"
set pwmgen(A)				"$CARD.0.pwmgen.03"
set pwmgen(W)				"$CARD.0.pwmgen.04"
set pwmgen(SPINDLE)			"$CARD.0.pwmgen.06"
### for testing on servo
#set pwmgen(SPINDLE)			"$CARD.0.pwmgen.00"
### for testing on servo

array set axis {
	X				"axis.0"
	Y				"axis.1"
	Z				"axis.2"
	A				"axis.3"
	W				"axis.8"
}

array set pid {
	X				"pid_X"
	Y				"pid_Y"
	Z				"pid_Z"
	A				"pid_A"
	W				"pid_W"
	SPINDLE				"pid_spindle"
}	

array set ddt1 {
	X				"ddt1_X"
	Y				"ddt1_Y"
	Z				"ddt1_Z"
	A				"ddt1_A"
	W				"ddt1_W"
}	

array set ddt2 {
	X				"ddt2_X"
	Y				"ddt2_Y"
	Z				"ddt2_Z"
	A				"ddt2_A"
	W				"ddt2_W"
}

array set comp {
	X				"comp_X"
	Y				"comp_Y"
	Z				"comp_Z"
	A				"comp_A"
	W				"comp_W"
}

array set encoder_scale {
	X				$::AXIS_0(INPUT_SCALE)
	Y				$::AXIS_1(INPUT_SCALE)
	Z				$::AXIS_2(INPUT_SCALE)
	A				$::AXIS_3(INPUT_SCALE)
	W				$::AXIS_8(INPUT_SCALE)
}

array set debounce {
	run				"debounce.0.0"
	stop				"debounce.0.1"
	pause				"debounce.0.2"
	step				"debounce.0.3"
	home				"debounce.0.4"
	machine_onoff			"debounce.0.5"
}

array set stepgen {
	ss_mpg				"stepgen.0"
	lg_flash			"stepgen.1"
}

############ TCL procs #############

proc set_pid_gains {ax p i d ff1 db} {
	setp pid_$ax.Pgain		$p
	setp pid_$ax.Igain		$i
	setp pid_$ax.Dgain		$d
	setp pid_$ax.FF1		$ff1
	setp pid_$ax.deadband		$db
}

proc set_pid_gains_tuner {ax p i d ff1 db} {
	loadusr	-W ./arduino_pid_tuner.py $ax

	setp arduino_pid_tuner.${ax}_p_init	$p
	setp arduino_pid_tuner.${ax}_i_init	$i
	setp arduino_pid_tuner.${ax}_d_init	$d
	setp arduino_pid_tuner.${ax}_ff1_init	$ff1
	setp arduino_pid_tuner.${ax}_db_init	$db

	net pid_p_$ax				<= arduino_pid_tuner.${ax}_p		=> pid_$ax.Pgain
	net pid_d_$ax				<= arduino_pid_tuner.${ax}_d		=> pid_$ax.Dgain
	net pid_i_$ax				<= arduino_pid_tuner.${ax}_i		=> pid_$ax.Igain
	net pid_ff1_$ax				<= arduino_pid_tuner.${ax}_ff1		=> pid_$ax.FF1
	net pid_db_$ax				<= arduino_pid_tuner.${ax}_db		=> pid_$ax.deadband

	setp arduino_pid_tuner.enable 1
}

proc prepare_pid {ax} {
	switch $ax {
		X {
			set p_init $::AXIS_0(P)
			set i_init $::AXIS_0(I)
			set d_init $::AXIS_0(D)
			set ff1_init $::AXIS_0(FF1)
			set db_init $::AXIS_0(DEADBAND)
		}
		Y {
			set p_init $::AXIS_1(P)
			set i_init $::AXIS_1(I)
			set d_init $::AXIS_1(D)
			set ff1_init $::AXIS_1(FF1)
			set db_init $::AXIS_1(DEADBAND)
		}
		Z {
			set p_init $::AXIS_2(P)
			set i_init $::AXIS_2(I)
			set d_init $::AXIS_2(D)
			set ff1_init $::AXIS_2(FF1)
			set db_init $::AXIS_2(DEADBAND)
		}
		A {
			set p_init $::AXIS_3(P)
			set i_init $::AXIS_3(I)
			set d_init $::AXIS_3(D)
			set ff1_init $::AXIS_3(FF1)
			set db_init $::AXIS_3(DEADBAND)
		}
		W {
			set p_init $::AXIS_8(P)
			set i_init $::AXIS_8(I)
			set d_init $::AXIS_8(D)
			set ff1_init $::AXIS_8(FF1)
			set db_init $::AXIS_8(DEADBAND)
		}
	}

#	set_pid_gains_tuner $ax $p_init $i_init $d_init $ff1_init $db_init
	set_pid_gains $ax $p_init $i_init $d_init $ff1_init $db_init
}

proc coresim {ax} {
	global axis ddt1 ddt2

	net ${ax}pos				<= $axis($ax).motor-pos-cmd		=> $axis($ax).motor-pos-fb		=> $ddt1($ax).in
	net ${ax}vel				<= $ddt1($ax).out			=> $ddt2($ax).in
	net ${ax}acc				<= $ddt2($ax).out
}

proc axis_setup {ax} {
	global pwmgen encoder pid axis encoder_scale ddt1 ddt2

	setp $encoder($ax).scale		$encoder_scale($ax)
	setp $pwmgen($ax).output-type		1
	setp $pwmgen($ax).scale			100
	setp $pid($ax).maxoutput		98

	net ${ax}pos-fb				<= $encoder($ax).position		=> $pid($ax).feedback			=> $axis($ax).motor-pos-fb
	net ${ax}pos				<= $axis($ax).motor-pos-cmd		=> $pid($ax).command			=> $ddt1($ax).in
	net ${ax}vel-cmd			<= $pid($ax).output			=> $pwmgen($ax).value
	net ${ax}vel				<= $ddt1($ax).out			=> $ddt2($ax).in
	net ${ax}acc				<= $ddt2($ax).out

	# machine ON
	net ${ax}enable				<= $axis($ax).amp-enable-out		=> $pwmgen($ax).enable			=> $pid($ax).enable

	net ${ax}index-enable			<= $encoder($ax).index-enable		=> $axis($ax).index-enable
}

proc simulated_limits {ax} {
	global comp axis

	setp $comp($ax).hyst			0

	net $ax-neg-limit			<= $comp($ax).out			=> $axis($ax).neg-lim-sw-in		=> $axis($ax).home-sw-in
	net ${ax}pos									=> $comp($ax).in0
	net ${ax}homeswpos								=> $comp($ax).in1

	sets ${ax}homeswpos			-1
	# motor-pos-cmd is already connected on ${ax}pos-cmd signal
}

proc limits {ax} {
	global pin axis

#	net $ax-neg-limit			<= $pin(LIMIT_${ax}_NEG)		=> $axis($ax).neg-lim-sw-in
	net $ax-pos-limit			<= $pin(LIMIT_${ax}_POS)		=> $axis($ax).pos-lim-sw-in
}

proc limits_home {ax} {
	global axis

#	net $ax-neg-limit								=> $axis($ax).home-sw-in
	net $ax-pos-limit								=> $axis($ax).home-sw-in
}

proc prepare_axis {ax} {
	axis_setup $ax
	prepare_pid $ax
#	simulated_limits $ax
	limits $ax
	limits_home $ax
}

proc prepare_axis_sim {ax} {
	coresim $ax
	simulated_limits $ax
}



############ components ############

loadusr	-W hal_manualtoolchange

loadrt	trivkins
loadrt	hostmot2

loadrt	debounce		cfg=6
loadrt	pid			names=$pid(X),$pid(Y),$pid(Z),$pid(A),$pid(W),$pid(SPINDLE) debug=0
loadrt	comp			names=$comp(X),$comp(Y),$comp(Z),$comp(A),$comp(W)
loadrt	ddt			names=$ddt1(X),$ddt2(X),$ddt1(Y),$ddt2(Y),$ddt1(Z),$ddt2(Z),$ddt1(A),$ddt2(A),$ddt1(W),$ddt2(W)
loadrt	encoder			names=encoder_mv,encoder_js,encoder_so,encoder_fo,encoder_ss
loadrt	conv_s32_float		names=conv_s32_float_fo,conv_s32_float_so,conv_s32_float_ss
loadrt	conv_float_s32		names=conv_float_s32_fo,conv_float_s32_so
loadrt	oneshot			names=oneshot_prun,oneshot_pstop,oneshot_ppause,oneshot_fo_button
loadrt	and2			names=and2_run,and2_pause,and2_resume
loadrt	mux2			names=mux2_fo,mux2_ss_reverse
loadrt	sum2			names=sum2_fo,sum2_so
loadrt	mux8			names=mux8_mpg
loadrt	or2			names=or2_spindle_start
loadrt	ilowpass		names=ilowpass_mpg
loadrt	knob2float		names=knob2float_js,knob2float_ss
loadrt	stepgen			step_type=1,0 ctrl_type=p,v
loadrt	s32_to_updown		names=s32_to_updown_ss
loadrt	abs			names=abs_spindle_fb
loadrt	xor2			names=xor2_light_green
loadrt	mult2			names=mult2_ss_reverse
loadrt	limit2			names=limit2_spindle
loadrt	lowpass			names=lowpass_spindle_fb
loadrt	toggle2nist		names=toggle2nist_machine_onoff
loadrt	toggle			names=toggle_machine_onoff
loadrt	scale			names=scale_ss

loadrt	$::EMCMOT(EMCMOT)	servo_period_nsec=$::EMCMOT(SERVO_PERIOD) num_joints=$::TRAJ(AXES)

loadrt	hm2_pci			config="firmware=hm2/george/georgeconf2_96.bit"

############ hal functions ############

foreach n [array names ddt1] {
	addf $ddt1($n) servo-thread
	addf $ddt2($n) servo-thread
}

foreach n [array names comp] {
	addf $comp($n) servo-thread
}

foreach n [array names pid] {
	addf $pid($n).do-pid-calcs servo-thread
}


addf $CARD.0.read			servo-thread
addf $CARD.0.write			servo-thread
addf $CARD.0.pet_watchdog		servo-thread

addf motion-command-handler		servo-thread
addf motion-controller			servo-thread

addf encoder.update-counters		servo-thread
addf encoder.capture-position		servo-thread

addf conv_s32_float_fo			servo-thread
addf conv_float_s32_fo			servo-thread
addf conv_s32_float_so			servo-thread
addf conv_float_s32_so			servo-thread
addf conv_s32_float_ss			servo-thread

addf oneshot_prun			servo-thread
addf oneshot_pstop			servo-thread
addf oneshot_ppause			servo-thread
addf oneshot_fo_button			servo-thread

addf debounce.0				servo-thread

addf and2_pause				servo-thread
addf and2_resume			servo-thread
addf and2_run				servo-thread

addf mux2_fo				servo-thread
addf mux2_ss_reverse			servo-thread

addf sum2_fo				servo-thread
addf sum2_so				servo-thread

addf mux8_mpg				servo-thread

addf or2_spindle_start			servo-thread

addf ilowpass_mpg			servo-thread

addf knob2float_js			servo-thread
addf knob2float_ss			servo-thread

addf stepgen.make-pulses		servo-thread
addf stepgen.update-freq		servo-thread
addf stepgen.capture-position		servo-thread

addf s32_to_updown_ss			servo-thread

addf abs_spindle_fb			servo-thread

addf xor2_light_green			servo-thread

addf mult2_ss_reverse			servo-thread

addf limit2_spindle			servo-thread

addf lowpass_spindle_fb			servo-thread

addf toggle2nist_machine_onoff		servo-thread

addf toggle_machine_onoff		servo-thread

addf scale_ss				servo-thread


############ Card init ############

setp $CARD.0.pwmgen.pwm_frequency	20000
setp $CARD.0.watchdog.timeout_ns	10000000


###### 7i39ta enable mosfet outputs ######

foreach output {POWER CW FLOOD CCW MIST LIGHT_RED OIL LIGHT_GREEN} {
	setp $mosfet($output).is_output		true
}

foreach output {POWER CW FLOOD CCW MIST OIL} {
	setp $mosfet($output).invert_output	true
}


###### PREPARE AXES ######
prepare_axis "X"
prepare_axis "Y"
prepare_axis "Z"
prepare_axis_sim "A"
prepare_axis_sim "W"


###### machine on/off ######

net machine-on-switch			<= $pin(MACHINE_ON)			=> toggle_machine_onoff.in
net machine-on-toggle			<= toggle_machine_onoff.out		=> $debounce(machine_onoff).in
net machine-on-toggle-debounced		<= $debounce(machine_onoff).out		=> toggle2nist_machine_onoff.in
net machine-on				<= toggle2nist_machine_onoff.on		=> halui.machine.on
net machine-off				<= toggle2nist_machine_onoff.off	=> halui.machine.off
net machine-is-on			<= halui.machine.is-on			=> toggle2nist_machine_onoff.is-on	=> $mosfet(LIGHT_RED).out


###### manual toolchange ######

net tool-change				<= iocontrol.0.tool-change		=> hal_manualtoolchange.change
net tool-changed			<= hal_manualtoolchange.changed		=> iocontrol.0.tool-changed
net tool-prep-number			<= iocontrol.0.tool-prep-number		=> hal_manualtoolchange.number


###### estop #######

net estop				<= $pin(ESTOP)				=> iocontrol.0.emc-enable-in



###### feed override knob ######

setp encoder_fo.x4-mode			false
setp halui.feed-override.scale		0.05

net sum2_fo_100									=> sum2_fo.in1
net encoder_fo_a			<= $pin(ENCODER_FEEDOVERRIDE_A)		=> encoder_fo.phase-A
net encoder_fo_b 			<= $pin(ENCODER_FEEDOVERRIDE_B)		=> encoder_fo.phase-B

net fo_encoder_count			<= encoder_fo.counts			=> conv_s32_float_fo.in
net fo_encoder_count_float		<= conv_s32_float_fo.out		=> sum2_fo.in0
net summed_encoder_count_float		<= sum2_fo.out				=> conv_float_s32_fo.in
net summed_encoder_count		<= conv_float_s32_fo.out		=> halui.feed-override.counts
#net halui_fo_reset			<= $pin(BUTTON_FEEDOVERRIDE_RESET)	=> halui.feed-override.direct-value	=> encoder_fo.reset

sets sum2_fo_100			20


###### spindle override knob ######

setp encoder_so.x4-mode			false
setp halui.spindle-override.scale	0.05

net sum2_so_100									=> sum2_so.in1
net encoder_so_a			<= $pin(ENCODER_SPINDLEOVERRIDE_A)	=> encoder_so.phase-A
net encoder_so_b 			<= $pin(ENCODER_SPINDLEOVERRIDE_B)	=> encoder_so.phase-B

net so_encoder_count			<= encoder_so.counts			=> conv_s32_float_so.in
net so_encoder_count_float		<= conv_s32_float_so.out		=> sum2_so.in0
net summed_so_encoder_count_float	<= sum2_so.out				=> conv_float_s32_so.in
net summed_so_encoder_count		<= conv_float_s32_so.out		=> halui.spindle-override.counts
#net halui_so_reset			<= $pin(BUTTON_SPINDLEOVERRIDE_RESET)	=> halui.spindle-override.direct-value	=> encoder_so.reset

sets sum2_so_100			20


###### jog speed knob ######

setp encoder_js.x4-mode			false

setp knob2float_js.scale		100
setp knob2float_js.min-out		0
setp knob2float_js.max-out		6000
setp knob2float_js.enable		true

net encoder_js_a			<= $pin(ENCODER_JOGSPEED_A)		=> encoder_js.phase-A
net encoder_js_b			<= $pin(ENCODER_JOGSPEED_B)		=> encoder_js.phase-B

net js_counts				<= encoder_js.counts			=> knob2float_js.counts
net jog-speed				<= knob2float_js.out			=> halui.jog-speed


###### max velocity knob ######

setp encoder_mv.x4-mode			false
setp halui.max-velocity.scale		1

net encoder_mv_a			<= $pin(ENCODER_MAXVELOCITY_A)		=> encoder_mv.phase-A
net encoder_mv_b			<= $pin(ENCODER_MAXVELOCITY_B)		=> encoder_mv.phase-B

net halui_mv_counts			<= encoder_mv.counts			=> halui.max-velocity.counts


###### spindle speed knob ######

setp $stepgen(ss_mpg).steplen		50000000
setp $stepgen(ss_mpg).stepspace		50000000
setp $stepgen(ss_mpg).enable		true
setp encoder_ss.x4-mode			false

setp knob2float_ss.scale		1
setp knob2float_ss.min-out		-1000000000
setp knob2float_ss.max-out		1000000000
setp knob2float_ss.enable		true

net encoder_ss_a			<= $pin(ENCODER_SPINDLESPEED_A)		=> encoder_ss.phase-A
net encoder_ss_b			<= $pin(ENCODER_SPINDLESPEED_B)		=> encoder_ss.phase-B

net ss_counts				<= encoder_ss.counts			=> knob2float_ss.counts
net ss_counts_float			<= knob2float_ss.out			=> $stepgen(ss_mpg).position-cmd
net halui_ss_increment			<= $stepgen(ss_mpg).up			=> halui.spindle.increase
net halui_ss_decrement			<= $stepgen(ss_mpg).down		=> halui.spindle.decrease


###### program run/stop/pause ######

setp debounce.0.delay 			100

setp $stepgen(lg_flash).steplen		500000000
setp $stepgen(lg_flash).stepspace	100000000
setp $stepgen(lg_flash).velocity-cmd	1

setp oneshot_prun.rising		0
setp oneshot_prun.falling		1
setp oneshot_prun.width			0.1
setp oneshot_pstop.rising		0
setp oneshot_pstop.falling		1
setp oneshot_pstop.width		0.1
setp oneshot_ppause.rising		0
setp oneshot_ppause.falling		1
setp oneshot_ppause.width		0.1

net button_program_run			<= $pin(PROGRAM_RUN)		=> $debounce(run).in
net debounced_program_run		<= $debounce(run).out		=> and2_run.in0
net halui_program_idle			<= halui.program.is-idle	=> and2_run.in1			=> xor2_light_green.in0
net xored_program_idle			<= xor2_light_green.out		=> $mosfet(LIGHT_GREEN).out
net program_run_if_idle			<= and2_run.out			=> oneshot_prun.in		=> halui.mode.auto
net oneshoted_program_run		<= oneshot_prun.out		=> halui.program.run

net button_program_stop			<= $pin(PROGRAM_STOP)		=> $debounce(stop).in
net debounced_program_stop		<= $debounce(stop).out		=> oneshot_pstop.in
net debounced_program_stop						=> halui.abort

net button_program_pause		<= $pin(PROGRAM_PAUSE)		=> $debounce(pause).in
net debounced_program_pause		<= $debounce(pause).out		=> oneshot_ppause.in
net oneshoted_program_pause		<= oneshot_ppause.out		=> and2_pause.in0		=> and2_resume.in0
net program_is_running			<= halui.program.is-running	=> and2_pause.in1
net program_is_paused			<= halui.program.is-paused	=> and2_resume.in1		=> $stepgen(lg_flash).enable
net lg_flash				<= $stepgen(lg_flash).step	=> xor2_light_green.in1

net halui_program_pause			<= and2_pause.out		=> halui.program.pause
net halui_program_resume		<= and2_resume.out		=> halui.program.resume

net halui_program_step			<= $pin(PROGRAM_STEP)		=> $debounce(step).in
net debounced_program_step		<= $debounce(step).out		=> halui.program.step

# in postgui.hal
#net clear_errors			<= $pin(CLEAR_ERRORS)		=> axisui.notifications-clear-error

###### jog ######

net jog_x_minus				<= $pin(JOG_X_MINUS)		=> halui.jog.0.minus
net jog_x_plus				<= $pin(JOG_X_PLUS)		=> halui.jog.0.plus
net jog_y_minus				<= $pin(JOG_Y_MINUS)		=> halui.jog.1.minus
net jog_y_plus				<= $pin(JOG_Y_PLUS)		=> halui.jog.1.plus
net jog_z_minus				<= $pin(JOG_Z_MINUS)		=> halui.jog.2.minus
net jog_z_plus				<= $pin(JOG_Z_PLUS)		=> halui.jog.2.plus
net jog_a_minus				<= $pin(JOG_A_MINUS)		=> halui.jog.3.minus
net jog_a_plus				<= $pin(JOG_A_PLUS)		=> halui.jog.3.plus
net jog_w_minus				<= $pin(JOG_W_MINUS)		=> halui.jog.8.minus
net jog_w_plus				<= $pin(JOG_W_PLUS)		=> halui.jog.8.plus


###### mpg ######

foreach ax {X Y Z A W} {
	setp $axis($ax).jog-vel-mode		0
}

setp mux8_mpg.in0			0
setp mux8_mpg.in1			0.0000250
setp mux8_mpg.in2			0.000250
setp mux8_mpg.in3			0
setp mux8_mpg.in4			0.00250
setp mux8_mpg.in5			0
setp mux8_mpg.in6			0
setp mux8_mpg.in7			0

setp ilowpass_mpg.gain			0.05
setp ilowpass_mpg.scale			10

net mpg_scale0				<= $pin(MPG_SCALE_0)		=> mux8_mpg.sel0
net mpg_scale1				<= $pin(MPG_SCALE_1)		=> mux8_mpg.sel1
net mpg_scale2				<= $pin(MPG_SCALE_2)		=> mux8_mpg.sel2

net mpg_axis_select_x			<= $pin(MPG_AXIS_SELECT_X)	=> $axis(X).jog-enable 
net mpg_axis_select_y			<= $pin(MPG_AXIS_SELECT_Y)	=> $axis(Y).jog-enable 
net mpg_axis_select_z			<= $pin(MPG_AXIS_SELECT_Z)	=> $axis(Z).jog-enable 
net mpg_axis_select_a			<= $pin(MPG_AXIS_SELECT_4)	=> $axis(A).jog-enable 
net mpg_axis_select_w			<= $pin(MPG_AXIS_SELECT_5)	=> $axis(W).jog-enable 
# net mpg_axis_select_6			<= $pin(MPG_AXIS_SELECT_6)	=> axis.5.jog-enable 

net mpg_scale				<= mux8_mpg.out			=> $axis(X).jog-scale	=> $axis(Y).jog-scale	=> $axis(Z).jog-scale	=> $axis(A).jog-scale	=> $axis(W).jog-scale
net mpg_counts				<= $encoder(MPG).count		=> ilowpass_mpg.in
net ilowpassed_mpg_counts		<= ilowpass_mpg.out		=> $axis(X).jog-counts	=> $axis(Y).jog-counts	=> $axis(Z).jog-counts	=> $axis(A).jog-counts	=> $axis(W).jog-counts


###### home ######

net home_button				<= $pin(HOME)			=> $debounce(home).in
net debounced_home_button		<= $debounce(home).out		=> halui.home-all


###### spindle ######

setp $mosfet(CW).invert_output		true

setp $pwmgen(SPINDLE).scale		[expr $::SPINDLE(MAX_RPM) / 60]
setp $pid(SPINDLE).maxoutput		[expr $::SPINDLE(MAX_RPM) * 0.98]
setp $pid(SPINDLE).enable		1

setp $pwmgen(SPINDLE).output-type	2

setp limit2_spindle.maxv		1000
setp limit2_spindle.min			[expr $::SPINDLE(MAX_RPM) * -1]
setp limit2_spindle.max			$::SPINDLE(MAX_RPM)

setp $encoder(SPINDLE).scale		[expr (83 * 4)]

setp mux2_ss_reverse.in0		-1
setp mux2_ss_reverse.in1		1
setp $pid(SPINDLE).FF0			1
setp $pid(SPINDLE).Pgain		5
setp $pid(SPINDLE).Igain		2
setp $pid(SPINDLE).Dgain		0.01

setp lowpass_spindle_fb.gain		0.01

setp scale_ss.gain			60

net motion-spindle-index-enable		<= motion.spindle-index-enable	=> $encoder(SPINDLE).index-enable
net motion-spindle-revs			<= $encoder(SPINDLE).position	=> motion.spindle-revs

net spindle-vel-fb			<= $encoder(SPINDLE).velocity	=> $pid(SPINDLE).feedback	=> motion.spindle-speed-in	=> scale_ss.in
net spindle-vel-fb-min			<= scale_ss.out			=> lowpass_spindle_fb.in
net spindle-vel-fb-lowpass		<= lowpass_spindle_fb.out

net spindle-cw				<= $reverse_spindle_in		=> mux2_ss_reverse.sel
net ss_multiplier			<= mux2_ss_reverse.out		=> mult2_ss_reverse.in0

net spindle-cmd				<= motion.spindle-speed-out-rps	=> $pid(SPINDLE).command
net spindle-cmd-min			<= motion.spindle-speed-out
net spindle-pid-output			<= $pid(SPINDLE).output		=> mult2_ss_reverse.in1
net spindle-speed-with-reverse		<= mult2_ss_reverse.out		=> $pwmgen(SPINDLE).value

net spindle-enable			<= motion.spindle-on		=> $pwmgen(SPINDLE).enable	=> $mosfet(CW).out

net motion-spindle-forward		<= motion.spindle-forward
net motion-spindle-reverse		<= motion.spindle-reverse

# reverse spindle hall switch
net spindle-user-cw			<= $pin(SPINDLE_FORWARD)	=> halui.spindle.forward	=> or2_spindle_start.in0
net spindle-user-ccw			<= $pin(SPINDLE_REVERSE)	=> halui.spindle.reverse	=> or2_spindle_start.in1

net spindle-start			<= or2_spindle_start.out	=> halui.spindle.start
net spindle-stop			<= $pin(SPINDLE_STOP)		=> halui.spindle.stop


###### flood & mist ######

net coolant-flood			<= iocontrol.0.coolant-flood	=> $mosfet(FLOOD).out
net coolant-user-flood			<= $pin(FLOOD)			=> halui.flood.on

net coolant-mist			<= iocontrol.0.coolant-mist	=> $mosfet(MIST).out
net coolant-user-mist			<= $pin(MIST)			=> halui.mist.on

net flood-mist-off			<= $pin(FLOOD_MIST_OFF)		=> halui.mist.off		=> halui.flood.off


###### mdi commands ######

net mdi-g54				<= $pin(G54)			=> halui.mdi-command-00
net mdi-g28				<= $pin(G28)			=> halui.mdi-command-01






#loadusr halscope