import ch.psi.pshell.epics as epics

class Keithley(object):
    def __init__(self, base_name, base_channel):
        self.base_channel = base_channel
        self.base_name = base_name
        self.scanCh = None
        self.ttypeCh = None
        self.nplcCh = None
        self.navgCh = None
        self.tottimeCh = None
        self.doinitCh = None
        self.dotriggerCh = None
        self.dofetchCh = None
        self.readoutCh = None
        
    def initialize(self):
        self.scanCh = epics.ChannelInteger(self.base_name + "Scan", self.base_channel + "READSCAN.SCAN")
        self.ttypeCh = epics.ChannelInteger(self.base_name + "TType", self.base_channel + "TTYPE")
        self.nplcCh = epics.ChannelDouble(self.base_name + "Nplc", self.base_channel + "NPLC")
        self.navgCh = epics.ChannelInteger(self.base_name + "Navg", self.base_channel + "NAVG")
        self.tottimeCh = epics.ChannelDouble(self.base_name + "TotTime", self.base_channel + "TOTTIME")
        self.doinitCh = epics.ChannelInteger(self.base_name + "DoInit", self.base_channel + "DOINIT")
        self.dotriggerCh = epics.ChannelInteger(self.base_name + "DoTrigger", self.base_channel + "DOTRIGGER")
        self.dofetchCh = epics.ChannelInteger(self.base_name + "DoFetch", self.base_channel + "DOFETCH")
        self.readoutCh = epics.ChannelDouble(self.base_name + "Readout", self.base_channel + "READOUT")

        self.scanCh.initialize()
        self.ttypeCh.initialize()
        self.nplcCh.initialize()
        self.navgCh.initialize()
        self.tottimeCh.initialize()
        self.doinitCh.initialize()
        self.dotriggerCh.initialize()
        self.dofetchCh.initialize()
        self.readoutCh.initialize()
    
    def prepare(self, dwell):
        """
        prepare keithley for gpib polling:
        scan passive, bus triggered, set dwell time
        
        dwell = dwell time in seconds (0.1 - 20.0)
        """
        self.scanCh.write(0)
        self.ttypeCh.write(2)
        nplc = 5.
        navg = dwell / 0.1
        if navg > 100:
            nplc *= 2
            navg /= 2
        navg = min(navg, 100)
        nplc = min(nplc, 10.)
        self.nplcCh.write(nplc)
        self.navgCh.write(navg)

    def trig(self):
        """
        trigger keithleys, wait until done, and read the result into EPICS.
        the value can then be read by pshell from the channel.
        """
        self.doinitCh.write(1)
        self.dotriggerCh.write(1)

    def get_dwell(self):
        """
        get dwell time in seconds.
        """
        dwell = self.tottimeCh.read() / 1000.
        return dwell
    
    def fetch(self):
        """
        fetch the current value from the keithley into EPICS.
        """
        #time.sleep(self.get_dwell())
        self.dofetchCh.write(1)

    def read(self):
        """
        read the curent value.
        """
        return self.readoutCh.read()
        
    def release(self):
        """
        switch keithleys to free run.
        0.1 s polling and dwell time
        """
        self.nplcCh.write(5.)
        self.navgCh.write(1)
        self.scanCh.write(9)
        self.ttypeCh.write(0)

KeiSample = Keithley("SampleKeithley", "X03DA-KEITHLEY-1:")
KeiReference = Keithley("ReferenceKeithley", "X03DA-KEITHLEY-2:")

KeiSample.initialize()
KeiReference.initialize()