# HG changeset patch # User Jeandet Alexis # Date 2016-12-23 11:34:01 # Node ID 142b4267322d6de937498c24939176cbeffe7f6c # Parent 438467acb8ed1105fa013fa611de6e112c4f6784 Added Discoply Added interface to discoply in discovery class Some fixes on prologix GPIB class diff --git a/lppinstru/discoply.py b/lppinstru/discoply.py new file mode 100644 --- /dev/null +++ b/lppinstru/discoply.py @@ -0,0 +1,87 @@ +#!/usr/bin/env python +#-*- coding: utf-8 -*- +"""Simple python library to drive the analog discovery module from www.digilentinc.com + With Discoply addon connected https://hephaistos.lpp.polytechnique.fr/rhodecode/HG_REPOSITORIES/LPP/INSTRUMENTATION/PCB/DiscoPli +""" + +from ctypes import * +import time +import sys +import os +import matplotlib.pyplot as plt +import numpy as np +from lppinstru import discovery + +__author__ = "Alexis Jeandet" +__copyright__ = "Copyright 2015, Laboratory of Plasma Physics" +__credits__ = [] +__license__ = "GPLv2" +__version__ = "1.0.0" +__maintainer__ = "Alexis Jeandet" +__email__ = "alexis.jeandet@member.fsf.org" +__status__ = "Production" + + + +class discoply(discovery.Discovery): + _gains={ + "LTC-6910-1":[0, 1, 2, 5, 10, 20, 50, 100], + "LTC-6910-2":[0, 1, 2, 4, 8, 16, 32, 64], + "LTC-6910-3":[0, 1, 2, 3, 4, 5, 6, 7] + } + def __init__(self,card=-1,model="LTC-6910-1",gain_ch1=1,gain_ch2=1): + super(discoply,self).__init__(card) + self._model=model + self.set_power() + self.digital_io_output_enable(0x3F) + self.gain_idx = [gain_ch1,gain_ch2] + + def auto_remove_offset(self,channel=0): + out=0.0 + for i in range(10): + self.analog_out_gen(shape="DC",offset=out) + time.sleep(0.2) + mean=super(discoply,self).analog_in_read(frequency=1e5,samplesCount=8192)[0][channel].mean() + out+=-mean*14./self.gain[channel] + return mean + + def analog_in_read(self,ch1=True,ch2=True,frequency=100000000,samplesCount=100,ch1range=5.0,ch2range=5.0,trigger=discovery.trigsrcNone): + data=super(discoply,self).analog_in_read(ch1,ch2,frequency,samplesCount,ch1range,ch2range,trigger) + if self.gain[0] !=0: + data[0][0]=data[0][0]/self.gain[0] + if self.gain[1] !=0: + data[0][1]=data[0][1]/self.gain[1] + return data + + @property + def offset(self): + data=super(discoply,self).analog_in_read(frequency=1e4,samplesCount=8192)[0] + return [data[0].mean(),data[1].mean()] + + @property + def gain(self): + return [ + self._gains[self._model][self.gain_idx[0]], + self._gains[self._model][self.gain_idx[1]]] + + @property + def gain_idx(self): + dio=self.digital_io + return [dio&7,(dio>>3)&7] + + @gain_idx.setter + def gain_idx(self,value): + self.digital_io =(value[0]&7) + ((value[1]&7)<<3) + + def set_gain_idx(self,value,channel): + gain = self.gain & ~(7 << [0,3][channel]) + self.gain_idx = gain + (value << [0,3][channel]) + + +if __name__ == '__main__': + quit() + + + + + diff --git a/lppinstru/discovery.py b/lppinstru/discovery.py old mode 100755 new mode 100644 --- a/lppinstru/discovery.py +++ b/lppinstru/discovery.py @@ -364,6 +364,9 @@ class Discovery(object): self.__libdwf.FDwfAnalogOutTriggerSourceSet(self.__hdwf, c_int(channel), trigSrc) self.__libdwf.FDwfAnalogOutRepeatTriggerSet(self.__hdwf, c_int(channel), c_bool(trigRepeat)) + def __del__(self): + if self.__opened: + self.__libdwf.FDwfDeviceClose(self.__hdwf) def analog_out_status(self, channel=0): status = c_byte(DwfStateDone.value) @@ -400,13 +403,22 @@ class Discovery(object): # self.__libdwf.FDwfAnalogOutWaitSet(self.__hdwf, c_int(channel), c_double(wait)) # self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(True)) - - + def digital_io_get(self): + dwRead = c_uint32() + self.__libdwf.FDwfDigitalIOStatus (self.__hdwf) + self.__libdwf.FDwfDigitalIOInputStatus(self.__hdwf, byref(dwRead)) + return dwRead.value - def __del__(self): - if self.__opened: - self.__libdwf.FDwfDeviceClose(self.__hdwf) + def digital_io_set(self,value): + self.__libdwf.FDwfDigitalIOOutputSet(self.__hdwf, c_int(value)) + @property + def digital_io(self): + return self.digital_io_get() + + @digital_io.setter + def digital_io(self,value): + self.digital_io_set(value) if __name__ == '__main__': print("open first dev") diff --git a/lppinstru/dlp_temp.py b/lppinstru/dlp_temp.py --- a/lppinstru/dlp_temp.py +++ b/lppinstru/dlp_temp.py @@ -107,21 +107,21 @@ class dlp_temp(object): return self.digit_in(0) @GP2.setter def GP2(self,value): - return self.digit_out(0,val) + return self.digit_out(0,value) @property def GP0(self): return self.digit_in(1) @GP0.setter def GP0(self,value): - return self.digit_out(1,val) + return self.digit_out(1,value) @property def GP4(self): return self.digit_in(2) @GP4.setter def GP4(self,value): - return self.digit_out(2,val) + return self.digit_out(2,value) if __name__ == '__main__': print("") diff --git a/lppinstru/prologix_usb_gpib.py b/lppinstru/prologix_usb_gpib.py --- a/lppinstru/prologix_usb_gpib.py +++ b/lppinstru/prologix_usb_gpib.py @@ -23,13 +23,15 @@ class UsbGpib(object): 1:"CONTROLLER" ,} revmodedic = {"DEVICE":"0" , "CONTROLLER":"1" ,} - def __init__(self,port,address=0): - self._port=serial.Serial(port,timeout=0.1) + def __init__(self,port,address=0,baudrate=9600): + self._port=serial.Serial(port,timeout=0.1,baudrate=baudrate) self._address=address - self._mode=1 + self.write("++auto 1") + self._auto=1 + self.mode=1 self.write("++ver") self.version=self.read() - self.write("++auto 1") + def set_as_device(self): self.write("++mode 0") @@ -44,7 +46,10 @@ class UsbGpib(object): @mode.setter def mode(self,new_mode): - self._mode=self.revmodedic[new_mode] + if type(new_mode) == type("str"): + self._mode=self.revmodedic[new_mode] + elif type(new_mode) == type(1): + self._mode=new_mode self.write("++mode %d" % self._mode) @property @@ -58,16 +63,26 @@ class UsbGpib(object): self.write("++addr %d" % self._address) def write(self,command): - self._port.write(b"%s\n\r" % command) + self._port.write(("%s\n\r" % command).encode()) self._port.flush() - def read(self,command="",GPIB=False): + def read(self,command=""): if not command=="": self.write(command) - if GPIB: + if command[0:2]!="++" and self._auto==0: self.write("++read") return self._port.readall() def idn(self): return self.read("*IDN?") + + @property + def auto_read_after_write(self): + self._auto=int(self.read("++auto")) + return self._auto + + @auto_read_after_write.setter + def auto_read_after_write(self,enabled): + self._auto=enabled + self.write("++auto %d" % self._auto)