def set_setpoint(self, value):
     """ Set the pressure regulator,
     setpoint is generally in psi, but really
     depends on the hw configuration """
     value = value * self.conf['PSICONV']
     log.debug("Set pressure regulator %d to %f", self.id_, value)
     self.synth.cbox.set_dac(self.id_, value) 

    def set_dac(self, devid, value):
        """ Set the DAC0 output"""
        tmpstr = "/DAC/run %d %x\n"
        if devid == 0:
            val = value / self.conf['DACCONST0']
        elif devid == 1:
            val = value / self.conf['DACCONST1']
        else:
            raise ElixysCBoxError("Unexpected DAC device id")

        val = int(math.ceil(val))
        dacmax = self.conf['DACMAX']
        if val > dacmax:
            log.warn("Attempt to set DAC %d to "
                    "%d, setting to MAX %d", devid, val, dacmax)
            val = dacmax

        dacmin = self.conf['DACMIN']
        if val < dacmin:
            log.warn("Attempt to set DAC %d to "
                    "%d, setting to MIN %d", devid, val, dacmin)
        
        tmpstr = tmpstr % (devid, val)
        log.debug("Set DAC: sent %s", tmpstr)
        self.write(tmpstr)
        self.read()

 def all(self):
     self.state_ = self.status.DigitalInputs['state']               
     self.all_state_ = [not bool(self.state_ >> sensorbit & 1) 
         for sensorbit in range(self.sysconf['DigitalInputs']['count'])]
     log.debug("Get Digital input %d tripped -> %s"
               % (self.id_, self.tripped_))
     return self.all_state_

 def lower_no_check(self):
     """ Move the actuator down but don't wait """
     log.debug("Actuator %s lower | Turn on valve:%d, Turn off valve:%d",
             repr(self), self._down_valve_id, self._up_valve_id)
     self.synth.valves[self._up_valve_id].on = False
     time.sleep(0.2)
     self.synth.valves[self._down_valve_id].on = True

 def set_on(self, value):
     log.debug("Set Mixer %d on -> %s" % (self.id_, value))
     self.on_ = value
     if value is True:
         self.set_duty_cycle(100.0)
     else:
         self.set_duty_cycle(0.0)

 def turn_counter_clockwise(self):
     """ Turn the stopcock counter clockwise """
     log.debug("Turn stopcock %d counter-clockwise", self.id_)
     self.synth.valves[self._cw_valve_id].on = False
     time.sleep(0.2)
     self.synth.valves[self._ccw_valve_id].on = True
     time.sleep(0.2)

 def set_on(self, value):
     """ Set the valve state """
     if not hasattr(self,'valve_state0') or not hasattr(self,'valve_state1') \
         or not hasattr(self,'valve_state2'):
         self.load_states()
     log.debug("Set Valve %d on -> %s" % (self.id_, value))
     self.on_ = value
     if self.id_ < 16:
         log.debug("Before Set Valve %d (state0) on -> %s" % (self.id_, bin(Valve.valve_state0)))
         if value is True:
             Valve.valve_state0 |= (1<<(self.id_%16))
         else:
             Valve.valve_state0 &= ~(1<<(self.id_%16))
         self.comproc.run_cmd(self.cmd_lookup['Valves']['set_state0'](Valve.valve_state0))
         log.debug("After Set Valve %d (state0) on -> %s" % (self.id_, bin(Valve.valve_state0)))
         self.on_ = True
     elif self.id_ < 32:
         if value is True:
             Valve.valve_state1 |= (1<< (self.id_%16))
         else:
             Valve.valve_state1 &= ~(1<<(self.id_%16))
         self.comproc.run_cmd(self.cmd_lookup['Valves']['set_state1'](Valve.valve_state1))
         log.debug("Set Valve %d (state1) on -> %s" % (self.id_, bin(Valve.valve_state1)))
         self.on_ = True
     elif self.id_ < 48:
         if value is True:
             Valve.valve_state2 |= (1<< (self.id_%16))
         else:
             Valve.valve_state2 &= ~(1<<(self.id_%16))
         self.comproc.run_cmd(self.cmd_lookup['Valves']['set_state2'](Valve.valve_state2))
         log.debug("Set Valve %d (state2) on -> %s" % (self.id_, bin(Valve.valve_state2)))
         self.on_ = True

 def get_analog_out(self):
     """ Return the analog Liquid Sensor value
     """
     self.analog_out_ = self.status.LiquidSensors[self.id_]['analog_in'] / 4095.0
     log.debug("Get Liquid Sensor Analog in %d on -> %s"
               % (self.id_, self.analog_out_))
     return self.analog_out_

 def close_no_check(self):
     """ Close the gripper and don't check the sensors """
     log.debug("Gripper Close | Turn off valve:%d, Turn on valve:%d",
             self._open_valve_id, self._close_valve_id)
     self.synth.valves[self._open_valve_id].on = False
     time.sleep(0.2)
     self.synth.valves[self._close_valve_id].on = True
     time.sleep(0.2)

 def get_on(self):
     log.debug("Get Temperature Controller %d on -> %s"
               % (self.id_, self.on_))
     errcode = self.status.TemperatureControllers[0]['error_code']
     if errcode == '\x01':
         self.on_ = True
     else:
         self.on_ = False
     return self.on_

 def get_setpoint(self):
     """ Get the pressure regulator
     setpoint, i.e. the pressure it is suppose to get to
     """
     value = self.synth.cbox.get_dacs()[self.id_]
     value = value / self.conf['PSICONV']
     log.debug("Current setpoint on regulator %d = %f",
             self.id_, value)
     return value

 def set_duty_cycle(self, value):
     log.debug("Set Mixer %d duty cycle -> %f" % (self.id_, value))        
     if value >= 0.0 and value <= 100.0:
         self.duty_ = value
         cmd = self.cmd_lookup['Mixers']['set_duty_cycle'][self.id_](value)
         self.comproc.run_cmd(cmd)
     else:
         # Raise Exception, value out of range!
         log.error("Mixer %d duty cycle -> %f out of range" % (self.id_, value))                

 def get_pressure(self):
     """ Return the actual pressure in PSI,
     or something else depending on hwconf.ini
     """
     value = self.synth.cbox.get_adcs()[self.id_]
     value = value / self.conf['PSICONV']
     log.debug("Current pressure on regulator %d = %f",
             self.id_, value)
     return value

    def move_coord(self, x, y):
        """ Move to x, y coordinates """

        log.debug("Move Reagent Robot to %d, %d", x, y)
        self.prepare_move()
        self.xactuator.move(x)
        self.yactuator.move(y)
        self.yactuator.wait()
        self.xactuator.wait()

    def set_analog_out(self, value):
        if not(value >= 0.0 and value <= 10.0):
            # Should raise exception in future!!!!
            log.error("SMC Analog setpoint (%f) out of range" % value)
            return
        self.comproc.run_cmd(self.cmd_lookup['SMCInterfaces']['set_analog_out'][self.id_](value))
        log.debug("Set SMC Analog out %d on -> %s"
                  % (self.id_, value))

        self.analog_out_ = value

 def set_setpoint(self, value):
     if value > 180.0:
         #Raise exception
         log.debug("Error Temperature Controller %d setpoint -> %f,"
                   "TOO HOT, should be less than 180"
                   % (self.id_, self.setpoint_))
         return
     self.setpoint_ = value
     log.debug("Set Temperature Controller %d setpoint -> %f"
               % (self.id_, self.setpoint_))
     cmd = self.cmd_lookup['TemperatureControllers']['set_setpoint'][self.id_](value)
     self.comproc.run_cmd(cmd)

 def lower(self):
     """ Lower actuator and unsure it gets there """
     for i in xrange(self.conf['retry_count']):
         begintime = datetime.now()
         self.lower_no_check()
         while self.timeout > datetime.now() - begintime:
             time.sleep(0.1)
             if self.is_down:
                 log.debug("Lower actuator %s success", repr(self))
                 return
         log.info("Failed to raise actuator %s before timeout, retry %d",
                     repr(self), i)
     log.error("Failed to lower actuator %s after retrys", repr(self))

 def close(self):
     """ Close the gripper and make sure it closes """
     for i in xrange(self.conf['retry_count']):
         begintime = datetime.now()
         self.close_no_check()
         while self.timeout > datetime.now() - begintime:
             time.sleep(0.1)
             if self.is_closed:
                 log.debug("Close actuator %s success", repr(self))
                 return
         log.info("Failed to close actuator %s before timeout, retry %d",
                     repr(self), i)
     log.error("Failed to close actuator %s after retrys", repr(self))

    def lift(self):
        """ Move the actuator up and ensure it gets there """
        for i in xrange(self.conf['retry_count']):
            begintime = datetime.now()
            self.lift_no_check()
            while self.timeout > datetime.now() - begintime:
                time.sleep(0.1)
                if self.is_up:
                    log.debug("Lift actuator %s success", repr(self))
                    return

            log.info("Failed to raise actautor %s before timeout, retry %d",
                        repr(self), i)
        log.error("Failed to raise actuator %s after retrys", repr(self))

    def open(self):
        """ Open the gripper and make sure it opens """
        for i in xrange(self.conf['retry_count']):
            begintime = datetime.now()
            self.open_no_check()
            while self.timeout > datetime.now() - begintime:
                time.sleep(0.1)
                if self.is_open:
                    log.debug("Open actuator %s success", repr(self))
                    return

            log.info("Failed to open actautor %s before timeout, retry %d",
                        repr(self), i)
        log.error("Failed to open actuator %s after retrys", repr(self))