# 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 Controller 1
# Motor Controller 1
# Motor Controller 1
############################
#:TP at HOME
#

# Beam Shade Vertical Translation (6mm/T double helix, 500mm)
Motor dszvt DMC2280 [params \
  host $dmc2280_controller1(host)\
  port $dmc2280_controller1(port)\
  axis A\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX [expr -25000/6]\
  absEnc 1\
  absEncHome 8172500\
  cntsPerX [expr -8192/6]]
dszvt hardlowerlim 0
dszvt hardupperlim 275
dszvt softlowerlim 0
dszvt softupperlim 275
dszvt home 0

# Collimator Table Horizontal Translation, X
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 0
c1ht hardupperlim 0
c1ht softlowerlim 0
c1ht softupperlim 0
c1ht home 0

# Collimator Tilt, Z axis, positive is down 
Motor m1ro DMC2280 [params \
  host $dmc2280_controller1(host)\
  port $dmc2280_controller1(port)\
  axis C\
  units degrees\
  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

# Beam Attenuator (16mm/turn, 200mm travel)
Motor bat DMC2280 [params \
  host $dmc2280_controller1(host)\
  port $dmc2280_controller1(port)\
  axis D\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX [expr 25000/16]\
  absEnc 1\
  absEncHome 7500000\
  cntsPerX [expr 8192/16]]
bat hardlowerlim 0
bat hardupperlim 200
bat softlowerlim 0
bat softupperlim 200
bat home 0

# Slit 3 Tower Translation (1mm/T, +/- 100mm)
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 8742250\
  cntsPerX -8192]
st3vt hardlowerlim 0
st3vt hardupperlim 251
st3vt softlowerlim 0
st3vt softupperlim 251
st3vt home 0

# Slit 4 Tower Translation (1mm/T, +/- 100mm)
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 8806900\
  cntsPerX -8192]
st4vt hardlowerlim 0
st4vt hardupperlim 248
st4vt softlowerlim 0
st4vt softupperlim 248
st4vt home 0

############################
# Motor Controller 2
# Motor Controller 2
# Motor Controller 2
############################
#:TP at HOME
#

# Sample Tilt 1, upper (1 degree/turn)
Motor sath DMC2280 [params \
  host $dmc2280_controller2(host)\
  port $dmc2280_controller2(port)\
  axis A\
  units degrees\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX 25000\
  absEnc 1\
  absEncHome 7500000\
  cntsPerX 8192]
setHomeandRange -motor sath -home 0 -lowrange 15 -uprange 15
sath speed 1
sath precision 0.01

# Sample Tilt 2, lower (1 degree/turn)
Motor saphi DMC2280 [params \
  host $dmc2280_controller2(host)\
  port $dmc2280_controller2(port)\
  axis B\
  units degrees\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX -25000\
  absEnc 1\
  absEncHome 7500000\
  cntsPerX -8192]
setHomeandRange -motor saphi -home 90 -lowrange 15 -uprange 15
saphi speed 1
saphi precision 0.01

# Sample Translation, Linear X (5mm/T, 0-750mm)
Motor sax DMC2280 [params \
  host $dmc2280_controller2(host)\
  port $dmc2280_controller2(port)\
  axis C\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX [expr 25000/5]\
  absEnc 1\
  absEncHome 7500000\
  cntsPerX [expr 8192/5]]
sax hardlowerlim 0
sax hardupperlim 750
sax softlowerlim 0
sax softupperlim 750
sax home 0

# Sample Translation, Linear Y
#Motor say 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]
#say hardlowerlim -600
#say hardupperlim -300
#say softlowerlim -600
#say softupperlim -300
#say home -450

# Sample Translation, Linear Z (??/T, 300mm)
Motor saz DMC2280 [params \
  host $dmc2280_controller2(host)\
  port $dmc2280_controller2(port)\
  axis E\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX [expr -25000*5]\
  absEnc 1\
  absEncHome 8927484\
  cntsPerX [expr -8192/5]]
saz hardlowerlim 0
saz hardupperlim 280
saz softlowerlim 0
saz softupperlim 280
saz home 0

# Detector Translation, Linear Y (Not Motorized)
#Motor deyht 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]
#deyht hardlowerlim -595
#deyht hardupperlim 800
#deyht softlowerlim -595
#deyht softupperlim 800
#deyht home 0

# Detector Translation, Linear Z (5mm/T gearing unknown)
Motor dezvt DMC2280 [params \
  host $dmc2280_controller2(host)\
  port $dmc2280_controller2(port)\
  axis G\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX -25000\
  absEnc 1\
  absEncHome 7500000\
  cntsPerX [expr -8192/5]]
dezvt hardlowerlim 0
dezvt hardupperlim 1348
dezvt softlowerlim 0
dezvt softupperlim 1348
dezvt home 0

#Measured or computed slit motor steps per millimetre
set slitStepRate 20180

############################
# Motor Controller 3
# Motor Controller 3
# Motor Controller 3
############################
#

# Slit 1, upper
Motor s1up DMC2280 [params \
  host $dmc2280_controller3(host)\
  port $dmc2280_controller3(port)\
  axis A\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s1up hardlowerlim -25
s1up hardupperlim 95
s1up softlowerlim -25
s1up softupperlim 95
s1up home 0

# Slit 1, lower
Motor s1lo DMC2280 [params \
  host $dmc2280_controller3(host)\
  port $dmc2280_controller3(port)\
  axis B\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s1lo hardlowerlim -25
s1lo hardupperlim 95
s1lo softlowerlim -25
s1lo softupperlim 95
s1lo home 0

# Slit 1, right
Motor s1ri DMC2280 [params \
  host $dmc2280_controller3(host)\
  port $dmc2280_controller3(port)\
  axis C\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s1ri hardlowerlim -25
s1ri hardupperlim 25
s1ri softlowerlim -25
s1ri softupperlim 25
s1ri home 0

# Slit 1, left
Motor s1le DMC2280 [params \
  host $dmc2280_controller3(host)\
  port $dmc2280_controller3(port)\
  axis D\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s1le hardlowerlim -25
s1le hardupperlim 25
s1le softlowerlim -25
s1le softupperlim 25
s1le home 0

# Slit 2, upper
Motor s2up DMC2280 [params \
  host $dmc2280_controller3(host)\
  port $dmc2280_controller3(port)\
  axis E\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s2up hardlowerlim -25
s2up hardupperlim 95
s2up softlowerlim -25
s2up softupperlim 95
s2up home 0

# Slit 2, lower
Motor s2lo DMC2280 [params \
  host $dmc2280_controller3(host)\
  port $dmc2280_controller3(port)\
  axis F\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s2lo hardlowerlim -25
s2lo hardupperlim 95
s2lo softlowerlim -25
s2lo softupperlim 95
s2lo home 0

# Slit 2, right
Motor s2ri DMC2280 [params \
  host $dmc2280_controller3(host)\
  port $dmc2280_controller3(port)\
  axis G\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s2ri hardlowerlim -25
s2ri hardupperlim 25
s2ri softlowerlim -25
s2ri softupperlim 25
s2ri home 0

# Slit 2, left
Motor s2le DMC2280 [params \
  host $dmc2280_controller3(host)\
  port $dmc2280_controller3(port)\
  axis H\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s2le hardlowerlim -25
s2le hardupperlim 25
s2le softlowerlim -25
s2le softupperlim 25
s2le home 0

# Slit 3, upper
Motor s3up DMC2280 [params \
  host $dmc2280_controller4(host)\
  port $dmc2280_controller4(port)\
  axis A\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s3up hardlowerlim -25
s3up hardupperlim 95
s3up softlowerlim -25
s3up softupperlim 95
s3up home 0

# Slit 3, lower
Motor s3lo DMC2280 [params \
  host $dmc2280_controller4(host)\
  port $dmc2280_controller4(port)\
  axis B\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s3lo hardlowerlim -25
s3lo hardupperlim 95
s3lo softlowerlim -25
s3lo softupperlim 95
s3lo home 0

# Slit 3, right
Motor s3ri DMC2280 [params \
  host $dmc2280_controller4(host)\
  port $dmc2280_controller4(port)\
  axis C\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s3ri hardlowerlim -25
s3ri hardupperlim 25
s3ri softlowerlim -25
s3ri softupperlim 25
s3ri home 0

# Slit 3, Left
Motor s3le DMC2280 [params \
  host $dmc2280_controller4(host)\
  port $dmc2280_controller4(port)\
  axis D\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s3le hardlowerlim -25
s3le hardupperlim 25
s3le softlowerlim -25
s3le softupperlim 25
s3le home 0

# Slit 4, upper
Motor s4up DMC2280 [params \
  host $dmc2280_controller4(host)\
  port $dmc2280_controller4(port)\
  axis E\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s4up hardlowerlim -25
s4up hardupperlim 95
s4up softlowerlim -25
s4up softupperlim 95
s4up home 0

# Slit 4, lower
Motor s4lo DMC2280 [params \
  host $dmc2280_controller4(host)\
  port $dmc2280_controller4(port)\
  axis F\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s4lo hardlowerlim -25
s4lo hardupperlim 95
s4lo softlowerlim -25
s4lo softupperlim 95
s4lo home 0

# Slit 4, right
Motor s4ri DMC2280 [params \
  host $dmc2280_controller4(host)\
  port $dmc2280_controller4(port)\
  axis G\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s4ri hardlowerlim -25
s4ri hardupperlim 25
s4ri softlowerlim -25
s4ri softupperlim 25
s4ri home 0

# Slit 4, left
Motor s4le DMC2280 [params \
  host $dmc2280_controller4(host)\
  port $dmc2280_controller4(port)\
  axis H\
  units mm\
  maxSpeed 1\
  maxAccel 1\
  maxDecel 1\
  stepsPerX $slitStepRate]
s4le hardlowerlim -25
s4le hardupperlim 25
s4le softlowerlim -25
s4le softupperlim 25
s4le home 0

## Polarization Analyzer Vertical Translation, Z
#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

## Polarization Analyzer Rotation 
#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

#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