@@ -0,0 +1,87 | |||
|
1 | #!/usr/bin/env python | |
|
2 | #-*- coding: utf-8 -*- | |
|
3 | """Simple python library to drive the analog discovery module from www.digilentinc.com | |
|
4 | With Discoply addon connected https://hephaistos.lpp.polytechnique.fr/rhodecode/HG_REPOSITORIES/LPP/INSTRUMENTATION/PCB/DiscoPli | |
|
5 | """ | |
|
6 | ||
|
7 | from ctypes import * | |
|
8 | import time | |
|
9 | import sys | |
|
10 | import os | |
|
11 | import matplotlib.pyplot as plt | |
|
12 | import numpy as np | |
|
13 | from lppinstru import discovery | |
|
14 | ||
|
15 | __author__ = "Alexis Jeandet" | |
|
16 | __copyright__ = "Copyright 2015, Laboratory of Plasma Physics" | |
|
17 | __credits__ = [] | |
|
18 | __license__ = "GPLv2" | |
|
19 | __version__ = "1.0.0" | |
|
20 | __maintainer__ = "Alexis Jeandet" | |
|
21 | __email__ = "alexis.jeandet@member.fsf.org" | |
|
22 | __status__ = "Production" | |
|
23 | ||
|
24 | ||
|
25 | ||
|
26 | class discoply(discovery.Discovery): | |
|
27 | _gains={ | |
|
28 | "LTC-6910-1":[0, 1, 2, 5, 10, 20, 50, 100], | |
|
29 | "LTC-6910-2":[0, 1, 2, 4, 8, 16, 32, 64], | |
|
30 | "LTC-6910-3":[0, 1, 2, 3, 4, 5, 6, 7] | |
|
31 | } | |
|
32 | def __init__(self,card=-1,model="LTC-6910-1",gain_ch1=1,gain_ch2=1): | |
|
33 | super(discoply,self).__init__(card) | |
|
34 | self._model=model | |
|
35 | self.set_power() | |
|
36 | self.digital_io_output_enable(0x3F) | |
|
37 | self.gain_idx = [gain_ch1,gain_ch2] | |
|
38 | ||
|
39 | def auto_remove_offset(self,channel=0): | |
|
40 | out=0.0 | |
|
41 | for i in range(10): | |
|
42 | self.analog_out_gen(shape="DC",offset=out) | |
|
43 | time.sleep(0.2) | |
|
44 | mean=super(discoply,self).analog_in_read(frequency=1e5,samplesCount=8192)[0][channel].mean() | |
|
45 | out+=-mean*14./self.gain[channel] | |
|
46 | return mean | |
|
47 | ||
|
48 | def analog_in_read(self,ch1=True,ch2=True,frequency=100000000,samplesCount=100,ch1range=5.0,ch2range=5.0,trigger=discovery.trigsrcNone): | |
|
49 | data=super(discoply,self).analog_in_read(ch1,ch2,frequency,samplesCount,ch1range,ch2range,trigger) | |
|
50 | if self.gain[0] !=0: | |
|
51 | data[0][0]=data[0][0]/self.gain[0] | |
|
52 | if self.gain[1] !=0: | |
|
53 | data[0][1]=data[0][1]/self.gain[1] | |
|
54 | return data | |
|
55 | ||
|
56 | @property | |
|
57 | def offset(self): | |
|
58 | data=super(discoply,self).analog_in_read(frequency=1e4,samplesCount=8192)[0] | |
|
59 | return [data[0].mean(),data[1].mean()] | |
|
60 | ||
|
61 | @property | |
|
62 | def gain(self): | |
|
63 | return [ | |
|
64 | self._gains[self._model][self.gain_idx[0]], | |
|
65 | self._gains[self._model][self.gain_idx[1]]] | |
|
66 | ||
|
67 | @property | |
|
68 | def gain_idx(self): | |
|
69 | dio=self.digital_io | |
|
70 | return [dio&7,(dio>>3)&7] | |
|
71 | ||
|
72 | @gain_idx.setter | |
|
73 | def gain_idx(self,value): | |
|
74 | self.digital_io =(value[0]&7) + ((value[1]&7)<<3) | |
|
75 | ||
|
76 | def set_gain_idx(self,value,channel): | |
|
77 | gain = self.gain & ~(7 << [0,3][channel]) | |
|
78 | self.gain_idx = gain + (value << [0,3][channel]) | |
|
79 | ||
|
80 | ||
|
81 | if __name__ == '__main__': | |
|
82 | quit() | |
|
83 | ||
|
84 | ||
|
85 | ||
|
86 | ||
|
87 |
@@ -364,6 +364,9 class Discovery(object): | |||
|
364 | 364 | self.__libdwf.FDwfAnalogOutTriggerSourceSet(self.__hdwf, c_int(channel), trigSrc) |
|
365 | 365 | self.__libdwf.FDwfAnalogOutRepeatTriggerSet(self.__hdwf, c_int(channel), c_bool(trigRepeat)) |
|
366 | 366 | |
|
367 | def __del__(self): | |
|
368 | if self.__opened: | |
|
369 | self.__libdwf.FDwfDeviceClose(self.__hdwf) | |
|
367 | 370 | |
|
368 | 371 | def analog_out_status(self, channel=0): |
|
369 | 372 | status = c_byte(DwfStateDone.value) |
@@ -400,13 +403,22 class Discovery(object): | |||
|
400 | 403 | # self.__libdwf.FDwfAnalogOutWaitSet(self.__hdwf, c_int(channel), c_double(wait)) |
|
401 | 404 | # self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(True)) |
|
402 | 405 | |
|
403 | ||
|
404 | ||
|
406 | def digital_io_get(self): | |
|
407 | dwRead = c_uint32() | |
|
408 | self.__libdwf.FDwfDigitalIOStatus (self.__hdwf) | |
|
409 | self.__libdwf.FDwfDigitalIOInputStatus(self.__hdwf, byref(dwRead)) | |
|
410 | return dwRead.value | |
|
405 | 411 | |
|
406 |
def |
|
|
407 | if self.__opened: | |
|
408 | self.__libdwf.FDwfDeviceClose(self.__hdwf) | |
|
412 | def digital_io_set(self,value): | |
|
413 | self.__libdwf.FDwfDigitalIOOutputSet(self.__hdwf, c_int(value)) | |
|
409 | 414 | |
|
415 | @property | |
|
416 | def digital_io(self): | |
|
417 | return self.digital_io_get() | |
|
418 | ||
|
419 | @digital_io.setter | |
|
420 | def digital_io(self,value): | |
|
421 | self.digital_io_set(value) | |
|
410 | 422 | |
|
411 | 423 | if __name__ == '__main__': |
|
412 | 424 | print("open first dev") |
@@ -107,21 +107,21 class dlp_temp(object): | |||
|
107 | 107 | return self.digit_in(0) |
|
108 | 108 | @GP2.setter |
|
109 | 109 | def GP2(self,value): |
|
110 | return self.digit_out(0,val) | |
|
110 | return self.digit_out(0,value) | |
|
111 | 111 | |
|
112 | 112 | @property |
|
113 | 113 | def GP0(self): |
|
114 | 114 | return self.digit_in(1) |
|
115 | 115 | @GP0.setter |
|
116 | 116 | def GP0(self,value): |
|
117 | return self.digit_out(1,val) | |
|
117 | return self.digit_out(1,value) | |
|
118 | 118 | |
|
119 | 119 | @property |
|
120 | 120 | def GP4(self): |
|
121 | 121 | return self.digit_in(2) |
|
122 | 122 | @GP4.setter |
|
123 | 123 | def GP4(self,value): |
|
124 | return self.digit_out(2,val) | |
|
124 | return self.digit_out(2,value) | |
|
125 | 125 | |
|
126 | 126 | if __name__ == '__main__': |
|
127 | 127 | print("") |
@@ -23,13 +23,15 class UsbGpib(object): | |||
|
23 | 23 | 1:"CONTROLLER" ,} |
|
24 | 24 | revmodedic = {"DEVICE":"0" , |
|
25 | 25 | "CONTROLLER":"1" ,} |
|
26 | def __init__(self,port,address=0): | |
|
27 | self._port=serial.Serial(port,timeout=0.1) | |
|
26 | def __init__(self,port,address=0,baudrate=9600): | |
|
27 | self._port=serial.Serial(port,timeout=0.1,baudrate=baudrate) | |
|
28 | 28 | self._address=address |
|
29 |
self. |
|
|
29 | self.write("++auto 1") | |
|
30 | self._auto=1 | |
|
31 | self.mode=1 | |
|
30 | 32 | self.write("++ver") |
|
31 | 33 | self.version=self.read() |
|
32 | self.write("++auto 1") | |
|
34 | ||
|
33 | 35 | |
|
34 | 36 | def set_as_device(self): |
|
35 | 37 | self.write("++mode 0") |
@@ -44,7 +46,10 class UsbGpib(object): | |||
|
44 | 46 | |
|
45 | 47 | @mode.setter |
|
46 | 48 | def mode(self,new_mode): |
|
49 | if type(new_mode) == type("str"): | |
|
47 | 50 | self._mode=self.revmodedic[new_mode] |
|
51 | elif type(new_mode) == type(1): | |
|
52 | self._mode=new_mode | |
|
48 | 53 | self.write("++mode %d" % self._mode) |
|
49 | 54 | |
|
50 | 55 | @property |
@@ -58,16 +63,26 class UsbGpib(object): | |||
|
58 | 63 | self.write("++addr %d" % self._address) |
|
59 | 64 | |
|
60 | 65 | def write(self,command): |
|
61 |
self._port.write( |
|
|
66 | self._port.write(("%s\n\r" % command).encode()) | |
|
62 | 67 | self._port.flush() |
|
63 | 68 | |
|
64 | 69 | |
|
65 |
def read(self,command="" |
|
|
70 | def read(self,command=""): | |
|
66 | 71 | if not command=="": |
|
67 | 72 | self.write(command) |
|
68 | if GPIB: | |
|
73 | if command[0:2]!="++" and self._auto==0: | |
|
69 | 74 | self.write("++read") |
|
70 | 75 | return self._port.readall() |
|
71 | 76 | |
|
72 | 77 | def idn(self): |
|
73 | 78 | return self.read("*IDN?") |
|
79 | ||
|
80 | @property | |
|
81 | def auto_read_after_write(self): | |
|
82 | self._auto=int(self.read("++auto")) | |
|
83 | return self._auto | |
|
84 | ||
|
85 | @auto_read_after_write.setter | |
|
86 | def auto_read_after_write(self,enabled): | |
|
87 | self._auto=enabled | |
|
88 | self.write("++auto %d" % self._auto) |
General Comments 0
You need to be logged in to leave comments.
Login now