# Setup addresses of Galil DMC2280 controllers.
set dmc2280_controller1(host) mc1-platypus
set dmc2280_controller1(port) pmc1-platypus

set dmc2280_controller2(host) mc2-platypus
set dmc2280_controller2(port) pmc2-platypus

set dmc2280_controller3(host) mc3-platypus
set dmc2280_controller3(port) pmc3-platypus

set dmc2280_controller4(host) mc4-platypus
set dmc2280_controller4(port) pmc4-platypus

# MOTORS
Motor s1up DMC2280 [params \
	host $dmc2280_controller3(host)\
	port $dmc2280_controller3(port)\
	axis A\
 units mm\
 maxSpeed 1\
 maxAccel 1\
 maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s1up hardlowerlim -15
s1up hardupperlim 15
s1up softlowerlim -15
s1up softupperlim 15
s1up home 0

Motor s1lo DMC2280 [params \
	host $dmc2280_controller3(host)\
	port $dmc2280_controller3(port)\
	axis B\
 units mm\
 maxSpeed 1\
 maxAccel 1\
 maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s1lo hardlowerlim -15
s1lo hardupperlim 15
s1lo softlowerlim -15
s1lo softupperlim 15
s1lo home 0

Motor s1ri DMC2280 [params \
	host $dmc2280_controller3(host)\
	port $dmc2280_controller3(port)\
	axis C\
 units mm\
 maxSpeed 1\
 maxAccel 1\
 maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s1ri hardlowerlim -13
s1ri hardupperlim 27
s1ri softlowerlim -13
s1ri softupperlim 27
s1ri home 0

Motor s1le DMC2280 [params \
	host $dmc2280_controller3(host)\
	port $dmc2280_controller3(port)\
	axis D\
 units mm\
 maxSpeed 1\
 maxAccel 1\
 maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s1le hardlowerlim -27
s1le hardupperlim 13
s1le softlowerlim -27
s1le softupperlim 13
s1le home 0

Motor s2up DMC2280 [params \
	host $dmc2280_controller3(host)\
	port $dmc2280_controller3(port)\
	axis E\
 units mm\
 maxSpeed 1\
 maxAccel 1\
 maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s2up hardlowerlim -15
s2up hardupperlim 15
s2up softlowerlim -15
s2up softupperlim 15
s2up home 0

Motor s2lo DMC2280 [params \
	host $dmc2280_controller3(host)\
	port $dmc2280_controller3(port)\
	axis F\
 units mm\
 maxSpeed 1\
 maxAccel 1\
 maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s2lo hardlowerlim -15
s2lo hardupperlim 15
s2lo softlowerlim -15
s2lo softupperlim 15
s2lo home 0

Motor s2ri DMC2280 [params \
	host $dmc2280_controller3(host)\
	port $dmc2280_controller3(port)\
	axis G\
 units mm\
 maxSpeed 1\
 maxAccel 1\
 maxDecel 1\
	stepsPerX 25000]
s2ri hardlowerlim -13
s2ri hardupperlim 27
s2ri softlowerlim -13
s2ri softupperlim 27
s2ri home 0

Motor s2le DMC2280 [params \
	host $dmc2280_controller3(host)\
	port $dmc2280_controller3(port)\
	axis H\
 units mm\
 maxSpeed 1\
 maxAccel 1\
 maxDecel 1\
	stepsPerX 25000]
s2le hardlowerlim -27
s2le hardupperlim 13
s2le softlowerlim -27
s2le softupperlim 13
s2le home 0

Motor st3vt DMC2280 [params \
	host $dmc2280_controller1(host)\
	port $dmc2280_controller1(port)\
	axis E\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
st3vt hardlowerlim -179
st3vt hardupperlim 21
st3vt softlowerlim -179
st3vt softupperlim 21
st3vt home 0

Motor s3up DMC2280 [params \
	host $dmc2280_controller4(host)\
	port $dmc2280_controller4(port)\
	axis A\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s3up hardlowerlim -15
s3up hardupperlim 15
s3up softlowerlim -15
s3up softupperlim 15
s3up home 0

Motor s3lo DMC2280 [params \
	host $dmc2280_controller4(host)\
	port $dmc2280_controller4(port)\
	axis B\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s3lo hardlowerlim -15
s3lo hardupperlim 15
s3lo softlowerlim -15
s3lo softupperlim 15
s3lo home 0

Motor s3ri DMC2280 [params \
	host $dmc2280_controller4(host)\
	port $dmc2280_controller4(port)\
	axis C\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s3ri hardlowerlim -13
s3ri hardupperlim 27
s3ri softlowerlim -13
s3ri softupperlim 27
s3ri home 0

Motor s3le DMC2280 [params \
	host $dmc2280_controller4(host)\
	port $dmc2280_controller4(port)\
	axis D\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s3le hardlowerlim -27
s3le hardupperlim 13
s3le softlowerlim -27
s3le softupperlim 13
s3le home 0

Motor st4vt DMC2280 [params \
	host $dmc2280_controller1(host)\
	port $dmc2280_controller1(port)\
	axis F\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
st4vt hardlowerlim -179
st4vt hardupperlim 21
st4vt softlowerlim -179
st4vt softupperlim 21
st4vt home 0

Motor s4up DMC2280 [params \
	host $dmc2280_controller4(host)\
	port $dmc2280_controller4(port)\
	axis E\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s4up hardlowerlim -15
s4up hardupperlim 15
s4up softlowerlim -15
s4up softupperlim 15
s4up home 0

Motor s4lo DMC2280 [params \
	host $dmc2280_controller4(host)\
	port $dmc2280_controller4(port)\
	axis F\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s4lo hardlowerlim -15
s4lo hardupperlim 15
s4lo softlowerlim -15
s4lo softupperlim 15
s4lo home 0

Motor s4ri DMC2280 [params \
	host $dmc2280_controller4(host)\
	port $dmc2280_controller4(port)\
	axis G\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s4ri hardlowerlim -13
s4ri hardupperlim 27
s4ri softlowerlim -13
s4ri softupperlim 27
s4ri home 0

Motor s4le DMC2280 [params \
	host $dmc2280_controller4(host)\
	port $dmc2280_controller4(port)\
	axis H\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
s4le hardlowerlim -27
s4le hardupperlim 13
s4le softlowerlim -27
s4le softupperlim 13
s4le home 0

#Motor c1ht DMC2280 [params \
#	host $dmc2280_controller1(host)\
#	port $dmc2280_controller1(port)\
#	axis B\
#  units mm\
#  maxSpeed 1\
#  maxAccel 1\
#  maxDecel 1\
#	stepsPerX 25000\
#	absEnc 1\
#	absEncHome 7500000\
#	cntsPerX 8192]
#c1ht hardlowerlim xxxx
#c1ht hardupperlim xxxx
#c1ht softlowerlim xxxx
#c1ht softupperlim xxxx
#c1ht home 0

Motor m1ro DMC2280 [params \
	host $dmc2280_controller1(host)\
	port $dmc2280_controller1(port)\
	axis C\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
m1ro hardlowerlim -5
m1ro hardupperlim 5
m1ro softlowerlim -5
m1ro softupperlim 5
m1ro home 0

Motor saz DMC2280 [params \
	host $dmc2280_controller2(host)\
	port $dmc2280_controller2(port)\
	axis D\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
saz hardlowerlim -600
saz hardupperlim -300
saz softlowerlim -600
saz softupperlim -300
saz home -450

#Motor sax DMC2280 [params \
#	host $dmc2280_controller2(host)\
#	port $dmc2280_controller2(port)\
#	axis C\
#  units mm\
#  maxSpeed 1\
#  maxAccel 1\
#  maxDecel 1\
#	stepsPerX 25000\
#	absEnc 1\
#	absEncHome 7500000\
#	cntsPerX 8192]
#sax hardlowerlim xxxx
#sax hardupperlim 750
#sax softlowerlim xxxx
#sax softupperlim 750
#sax home 0

Motor sath DMC2280 [params \
	host $dmc2280_controller2(host)\
	port $dmc2280_controller2(port)\
	axis A\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
sath hardlowerlim -10
sath hardupperlim 10
sath softlowerlim -10
sath softupperlim 10
sath home 0

Motor saphi DMC2280 [params \
	host $dmc2280_controller2(host)\
	port $dmc2280_controller2(port)\
	axis B\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
saphi hardlowerlim -20
saphi hardupperlim 20
saphi softlowerlim -20
saphi softupperlim 20
saphi home 0

#Motor anzvt DMC2280 [params \
#	host $dmc2280_controller2(host)\
#	port $dmc2280_controller2(port)\
#	axis xxxx\
#  units mm\
#  maxSpeed 1\
#  maxAccel 1\
#  maxDecel 1\
#	stepsPerX 25000\
#	absEnc 1\
#	absEncHome 7500000\
#	cntsPerX 8192]
#anzvt hardlowerlim xxxx
#anzvt hardupperlim xxxx
#anzvt softlowerlim xxxx
#anzvt softupperlim xxxx
#anzvt home 0

#Motor anro DMC2280 [params \
#	host $dmc2280_controller2(host)\
#	port $dmc2280_controller2(port)\
#	axis xxxx\
#  units mm\
#  maxSpeed 1\
#  maxAccel 1\
#  maxDecel 1\
#	stepsPerX 25000\
#	absEnc 1\
#	absEncHome 7500000\
#	cntsPerX 8192]
#anro hardlowerlim -10
#anro hardupperlim 10
#anro softlowerlim -10
#anro softupperlim 10
#anro home 0

#Motor dszvt DMC2280 [params \
#	host $dmc2280_controller1(host)\
#	port $dmc2280_controller1(port)\
#	axis A\
#  units mm\
#  maxSpeed 1\
#  maxAccel 1\
#  maxDecel 1\
#	stepsPerX 25000\
#	absEnc 1\
#	absEncHome 7500000\
#	cntsPerX 8192]
#dszvt hardlowerlim xxxx
#dszvt hardupperlim xxxx
#dszvt softlowerlim xxxx
#dszvt softupperlim xxxx
#dszvt home 0

Motor dezvt DMC2280 [params \
	host $dmc2280_controller2(host)\
	port $dmc2280_controller2(port)\
	axis F\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
	stepsPerX 25000\
	absEnc 1\
	absEncHome 7500000\
	cntsPerX 8192]
dezvt hardlowerlim -595
dezvt hardupperlim 800
dezvt softlowerlim -595
dezvt softupperlim 800
dezvt home 0

#Motor dezht DMC2280 [params \
#	host $dmc2280_controllerxxxx(host)\
#	port $dmc2280_controllerxxxx(port)\
#	axis xxxx\
#  units mm\
#  maxSpeed 1\
#  maxAccel 1\
#  maxDecel 1\
#	stepsPerX 25000\
#	absEnc 1\
#	absEncHome 7500000\
#	cntsPerX 8192]
#dezht hardlowerlim -595
#dezht hardupperlim 800
#dezht softlowerlim -595
#dezht softupperlim 800
#dezht home 0

#proc SplitReply { text } {
#     set l [split $text =]
#     return [lindex $l 1]
#}

#--------------------------------------------------------
proc s1widthscript {val} {
	set currentWidth [expr [SplitReply [s1ri]] + [SplitReply [s1le]]]
	set diff [expr $val - $currentWidth]
	set newD1R [expr [SplitReply [s1ri]] + $diff/2]
	set newD1L [expr [SplitReply [s1le]] + $diff/2]
	return "s1ri=$newD1R,s1le=$newD1L"
}
publish s1widthscript user

#-------------------------------------------------------
proc s1readwidth {} {
	return [expr [SplitReply [s1ri]] + [SplitReply [s1le]]] 
}
publish s1readwidth user
MakeConfigurableMotor s1hg
s1hg drivescript s1widthscript
s1hg readscript s1readwidth

#--------------------------------------------------------
proc s1heightscript {val} {
	set currentWidth [expr [SplitReply [s1up]] + [SplitReply [s1lo]]]
	set diff [expr $val - $currentWidth]
	set newD1B [expr [SplitReply [s1lo]] + $diff/2]
	set newD1T [expr [SplitReply [s1up]] + $diff/2]
	return "s1lo=$newD1B,s1up=$newD1T"
}
publish s1heightscript user

#-------------------------------------------------------
proc s1readheight {} {
	return [expr [SplitReply [s1up]] + [SplitReply [s1lo]]] 
}
publish s1readheight user

#---------------------------------------------------------
MakeConfigurableMotor s1vg
s1vg drivescript s1heightscript
s1vg readscript s1readheight

#--------------------------------------------------------
proc s1horoffsetscript {val} {
  set sr [splitreply [s1ri]]
  set sl [splitreply [s1le]]
	set currentoffset [ expr $sr - ($sr + $sl)/2.0 ] 
	set diff [expr $val - $currentoffset]
	set newd1r [expr $sr + $diff]
	set newd1l [expr $sl - $diff]
	return "s1ri=$newd1r,s1le=$newd1l"
}
publish s1horoffsetscript user

#-------------------------------------------------------
proc s1readhoroffset {} {
  set sr [splitreply [s1ri]]
	return [ expr $sr - ($sr + [splitreply [s1le]])/2.0 ] 
}
publish s1readhoroffset user

#-------------------------------------------------------
MakeConfigurableMotor s1ho
s1ho drivescript s1horoffsetscript
s1ho readscript s1readhoroffset

#--------------------------------------------------------
proc s1vertoffsetscript {val} {
  set SU [SplitReply [s1up]]
  set SD [SplitReply [s1lo]]
	set currentOffset [ expr $SU - ($SU + $SD)/2.0 ] 
	set diff [expr $val - $currentOffset]
	set newD1U [expr $SU + $diff]
	set newD1D [expr $SD - $diff]
	return "s1up=$newD1U,s1lo=$newD1D"
}
publish s1vertoffsetscript user

#-------------------------------------------------------
proc s1readvertoffset {} {
  set SU [SplitReply [s1up]]
	return [ expr $SU - ($SU + [SplitReply [s1lo]])/2.0 ] 
}
publish s1readvertoffset user

#-------------------------------------------------------
MakeConfigurableMotor s1vo
s1vo drivescript s1vertoffsetscript
s1vo readscript s1readvertoffset

###############################################

#--------------------------------------------------------
proc s2widthscript {val} {
	set currentWidth [expr [SplitReply [s2ri]] + [SplitReply [s2le]]]
	set diff [expr $val - $currentWidth]
	set newD1R [expr [SplitReply [s2ri]] + $diff/2]
	set newD1L [expr [SplitReply [s2le]] + $diff/2]
	return "s2ri=$newD1R,s2le=$newD1L"
}
publish s2widthscript user

#-------------------------------------------------------
proc s2readwidth {} {
	return [expr [SplitReply [s2ri]] + [SplitReply [s2le]]] 
}
publish s2readwidth user
MakeConfigurableMotor s2hg
s2hg drivescript s2widthscript
s2hg readscript s2readwidth

#-----------------------------------------------------
proc s2heightscript {val} {
	set currentWidth [expr [SplitReply [s2up]] + [SplitReply [s2lo]]]
	set diff [expr $val - $currentWidth]
	set newD1B [expr [SplitReply [s2lo]] + $diff/2]
	set newD1T [expr [SplitReply [s2up]] + $diff/2]
	return "s2lo=$newD1B,s2up=$newD1T"
}
publish s2heightscript user

#-------------------------------------------------------
proc s2readheight {} {
	return [expr [SplitReply [s2up]] + [SplitReply [s2lo]]] 
}
publish s2readheight user

#---------------------------------------------------------
MakeConfigurableMotor s2vg
s2vg drivescript s2heightscript
s2vg readscript s2readheight

#--------------------------------------------------------
proc s2horoffsetscript {val} {
  set sr [splitreply [s2ri]]
  set sl [splitreply [s2le]]
	set currentoffset [ expr $sr - ($sr + $sl)/2.0 ] 
	set diff [expr $val - $currentoffset]
	set newd1r [expr $sr + $diff]
	set newd1l [expr $sl - $diff]
	return "s2ri=$newd1r,s2le=$newd1l"
}
publish s2horoffsetscript user

#-------------------------------------------------------
proc s2readhoroffset {} {
  set sr [splitreply [s2ri]]
	return [ expr $sr - ($sr + [splitreply [s2le]])/2.0 ] 
}
publish s2readhoroffset user

#-------------------------------------------------------
MakeConfigurableMotor s2ho
s2ho drivescript s2horoffsetscript
s2ho readscript s2readhoroffset

#--------------------------------------------------------
proc s2vertoffsetscript {val} {
  set SU [SplitReply [s2up]]
  set SD [SplitReply [s2lo]]
	set currentOffset [ expr $SU - ($SU + $SD)/2.0 ] 
	set diff [expr $val - $currentOffset]
	set newD1U [expr $SU + $diff]
	set newD1D [expr $SD - $diff]
	return "s2up=$newD1U,s2lo=$newD1D"
}
publish s2vertoffsetscript user

#-------------------------------------------------------
proc s2readvertoffset {} {
  set SU [SplitReply [s2up]]
	return [ expr $SU - ($SU + [SplitReply [s2lo]])/2.0 ] 
}
publish s2readvertoffset user

#-------------------------------------------------------
MakeConfigurableMotor s2vo
s2vo drivescript s2vertoffsetscript
s2vo readscript s2readvertoffset

###############################################

#--------------------------------------------------------
proc s3widthscript {val} {
	set currentWidth [expr [SplitReply [s3ri]] + [SplitReply [s3le]]]
	set diff [expr $val - $currentWidth]
	set newD1R [expr [SplitReply [s3ri]] + $diff/2]
	set newD1L [expr [SplitReply [s3le]] + $diff/2]
	return "s3ri=$newD1R,s3le=$newD1L"
}
publish s3widthscript user

#-------------------------------------------------------
proc s3readwidth {} {
	return [expr [SplitReply [s3ri]] + [SplitReply [s3le]]] 
}
publish s3readwidth user
MakeConfigurableMotor s3hg
s3hg drivescript s3widthscript
s3hg readscript s3readwidth

#-----------------------------------------------------
proc s3heightscript {val} {
	set currentWidth [expr [SplitReply [s3up]] + [SplitReply [s3lo]]]
	set diff [expr $val - $currentWidth]
	set newD1B [expr [SplitReply [s3lo]] + $diff/2]
	set newD1T [expr [SplitReply [s3up]] + $diff/2]
	return "s3lo=$newD1B,s3up=$newD1T"
}
publish s3heightscript user

#-------------------------------------------------------
proc s3readheight {} {
	return [expr [SplitReply [s3up]] + [SplitReply [s3lo]]] 
}
publish s3readheight user

#---------------------------------------------------------
MakeConfigurableMotor s3vg
s3vg drivescript s3heightscript
s3vg readscript s3readheight

#--------------------------------------------------------
proc s3horoffsetscript {val} {
  set sr [splitreply [s3ri]]
  set sl [splitreply [s3le]]
	set currentoffset [ expr $sr - ($sr + $sl)/2.0 ] 
	set diff [expr $val - $currentoffset]
	set newd1r [expr $sr + $diff]
	set newd1l [expr $sl - $diff]
	return "s3ri=$newd1r,s3le=$newd1l"
}
publish s3horoffsetscript user

#-------------------------------------------------------
proc s3readhoroffset {} {
  set sr [splitreply [s3ri]]
	return [ expr $sr - ($sr + [splitreply [s3le]])/2.0 ] 
}
publish s3readhoroffset user

#-------------------------------------------------------
MakeConfigurableMotor s3ho
s3ho drivescript s3horoffsetscript
s3ho readscript s3readhoroffset

#--------------------------------------------------------
proc s3vertoffsetscript {val} {
  set SU [SplitReply [s3up]]
  set SD [SplitReply [s3lo]]
	set currentOffset [ expr $SU - ($SU + $SD)/2.0 ] 
	set diff [expr $val - $currentOffset]
	set newD1U [expr $SU + $diff]
	set newD1D [expr $SD - $diff]
	return "s3up=$newD1U,s3lo=$newD1D"
}
publish s3vertoffsetscript user

#-------------------------------------------------------
proc s3readvertoffset {} {
  set SU [SplitReply [s3up]]
	return [ expr $SU - ($SU + [SplitReply [s3lo]])/2.0 ] 
}
publish s3readvertoffset user

#-------------------------------------------------------
MakeConfigurableMotor s3vo
s3vo drivescript s3vertoffsetscript
s3vo readscript s3readvertoffset

###############################################

#--------------------------------------------------------
proc s4widthscript {val} {
	set currentWidth [expr [SplitReply [s4ri]] + [SplitReply [s4le]]]
	set diff [expr $val - $currentWidth]
	set newD1R [expr [SplitReply [s4ri]] + $diff/2]
	set newD1L [expr [SplitReply [s4le]] + $diff/2]
	return "s4ri=$newD1R,s4le=$newD1L"
}
publish s4widthscript user

#-------------------------------------------------------
proc s4readwidth {} {
	return [expr [SplitReply [s4ri]] + [SplitReply [s4le]]] 
}
publish s4readwidth user
MakeConfigurableMotor s4hg
s4hg drivescript s4widthscript
s4hg readscript s4readwidth

#-----------------------------------------------------
proc s4heightscript {val} {
	set currentWidth [expr [SplitReply [s4up]] + [SplitReply [s4lo]]]
	set diff [expr $val - $currentWidth]
	set newD1B [expr [SplitReply [s4lo]] + $diff/2]
	set newD1T [expr [SplitReply [s4up]] + $diff/2]
	return "s4lo=$newD1B,s4up=$newD1T"
}
publish s4heightscript user

#-------------------------------------------------------
proc s4readheight {} {
	return [expr [SplitReply [s4up]] + [SplitReply [s4lo]]] 
}
publish s4readheight user

#---------------------------------------------------------
MakeConfigurableMotor s4vg
s4vg drivescript s4heightscript
s4vg readscript s4readheight

#--------------------------------------------------------
proc s4horoffsetscript {val} {
  set sr [splitreply [s4ri]]
  set sl [splitreply [s4le]]
	set currentoffset [ expr $sr - ($sr + $sl)/2.0 ] 
	set diff [expr $val - $currentoffset]
	set newd1r [expr $sr + $diff]
	set newd1l [expr $sl - $diff]
	return "s4ri=$newd1r,s4le=$newd1l"
}
publish s4horoffsetscript user

#-------------------------------------------------------
proc s4readhoroffset {} {
  set sr [splitreply [s4ri]]
	return [ expr $sr - ($sr + [splitreply [s4le]])/2.0 ] 
}
publish s4readhoroffset user

#-------------------------------------------------------
MakeConfigurableMotor s4ho
s4ho drivescript s4horoffsetscript
s4ho readscript s4readhoroffset

#--------------------------------------------------------
proc s4vertoffsetscript {val} {
  set SU [SplitReply [s4up]]
  set SD [SplitReply [s4lo]]
	set currentOffset [ expr $SU - ($SU + $SD)/2.0 ] 
	set diff [expr $val - $currentOffset]
	set newD1U [expr $SU + $diff]
	set newD1D [expr $SD - $diff]
	return "s4up=$newD1U,s4lo=$newD1D"
}
publish s4vertoffsetscript user

#-------------------------------------------------------
proc s4readvertoffset {} {
  set SU [SplitReply [s4up]]
	return [ expr $SU - ($SU + [SplitReply [s4lo]])/2.0 ] 
}
publish s4readvertoffset user

#-------------------------------------------------------
MakeConfigurableMotor s4vo
s4vo drivescript s4vertoffsetscript
s4vo readscript s4readvertoffset