'''
EYES for Young Engineers and Scientists (EYES 1.0)
Python library to communicate to the AtMega32 uC running 'eyes.c'
Author  : Ajith Kumar B.P, bpajith@gmail.com
License : GNU GPL version 3
Started on 1-Nov-2010
Last Edit : 13-Oct-2011   : Added MCP2200 support (for version 2)
Last Edit : 4-Nov-2011    : DAC maximum set to 5.000 volts


The hardware consisists of :
1) 2 Digital Inputs
2) 2 Digital Outputs
3) 2 DAC channels
4) 8 ADC channels (only 6 used)
       0,1 : -5V to 5V inputs
         2 : 0 to 5V input

5) 1 Square wave generator using ATmega32
6) 1 Square wave generator using IC555 (frequency range selectable through Atmega32)
7) 1 Pulse Width Modulator Output using ATmega32
8) A 100 Hz sine wave generator, bipolar
9) 1 Current source controlled by DAC channel 1
10)1 Non-Inverting Amplifier using OP27, gain can be set by an external resistor
11)1 Inverting amplifier, gain can be selected using a series resistance at the input
12)2 Inverting amplifiers with gain = 47 , mainly used for microphones. 
'''
from __future__ import print_function

import serial, struct, math, time, commands, sys, os, glob, fnmatch

import gettext
gettext.bindtextdomain("expeyes")
gettext.textdomain('expeyes')
_ = gettext.gettext


#Commands with One byte argument (41 to 80) 
GETVERSION    =   1
DIGIN         =     2    # Digital Input (4 bits)
USOUND        =   3   # Pulse OD1 to get rising edge on ID2(internal)

#Commands with One byte argument (41 to 80) 
SETSAMTIME    =  41    # MCP3208 sampling duration
SETADCSIZE    =  42
READADC       =  43    #Read the specified ADC channel
R2FTIME       =  44    # Rise to Fall of signal on input pins
R2RTIME       =  45    # Rise to Fall of signal on input pins
F2RTIME       =  46    # Fall to Rise of signal on input pins
F2FTIME       =  47    # Fall to Rise of signal on input pins
SET2RTIME     =  48    # Setting of bit to rising edge
SET2FTIME     =  49    # to falling time
CLR2RTIME     =  50    # Setting of bit to rising edge
CLR2FTIME     =  51    # to falling time
PULSE2RTIME   =  52    # Pulse to rising edge
PULSE2FTIME   =  53    # Pulse to rising edge
SETPULSEWID   =  54    # width for PULSE2 functions (0 to 250)
SETPULSEPOL   =  55    # PULSE polarity (0 for HIGH true)
DIGOUT        =  56    # Digital output (4 bits)
ADC2CMP       =  57    # Route ADC input to ACOMP-
SETPWM        =  58    # Set 488 Hz PWM wave on TC0
SETPWMDAC     =  59    # Set 31.25 kHz PWM wave on TC0
GETPORT       =  60    # PINX data from port X
IRSEND        =  61   # Send 8 bit data on SQR1, using infrared LED

# Commands with Two bytes argument (81 to 120)
SETPWM0       =  81    # PWM on on OSC0
SETCOUNTER0   =  82    # Square wave on OSC0
SETCOUNTER2   =  83    # Square wave on OSC2
SETACTION     =  84    # Capture Actions of SET/CLR type
MULTIR2R      =  85    # Rising edge to a rising edge after N cycles
ADCTRIGS      =  86    # Trigger levels for read_block functions
SETWAVEFORM   =  87    # ISR Wavegen. OCR0 and which DAC from the caller
PULSE_D0D1    =  88    # Interrupt driven square wave on D0 and D1
SETDDR        =  90    # DDRX = dirmask (arg1 = X, arg2 = mask)
SETPORT       =  91    # PORTX = DATA (arg1 = X, arg2 = DATA)

# Commands with Three bytes argument (121 to 160)    
SETDAC        = 121   # Serial DAC: send ch, dlo & dhi
QCAPTURE01    = 122    # 2 bytes N, 1 byte dt. captures channel 0 and 1
WREEPROM      = 123    # Write EEPROM , 2 byte addr & 1 byte data
RDEEPROM      = 124    # Read EEPROM , 2 byte addr , 1 byte nb

#Commands with Four bytes argument (161 to 200)
CAPTURE01     = 161     # 2 bytes N, 2 bytes dt. Capture channel 0 and 1
QCAPTURE      = 162     # Ch, 2 byte N, 1 byte dt.

#Commands with Five bytes argument (201 to 240)
CAPTURE       = 201     # Ch, 2 byte N, 2 byte dt. Capture from MCP3208 ADC
CAPTURE_M32   = 202     # Ch, 2 byte N, 2 byte dt. Capture from ATmega32 ADC

# Actions before capturing waveforms
ASET          = 1
ACLR          = 2
APULSEHI      = 3
APULSELO      = 4
AWAITHI       = 5
AWAITLO       = 6
AWAITRISE     = 7
AWAITFALL     = 8

BUFSIZE       = 1800       # status + adcinfo + 1800 data

#Serial devices to search for EYES hardware.  
linux_list = ['/dev/ttyUSB0', '/dev/ttyUSB1', '/dev/ttyUSB2',
          '/dev/ttyACM0','/dev/ttyACM1','/dev/ttyACM2',
          '/dev/cu.usbserial']


def open(dev = None):
    '''
    If EYES hardware in found, returns an instance of 'Eyes', else returns None.
    '''
    obj = Eyes()
    if obj.fd != None:
        obj.disable_actions()
        return obj
    print (_('Could not find Phoenix-EYES hardware'))
    print (_('Check the connections.'))

DACMAX = 5.000                # MCP4922 DAC goes only up to 4.933 volts, in version 1
BAUDRATE = 38400            # Serial communication

class Eyes:
    fd = None                                # init should fill this
    adcsize = 1
    m = [10.0/4095]*2 + [5.0/4095]*6 + [4095./DACMAX/2, 4095.0/DACMAX] # 8th and 9th are for DAC
    c = [-5.0]*2 + [0.0]*6 + [4095.0/2, 0]
    msg = '.'

    def __init__(self, dev = None):
        """
        Searches for EYES hardware on RS232 ports and the USB-to-Serial adapters. Presence of the
        device is done by reading the version string.
        The timeout at Python end is set to 3.2 milliseconds, twice the minimum 555 output time period.
        TODO : Supporting more than one EYES on a PC to be done. The question is how to find out
        whether a port is already open or not, without doing any transactions to it.
        """
        self.adcsize = 2;

        if os.name == 'nt':
            device_list = []
            for k in range(1,255):
                s = 'COM%d'%k
                device_list.append(s)
            for k in range(1,11):
                device_list.append(k)
        elif (os.uname()[0] == 'Darwin'):
            device_list = []
            device_list = glob.glob('/dev/cu.usbserial*')
        else:
            device_list = []    # gather unused ones from the linux_list
            for dev in linux_list:
                res = commands.getoutput('lsof -t '+ str(dev))
                if res == '':
                    device_list.append(dev)

        for dev in device_list:
            try:
                handle = serial.Serial(dev, BAUDRATE, stopbits=1, timeout = 0.3, parity=serial.PARITY_EVEN)
            except:
                continue
            print (_('Port %s is existing ')%dev,)
            if handle.isOpen() != True:
                print (_('but could not open'))
                continue
            print (_('and opened. '),)
            handle.flush()
            time.sleep(.5)
            while handle.inWaiting() > 0 :
                handle.flushInput()
            handle.write(chr(GETVERSION))
            res = handle.read(1)
            ver = handle.read(5)        # 5 character version number
            if ver[:2] == 'ey':
                self.device = dev
                self.fd = handle
                self.version = ver
                handle.timeout = 4.0    # r2rtime on .7 Hz require this
                print (_('Found EYES version '),ver)
                return
            else:
                print (_('No EYES hardware detected'))
                self.fd = None
#------------------------------------------------------------------------------------

    def dwrite(self,ch):
        self.fd.write(ch)
        time.sleep(0.01)        #MCP2200 to ATmega transfer has no handshake

#-------------------- Pulse Width Modulated Waveform on TC0 and TC2 ------------------
    def set_pwmdac(self, vout):        # Value in 0 to 5V
        '''
        Sets the PULSE output (T10) to 31.25 kHz and sets the duty cycle to make the
        average voltage = vout. Need External RC filter to use this as a DC output.
        0 to 5V range is covered in 255 steps and the function returns the value set.
        '''
        if 0 <= vout <= 5.0:
            val = int(vout*255.0/5.0)
            self.dwrite(chr(SETPWMDAC))
            self.dwrite(chr(val))
            self.fd.read(1)
            return val * 5.0 / 255

    def set_pulse(self, ds):        # Dutycycle in percentage
        '''
        Sets the frequency on PULSE to 488.3 Hz. Dutycycle is set to 'ds'.
        Returns the actual value set.
        '''
        if 0 <= ds <= 100:
            val = int(ds*255.0/100)
            self.dwrite(chr(SETPWM))
            self.dwrite(chr(val))
            self.fd.read(1)
            return val * 100.0 / 255

#---------------- Square Wave Generation & Measuring the Frequency ------------------
    def irsend(self, dat):                # Infrared transmission
            self.dwrite(chr(IRSEND))
            self.dwrite(chr(dat))
            self.fd.read(1)

    def set_sqr0(self, freq):        # Sets Squarewave on the PULSE output
        '''
        Sets a square wave on the PULSE output. Frequency from 15Hz to 40000000 Hz (4 MHz), but
        it is not possible to set all intermediate values.
        The function sets the nearest possible value and returns it.
        '''
        if freq < 1:        # Disable squarewave on PULSE
            self.dwrite(chr(SETCOUNTER0))
            self.dwrite(chr(0))
            self.dwrite(chr(0))
            self.fd.read(1)
            return 0

        div = [4000000.0, 500000.0, 125000.0, 62500.0, 31250.0,15625.0,3906.25]
        for i in range(7):
            clock_sel = i+1
            freq0 = div[i]
            if ( freq0/ freq) <= 256:
                break
        setpoint = freq0/freq
        if setpoint > 255:
            setpoint = 255
        OCR0 = int(setpoint)-1
        #print (clock_sel, OCR2)
        self.dwrite(chr(SETCOUNTER0))
        self.dwrite(chr(clock_sel))
        self.dwrite(chr(OCR0))
        res = self.fd.read(1)
        if res != 'D':
            return None
        if setpoint == 0:
            return freq0
        else:
            return freq0/(OCR0+1)

    def set_sqr1(self, freq):        # Freq in Hertz
        '''
        Sets the output frequency of the SQR1. Ranges from 15Hz to 40000000 Hz (4 MHz), but
        it is not possible to set all intermediate values.
        The function sets the nearest possible value and returns it.
        '''
        if freq < 1:        # Disable PWG
            self.dwrite(chr(SETCOUNTER2))
            self.dwrite(chr(0))
            self.dwrite(chr(0))
            self.fd.read(1)
            return 0

        div = [4000000.0, 500000.0, 125000.0, 62500.0, 31250.0,15625.0,3906.25]
        for i in range(7):
            clock_sel = i+1
            freq0 = div[i]
            if ( freq0/ freq) <= 256:
                break
        setpoint = freq0/freq
        if setpoint > 255:
            setpoint = 255
        OCR2 = int(setpoint)-1
        #print (clock_sel, OCR2)
        self.dwrite(chr(SETCOUNTER2))
        self.dwrite(chr(clock_sel))
        self.dwrite(chr(OCR2))
        res = self.fd.read(1)
        if res != 'D':
            return None
        if setpoint == 0:
            return freq0
        else:
            return freq0/(OCR2+1)

    def get_sqr1(self):
        '''
        This function measures the frequency of SQR1. There is no need of this
        since set_sqr1 returns the frequency actually set.
        '''
        self.adc2cmp(6)
        t = self.multi_r2rtime(4)
        if t < 10000:
            t = self.multi_r2rtime(4,9)
            return 1.0e7/t
        return 1.0e6 / t

    def set_sqr2(self, fmax):
        '''
        This function sets the frequency range of SQR2.
        The ranges are : 0.7 to 25, 25 to 1000, 1000 to 10000 and 10000 to 90000.
        You need to adjust the 22 KOhm variable resistor to get the desired frequency
        within the selected range. Software allows you to measure the frequency while
        adjusting the resistor. Frequency can be set from .7 Hz to 90 KHz in different ranges.
        '''
        if fmax < 0:                    #PA0 to LOW, makes 555 output LOW
            self.set_ddr(0,1)
            self.set_port(0,1)
        elif fmax == 0:                    #PA0 to LOW, makes 555 output HIGH
            self.set_ddr(0,1)
            self.set_port(0,0)
        elif fmax<= 25:
            self.set_ddr(0, 2+4+8+16)    # connect (47 + 1 + 0.1 + 0.01) uF
            self.set_port(0,0)
        elif fmax<= 1000:
            self.set_ddr(0, 2+4+8)        # connect (1 + 0.1 + 0.01) uF
            self.set_port(0,0)
        elif fmax<= 10000:
            self.set_ddr(0, 2+4)        # connect (0.1 + 0.01) uF
            self.set_port(0,0)
        elif fmax <= 90000:                # connect 0.01 uF
            self.set_ddr(0, 2)
            self.set_port(0,0)
        elif fmax > 300000:                # Oscllate with stray capacitance only
            self.set_ddr(0, 0)
            self.set_port(0,0)

    def get_sqr2(self):
        '''
        This function measures the frequency of SQR2 (555 oscillator).
        Call this while adjusting the frequency using the variable resistor.
        '''
        self.adc2cmp(6)
        t = self.multi_r2rtime(4)
        if t < 0:
            return t
        if 0 < t < 10000:
            t = self.multi_r2rtime(4,9)
            return 1.0e7/t
        return 1.0e6 / t

    def sensor_frequency(self):
        '''
        This function measures the frequency on the signal on SENS (T23) input.
        '''
        self.adc2cmp(5)
        t = self.multi_r2rtime(4)
        if t < 0:
            return t
        if 0 < t < 10000:
            t = self.multi_r2rtime(4,9)
            return 1.0e7/t
        return 1.0e6 / t

    def ampin_frequency(self):
        '''
        This function measures the frequency of an external BIPOLAR signal connected to Terminal 15.
        If your signal is unipolar , connect it through a 1uF series
        The amplitude must be more than 100 mV
        '''
        return self.digin_frequency(2)    # Amplifier output is connected to PC2

    def digin_frequency(self, pin):
        '''
        This function measures the frequency of an external 0 to 5V PULSE on digital inputs.
        '''
        t = self.multi_r2rtime(pin)
        if t < 0:
            return t
        if 0 < t < 10000:
            t = self.multi_r2rtime(pin,9)
            return 1.0e7/t
        return 1.0e6 / t

#-------------------------------------- ADC & DAC Calibrations -----------------------------
    def eeprom_write_char(self,addr, dat):
        '''
        Writes one byte to the specified address of the EEPROM memory of ATmega32.
        Used for storing the calibration constants of ADC and DAC.
        WARNING: Using this function may destroy the Calibration Data.
        '''
        self.dwrite(chr(WREEPROM))
        self.dwrite(chr(addr&255))
        self.dwrite(chr(addr>>8))
        self.dwrite(dat)
        res = self.fd.read(1)
        if res != 'D':
            print (_('eeprom write byte error = '), res)

    def eeprom_read_block(self, addr, nb):    # get nb bytes starting from addr
        '''
        Reads 'nb' bytes starting from the specified address of the EEPROM memory of ATmega32.
        Used for restoring the calibration constants of ADC and DAC.
        '''
        self.dwrite(chr(RDEEPROM))
        self.dwrite(chr(addr&255))
        self.dwrite(chr(addr>>8))
        self.dwrite(chr(nb))
        res = self.fd.read(1)
        if res != 'D':
            print (_('eeprom read block error = '), res)
        dat = self.fd.read(nb)
        return dat

    def save_calib(self, ch, m, c):    # Saves m & c (8 bytes) to addr ch*8
        '''
        It is possible to reduce the offset and gain errors of the ADC, DAC and the op-amps
        used in the circuit by doing a calibration. The -5V to 5V output is connected to both
        the -5V to +5V inputs before running the calibrate.py program. The output is measured
        with a >= 4.5 digit voltmeter and the calibration constants are stored to the EEPROM.
        WARNING: Using this function may destroy the Calibration Data.
        '''
        addr = ch*8
        s = struct.pack('f'*2, m, c)    # pack to floats
        for i in range(2*4):
            self.eeprom_write_char(addr+i, s[i])
            print (ord(s[i]),)
        print()
        self.m[ch] = m
        self.c[ch] = c
        print (_('SC: ch = %d m=%10.6f  c=%10.6f')%(ch, self.m[ch], self.c[ch]))

    def load_calib(self, ch):    # Load m & c from EEPROM
        '''
        Loads the calibration constants from the EEPROM and assigns them to the slope & intercept.
        '''
        res = self.eeprom_read_block(ch*8,8)
        if ord(res[0]) == 255 and ord(res[1]) == 255:
            print (_('BAD Calibration data. EEPROM does not have any data '))
            return
        raw = struct.unpack('f'*2, res)
        self.m[ch] = raw[0]
        self.c[ch] = raw[1]
        for c in res: print (ord(c),)
        print()
        print (_('LC: ch = %d m=%10.6f  c=%10.6f')%(ch, self.m[ch], self.c[ch]))

    def loadall_calib(self):
        self.load_calib(0)
        self.load_calib(1)
        self.load_calib(8)

#------------------------------------ ADC & DAC transactions -----------------------------

    def set_current(self, i):
        '''
        Sets the current of the Programmable Current Source.
        Possible to set it from .020 mA to 2 mA, provided the IR drop across the load resistor < 2V
        Returns the voltage at the Current Source Output.
        '''
        if (i < 0.020) or (i > 2.0):
            print (_('ERR:Current must be from 0.02 to 2.0 mA'))
            return None
        i += 0.005                # 5 uA correction is applied. NEED TO SOLVE THIS PROBLEM !!!
        Rc = 1000.0                      # Collector Resistance from 5V reference
        v = 5.0 - Rc * i * 1.0e-3        # mA to A
        #print (_('DAC0 to set current = '), v)
        self.set_voltage(1,v)
        return self.get_voltage(6)

    def write_dac(self, ch, data):
        '''
        Writes binary data to DAC. Low level routine, generally not used.
        '''
        if (data > 4095):         # DAC linearity problem
            data = 4095
        self.dwrite(chr(SETDAC))
        self.dwrite(chr(ch))
        self.dwrite(chr(data&255))
        self.dwrite(chr(data>>8))
        res = self.fd.read(1)
        if res != 'D':
            print (_('WRITEDAC error '), res)
            return
        return data

    def set_voltage(self, ch, val):        # returns the interger send to DAC
        '''
        Sets the voltage outputs. Channel 0 is -5V to +5V and channel 1 is 0V to 5V.
        The DAC output goes only upto 4.990 volts.
        '''
        if val > DACMAX: val = DACMAX        # Patch for the MCP4922 Problem
        if val < -DACMAX: val = -DACMAX
        iv = int(round(self.m[8+ch]*val + self.c[8+ch]))
        return self.write_dac(ch,iv)

    def set_bpv(self, val):        # returns the interger send to DAC
        '''
        Sets the Bipolar Voltage Output (T30) from -4.99 to + 4.99 volts
        '''
        return self.set_voltage(0,val)

    def set_upv(self, val):        # returns the interger send to DAC
        '''
        Sets the Unipolar Voltage Output (T31) from 0 to + 4.99 volts
        '''
        if val < 0: return
        return self.set_voltage(1,val)

    def read_adc(self, ch):
        '''
        Reads the specified ADC channel, returns a number from 0 to 4095. Low level routine.
        '''
        if (ch > 7):
            print (_('Argument error'))
            return
        self.dwrite(chr(READADC))
        self.dwrite(chr(ch))
        res = self.fd.read(1)
        if res != 'D':
            print (_('READADC error '), res)
            return
        res = self.fd.read(2)
        iv = ord(res[0]) | (ord(res[1]) << 8)
        return iv

    def get_voltage(self, ch):
        '''
        Reads the specified channel of the ADC. Returns -5V to 5V for channels 0 and 1
        0V to 5V for other channels.
        '''
        if (ch > 7):
            print (_('Argument error'))
            return
        self.dwrite(chr(READADC))
        self.dwrite(chr(ch))
        res = self.fd.read(1)
        if res != 'D':
            print (_('WRITEDAC error '), res)
            return
        res = self.fd.read(2)
        iv = ord(res[0]) | (ord(res[1]) << 8)
        v = self.m[ch] * iv + self.c[ch]
        return v

    def get_voltage_time(self, ch):
        '''
        Reads the specified channel of the ADC. Returns -5V to 5V for channels 0 and 1
        0V to 5V for other channels. Adds the PC time info
        '''
        if (ch > 7):
            print (_('Argument error'))
            return
        self.dwrite(chr(READADC))
        self.dwrite(chr(ch))
        tm = time.time()                # Job is sent. Now mark the time
        res = self.fd.read(1)
        if res != 'D':
            print (_('WRITEDAC error '), res)
            return
        res = self.fd.read(2)
        iv = ord(res[0]) | (ord(res[1]) << 8)
        v = self.m[ch] * iv + self.c[ch]
        return tm, v

    def set_samtime(self, sam):
        '''
        Sets the sampling time of MCP3208 ADC, minimum required is 2 uSec. Give more for high input
        impedance signals.
        '''
        if sam > 250:
            print (_('Sampling time MUST NOT exceed 250 microseconds'))
            return
        self.dwrite(chr(SETSAMTIME))
        self.dwrite(chr(sam))
        res = self.fd.read(1)
        if res != 'D':
            print (_('SETSAMTIME ERROR '), res)

    def set_adcsize(self, size):
        '''
        The ADC output is 12 bits (2 bytes space). Capture functions gives the option to discard
        4 LSBs and return the data in 1 byte, saving space and time.
        '''
        if size > 2:
            print (_('ADC datasize MUST be 1 or 2 bytes'))
            return
        self.dwrite(chr(SETADCSIZE))
        self.dwrite(chr(size))
        res = self.fd.read(1)
        if res != 'D':
            print (_('SETADCSIZE ERROR '), res)
        else:
            self.adcsize = size


    def capture(self, ch, np, delay):
        '''
        Arguments : channel number , number of samples and timegap between consecutive
        digitizations. Returns two lists of size 'np'; time and volatge.
        '''
        if delay < 10:
            return
        if delay < 20:
            self.dwrite(chr(QCAPTURE))
            self.dwrite(chr(ch))
            self.dwrite(chr(np&255))
            self.dwrite(chr(np>>8))
            self.dwrite(chr(delay))
            st = time.time()
            res = self.fd.read(1)
            if res != 'D':
                print (_('QCAPTURE Error '), res, time.time()-st)
                return 0,0
            asize = 1                    # adc datasize = 1 for QCAPTURE
        else:
            self.dwrite(chr(CAPTURE))
            self.dwrite(chr(ch))
            self.dwrite(chr(np&255))
            self.dwrite(chr(np>>8))
            self.dwrite(chr(delay&255))
            self.dwrite(chr(delay>>8))
            res = self.fd.read(1)
            if res != 'D':
                print (_('CAPTURE error '), res)
                return
            res = self.fd.read(1)        # adc_size info from other end
            asize = ord(res)
        nc = asize * np
        data = self.fd.read(nc)
        dl = len(data)
        if dl != nc:
            print (_('CAPTURE: size mismatch '), nc, dl)
            return

        ta = []
        va = []
        if ch <= 1:                                    # Channel 0 or 1 (-5V to +5V)
            if asize == 2:                            # 2 byte dataword
                raw = struct.unpack('H'* np, data)  # 2 byte words in the structure
                for i in range(np):
                    ta.append(0.001 * i * delay)    # microseconds to milliseconds
                    va.append(self.m[ch] * (raw[i]>>4) + self.c[ch])
            else:
                raw = struct.unpack('B'* np, data)  # 1 byte words in the structure
                for i in range(np):
                    ta.append(0.001 * i * delay)        # microseconds to milliseconds
                    va.append(raw[i]*10.0/255 - 5.0)
        else:
            if asize == 2:                            # 2 byte dataword
                raw = struct.unpack('H'* np, data)  # 16 bit data in uint16 array
                for i in range(np):
                    ta.append(0.001 * i * delay)    # microseconds to milliseconds
                    va.append((raw[i]>>4) * 5.0 / 4095)
            else:
                raw = struct.unpack('B'* np, data)  # 8 bit data in byte array
                for i in range(np):
                    ta.append(0.001 * i * delay)    # microseconds to milliseconds
                    va.append(raw[i] * 5.0 / 255)
        return ta,va


    def capture01(self,np, delay):
        '''
        Samples the first two channels 'np' times.
        Time gap between samples is 'delay' usecs.
        If delay < 20, 9 usecs offset between CH0 & CH1, else 17 usecs.
        '''
        if delay < 10:
            return
        if delay < 20:                # Fast Capture, datasize = 1 byte
            self.dwrite(chr(QCAPTURE01))
            self.dwrite(chr(np&255))
            self.dwrite(chr(np>>8))
            self.dwrite(chr(delay))
            res = self.fd.read(1)
            if res != 'D':
                print (_('CAPTURE01 error '), res)
                return
            asize = 1
            tg01 =  0.009            # 0.009 milliseconds between CH0 and CH1
        else:                        # A slow capture
            self.dwrite(chr(CAPTURE01))
            self.dwrite(chr(np&255))
            self.dwrite(chr(np>>8))
            self.dwrite(chr(delay&255))
            self.dwrite(chr(delay>>8))
            res = self.fd.read(1)
            if res != 'D':
                print (_('CAPTURE01 error '), res)
                return
            res = self.fd.read(1)    # adc_size info from other end
            asize = ord(res)
            tg01 = 0.017            # 0.017 milliseconds between Ch0 & Ch1 digitizations

        nb = asize *np * 2        # data from two channels
        data = self.fd.read(nb)
        dl = len(data)
        if dl != nb:
            print (_('CAPTURE01: size mismatch '), nb, dl)
            return

        taa = []    # time & voltage arrays for CH0
        vaa = []
        tba = []    # time & voltage arrays for CH1
        vba = []
        if asize == 1:                            # 1 byte dataword
            raw = struct.unpack('B'* 2*np, data)  # 8 bit data in byte array
            for i in range(np):
                taa.append(0.001 * 2 * i * delay)
                vaa.append(raw[2*i] * 10.0 / 255.0 - 5.0)
                tba.append(0.001 * 2 * i * delay + tg01)
                vba.append(raw[2*i +1] * 10.0 / 255.0 - 5.0)
        else:
            raw = struct.unpack('H'* 2*np, data)  # 16 bit data in uint16 array
            for i in range(np):
                taa.append(0.001 * 2 * i * delay)
                vaa.append((raw[2*i]>>4) * 10.0 / 4095.0 - 5.0)
                tba.append(0.001 * 2 * i * delay + tg01)
                vba.append((raw[2*i +1]>>4) * 10.0 / 4095.0 - 5.0)
        return taa,vaa,tba,vba


    def capture_m32(self, ch, np, delay):   # Not working properly
        '''
        Capture 'np' samples from the ATmega32 ADC.
        Arguments : channel number , number of samples and timegap between consecutive
        digitizations. Returns a list of [time, volatge] coordinates.
        '''
        if delay < 10:
            return
        self.dwrite(chr(CAPTURE_M32))
        self.dwrite(chr(ch))
        self.dwrite(chr(np&255))
        self.dwrite(chr(np>>8))
        self.dwrite(chr(delay&255))
        self.dwrite(chr(delay>>8))
        res = self.fd.read(1)
        if res != 'D':
            print (_('CAPTURE_M32 error '), res)
            return
        asize = 1            # datasize = 1 for CAPTURE_M32
        nc = asize * np
        data = self.fd.read(nc)
        dl = len(data)
        if dl != nc:
            print (_('CAPTURE_M32: size mismatch '), nc, dl)
            return

        ta = []
        va = []
        raw = struct.unpack('B'* np, data)  # 8 bit data in byte array
        for i in range(np):
            ta.append(0.001 * i * delay)    # microseconds to milliseconds
            va.append(raw[i] * 5.0 / 255)
        return ta,va

#------------------- Modifiers for Capture ------------------------------
    def disable_actions(self):
        '''
        Disable all modifiers to the capture call. The capture will try to
        do a self triggering on the ADC input.
        '''
        self.dwrite(chr(SETACTION))
        self.dwrite(chr(0))
        self.dwrite(chr(0))
        self.fd.read(1)

    def enable_wait_high(self, pin):
        '''
        Wait for a HIGH on the speciied 'pin' just before every Capture.
        '''
        if pin == 4:
            mask = 0
        else:
            mask = 1 << pin
        self.dwrite(chr(SETACTION))
        self.dwrite(chr(AWAITHI))
        self.dwrite(chr(mask))
        self.fd.read(1)

    def enable_wait_rising(self, pin):
        '''
        Wait for a rising EDGE on the speciied 'pin' just before every Capture.
        '''
        if pin == 4:
            mask = 0
        else:
            mask = 1 << pin
        print (_('wait_rising '), AWAITRISE)
        self.dwrite(chr(SETACTION))
        self.dwrite(chr(AWAITRISE))
        self.dwrite(chr(mask))
        self.fd.read(1)

    def enable_wait_low(self, pin):
        '''
        Wait for a LOW on the speciied 'pin' just before every Capture.
        '''
        if pin == 4:
            mask = 0
        else:
            mask = 1 << pin
        self.dwrite(chr(SETACTION))
        self.dwrite(chr(AWAITLO))
        self.dwrite(chr(mask))
        self.fd.read(1)

    def enable_wait_falling(self, pin):
        '''
        Wait for a falling EDGE on the speciied 'pin' just before every Capture.
        '''
        if pin == 4:
            mask = 0
        else:
            mask = 1 << pin
        print (_('wait_rising '), AWAITRISE)
        self.dwrite(chr(SETACTION))
        self.dwrite(chr(AWAITFALL))
        self.dwrite(chr(mask))
        self.fd.read(1)

    def enable_set_high(self, pin):
        '''
        Sets the speciied 'pin' HIGH, just before every Capture.
        '''
        mask = 1 << pin
        self.dwrite(chr(SETACTION))
        self.dwrite(chr(ASET))
        self.dwrite(chr(mask))
        self.fd.read(1)

    def enable_set_low(self, pin):
        '''
        Sets the speciied 'pin' LOW, just before every Capture.
        '''
        mask = 1 << pin
        self.dwrite(chr(SETACTION))
        self.dwrite(chr(ACLR))
        self.dwrite(chr(mask))
        self.fd.read(1)

    def enable_pulse_high(self, pin):
        '''
        Generate a HIGH TRUE Pulse on the speciied 'pin', just before every Capture.
        width is specified by the set_pulsewidth() function.
        '''
        mask = 1 << pin
        self.dwrite(chr(SETACTION))
        self.dwrite(chr(APULSEHI))
        self.dwrite(chr(mask))
        self.fd.read(1)

    def enable_pulse_low(self, pin):
        '''
        Generate a LOW TRUE Pulse on the speciied 'pin', just before every Capture.
        '''
        mask = 1 << pin
        self.dwrite(chr(SETACTION))
        self.dwrite(chr(APULSELO))
        self.dwrite(chr(mask))
        self.fd.read(1)



#------------------------Time Interval Measurement routines-------------
    def set_pulsepol(self, pol):
        '''
        Sets the 'pulse_polarity' parameter for pulse2rtime()
        pol = 0 means HIGH TRUE pulse
        '''
        self.dwrite(chr(SETPULSEPOL))
        self.dwrite(chr(pol))
        res = self.fd.read(1)
        if res == 'D':
            self.pulse_pol = pol

    def set_pulsewidth(self, width):
        '''
        Sets the 'pulse_width' parameter for pulse2rtime() command.
        Also used by usound_time() and the elable_pulse_high/low() functions
        '''
        self.dwrite(chr(SETPULSEWID))
        self.dwrite(chr(width))
        res = self.fd.read(1)
        if res == 'D':
            self.pulse_width = width

    def usound_time(self):
        '''
        Used for measuring the velocity of sound. Connect the Transmitter Piezo to OD1 (T4).
        The Receiver is connected to the amplifier input T15. This function measures the time
        from a Pulse on ID1 to a signal on T15, in microseconds.
        Use set_pulsewidth() to set the width to 13 microseconds.
        '''
        self.dwrite(chr(USOUND))
        res = self.fd.read(1)
        if res != 'D':
            print (_('Echo error = '),res)
            return -1.0
        res = self.fd.read(3)
        low = (ord(res[1]) << 8) | ord(res[0])
        return low + 50000 * ord(res[2])

    def __helper(self, cmd, pin1, pin2):    # pins 0 to 3
        '''
        Used by time measurement functions below.
        Make an 8 bit mask from pin1 and pin2.
        First argument (pin1) is encoded in the HIGH half.
        for example pin1 = 2 , pin2 = 0, mask = 0010:0001
        '''
        if pin1 > 4 or pin2 > 4:
            return -1.0
        if pin1 == 4:            # Analog Comparator
            hi = 0
        else:
            hi = 1 << (pin1+4)  # digin pins
           
        if pin2 == 4:            # wait on Analog comparator
            low = 0
        else:
            low  = 1 << pin2
        mask = hi | low;
        self.dwrite(chr(cmd))
        self.dwrite(chr(mask))
        res = self.fd.read(1)
        if res != 'D':
            print (_('Time Measurement call Error. CMD = '), cmd, res)
            return -1.0
        res = self.fd.read(3)
        low = (ord(res[1]) << 8) | ord(res[0])
        return float(low + 50000 * ord(res[2]))
    
    def r2ftime(self, pin1, pin2):
        '''
        Measures time from a rising edge of pin1 to a falling edge on pin2.
        Pins could be same or distinct.
        '''
        return self.__helper(R2FTIME, pin1, pin2)

    def f2rtime(self, pin1, pin2):
        '''
        Measures time from a falling edge of pin1 to a rising edge on pin2.
        Pins could be same or distinct.
        '''
        return self.__helper(F2RTIME, pin1, pin2)

    def r2rtime(self, pin1, pin2):
        '''
        Measures time from a rising edge of pin1 to a rising edge on pin2.
        Pins could be same or distinct.
        '''
        return self.__helper(R2RTIME, pin1, pin2)

    def f2ftime(self, pin1, pin2):
        '''
        Measures time from a falling edge of pin1 to a falling edge on pin2.
        Pins could be same or distinct.
        '''
        return self.__helper(F2FTIME, pin1, pin2)

    def set2ftime(self, op, ip):
        '''
        Measures time from Setting output pin 'op' to a LOW on input pin 'ip'
        '''
        return self.__helper(SET2FTIME, op, ip)

    def set2rtime(self, op, ip):
        '''
        Measures time from Setting output pin 'op' to a HIGH on input pin 'ip'
        '''
        return self.__helper(SET2RTIME, op, ip)

    def clr2rtime(self, op, ip):
        '''
        Measures time from Clearing output pin 'op' to a HIGH on input pin 'ip'
        '''
        return self.__helper(CLR2RTIME, op, ip)

    def clr2ftime(self, op, ip):
        '''
        Measures time from Clearing output pin 'op' to a LOW on input pin 'ip'
        '''
        return self.__helper(CLR2FTIME, op, ip)

    def pulse2rtime(self, op, ip):
        '''
        Measures time from a Pulse on pin 'op' to a HIGH on input pin 'ip'
        '''
        return self.__helper(PULSE2RTIME, op, ip)

    def pulse2ftime(self, op, ip):
        '''
        Measures time from a Pulse on pin 'op' to a LOW on input pin 'ip'
        '''
        return self.__helper(PULSE2FTIME, op, ip)

    def multi_r2rtime(self, pin , skipcycles=0):
        '''
        Time between two rising edges on the same input pin.
        separated by 'skipcycles' number of cycles.
        If skipcycles is zero the period of the waveform is returned.
        '''
        if pin > 4:            # ADC inputs
            mask = pin << 4
        elif pin == 4:
            mask = 0
        else:
            mask = 1 << pin
        self.dwrite(chr(MULTIR2R))
        self.dwrite(chr(mask))
        self.dwrite(chr(skipcycles))
        if self.fd.read(1) != 'D':
            return -1.0
        res = self.fd.read(3)
        low = (ord(res[1]) << 8) | ord(res[0])
        return float(low + 50000 * ord(res[2]))


    def adc2cmp(self, ch):            # Route ADC input to comparator (AIN-)
        '''
        Route the specified ADC channel to the Analog Comparator Input (AIN-)
        '''
        self.dwrite(chr(ADC2CMP))
        self.dwrite(chr(ch))
        self.fd.read(1)

#----------------------------- Simple Digital I/O functions ----------------------------
    def write_outputs(self, val):
        '''
        Writes  a 2 bit number to the Digital Outputs
        '''
        self.dwrite(chr(DIGOUT))
        self.dwrite(chr(val))
        self.fd.read(1)

    def read_inputs(self):
        '''
        Gets a 4 bit number representing the Digital Input voltage Levels
        '''
        self.dwrite(chr(DIGIN))
        res = self.fd.read(1)
        if res != 'D':
            print (_('DIGIN error'))
            return
        res = self.fd.read(1)
        return ord(res) & 15        # 4 LSBs

#-----------DIRECT PORT ACCESS FUNCTIONS (Use only if you know what you are doing)---------
    def set_ddr(self, port, direc):
        self.dwrite(chr(SETDDR))
        self.dwrite(chr(port))     # 0 to 3 for A,B,C and D
        self.dwrite(chr(direc))
        self.fd.read(1)
        return

    def set_port(self, port, val):
        self.dwrite(chr(SETPORT))
        self.dwrite(chr(port))     # 0 to 3 for A,B,C and D
        self.dwrite(chr(val))
        self.fd.read(1)
        return

    def get_port(self, port):
        self.dwrite(chr(SETPORT))
        self.dwrite(chr(port))     # 0 to 3 for A,B,C and D
        self.fd.read(1)
        data = self.fd.read(1)          # get the status byte only
        return ord(data)

#--------------------------------- may go to eyeutils.py ------------------------------
    def minimum(self,va):
        vmin = 1.0e10        # need to change
        for v in va:
            if v < vmin:
                vmin = v
        return vmin

    def maximum(self,va):
        vmax = 1.0e-10        # need to change
        for v in va:
            if v > vmax:
                vmax = v
        return vmax

    def rms(self,va):
        vsum = 0.0
        for v in va:
            vsum += v**2
        v = vsum / len(va)
        return math.sqrt(v)

    def mean(self,va):
        vsum = 0.0
        for v in va:
            vsum += v
        v = vsum / len(va)
        return v

    def save(self, data, filename = 'plot.dat'):
        '''
        Input data is of the form, [ [x1,y1], [x2,y2],....] where x and y are vectors
        '''
        if data == None: return
        import __builtin__                    # Need to do this since 'eyes.py' redefines 'open'
        f = __builtin__.open(filename,'w')
        for xy in data:
            for k in range(len(xy[0])):
                f.write('%5.3f  %5.3f\n'%(xy[0][k], xy[1][k]))
            f.write('\n')
        f.close()

    def grace(self, data, xlab = '', ylab = '', title = ''):
        '''
        Input data is of the form, [ [x1,y1], [x2,y2],....] where x and y are vectors
        '''
        try:
            import pygrace
            global pg
            pg = pygrace.grace()
            for xy in data:
                pg.plot(xy[0],xy[1])
                pg.hold(1)                # Do not erase the old data
            pg.xlabel(xlab)
            pg.ylabel(ylab)
            pg.title(title)
            return True
        except:
            return False
