def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, BWLimited): m = self.lib.ps3000_set_channel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange)) if m == 0: raise IOError('Error calling %s: parameter out of range' % (inspect.stack()[1][3]))
def __init__(self): try: if sys.platform == 'darwin': raise OSError self.__DCONDLL = ctypes.windll.LoadLibrary(os.getcwd() + '\DCON_PC.dll') self.__UARTDLL = ctypes.windll.LoadLibrary(os.getcwd() + '\Uart.dll') mode = 'Hardware driver .dll found' except OSError: self.__DCONDLL = USB87P4Simulator('DCON') self.__UARTDLL = USB87P4Simulator('UART') mode = 'OSError, enter simulation mode' except AttributeError: self.__DCONDLL = USB87P4Simulator('DCON') self.__UARTDLL = USB87P4Simulator('UART') mode = 'Hardware not present, enter simulation mode' print mode self.__dwBaudRate = ctypes.c_uint32(115200) self.__iAddress = ctypes.c_int16(2) self.__iSlot = ctypes.c_int16(-1) self.__iCheckSum = ctypes.c_int16(0) self.__iTimeOut = ctypes.c_int16(100) self.__cParity = ctypes.c_uint8(0) self.__cStop = ctypes.c_uint8(0) self.__cData = ctypes.c_uint8(8) self.__iAOTotalCh = ctypes.c_int16(4) # com port 7 as in TPS41 layout self.__cComPort = ctypes.c_uint8(7)
def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, BWLimited): m = self.lib.ps6000SetChannel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange), c_float(VOffset), c_enum(BWLimited)) self.checkResult(m)
def _lowLevelSetSimpleTrigger(self, enabled, trigsrc, threshold_adc, direction, delay, timeout_ms): m = self.lib.ps4000aSetSimpleTrigger( c_int16(self.handle), c_int16(enabled), c_enum(trigsrc), c_int16(threshold_adc), c_enum(direction), c_uint32(delay), c_int16(timeout_ms)) self.checkResult(m)
def getTimeBaseNum(self, sampleTimeS): """ps3000 doesn't seem to have published formula like other scopes.""" time_interval = c_int32() timebases = [None] * self.MAX_TIMEBASES # Convert to nS sampleTimenS = sampleTimeS * 1E9 tb = 0 while tb < self.MAX_TIMEBASES: rv = self.lib.ps3000_get_timebase( c_int16(self.handle), c_int16(tb), c_uint32(512), byref(time_interval), c_void_p(), c_int16(1), c_void_p()) if rv != 0: timebases[tb] = time_interval.value tb += 1 # Figure out closest option besterror = 1E99 bestindx = 0 for indx, val in enumerate(timebases): if val is not None: error = sampleTimenS - val if abs(error) < besterror: besterror = abs(error) bestindx = indx return bestindx
def getTimestepFromTimebase(self, timebase): time_interval = c_int32() m = self.lib.ps2000_get_timebase(c_int16(self.handle), c_int16(timebase), c_uint32(512), byref(time_interval), c_void_p(), c_int16(1), c_void_p()) self.checkResult(m) return (time_interval.value / 1.0E9)
def set_analog_channel(self, channel, reading_type, voltage_range, enabled): """ Enable a analog channel to specified settings """ if channel < self.max_channels + 1: self.logger.debug('Setting up channel %d' % channel) assert type(reading_type) is c_int16 assert type(voltage_range) is c_int16 # 0: dormant, <> 0: active c_enabled = c_int16(enabled) result = self.lib.HRDLSetAnalogInChannel(self.handle, c_int16(channel), c_enabled, voltage_range, reading_type) if not result: self.logger.error('Error setting up channel %d' % channel) self._get_settings_error() else: self.logger.error('Nonsense channel number %d' % channel) return
def set_current(self, k_val, board_ind=0): """ sets the k value (must be int between 0 and 255) """ board_ind = ctypes.c_int16(board_ind) k_val = ctypes.c_int16(k_val) self.cmd.send_command(6, (board_ind, k_val))
def set_accel(self, accel, board_ind=0): """ sets accel and decell to value specified """ board_ind = ctypes.c_int16(board_ind) accel = ctypes.c_int16(accel) self.cmd.send_command(5, (board_ind, accel))
def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, bandwidth): m = self.lib.ps5000aSetChannel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange), c_float(VOffset)) self.checkResult(m) # The error this might through are # INVALID_HANDLE # INVALID_CHANNEL # INVALID_BANDWIDTH # Invalid bandwidth is the only case that could go wrong. # The others would be thrown above (assuming no race condition: # i.e. unplugging the scope in between this call. # I decided to keep the logic below to avoid a possible error # picobase/SetChannel should be changed to the following # Set the channel # save the new channel settings # check if ps5000a # change the bandwidth separately # changing the bandwidth would be it's own function (implemented below) if bandwidth: m = self.lib.ps5000aSetBandwidthFilter(c_int16(self.handle), c_enum(chNum), c_enum(1)) else: m = self.lib.ps5000aSetBandwidthFilter(c_int16(self.handle), c_enum(chNum), c_enum(0)) self.checkResult(m)
def set_max_speed(self, max_sp, board_ind=0): """ sets the max speed to integer value specified """ board_ind = ctypes.c_int16(board_ind) max_sp = ctypes.c_int16(max_sp) self.cmd.send_command(4, (board_ind, max_sp))
def DVI(self, b, a): if a.value == 0: b.value = 0 b_signed = c_int16(b.value) a_signed = c_int16(a.value) b.value = b_signed.value / a_signed.value self.cpu.EX.value = ((b_signed.value << 16) / a.value) & 0xffff
def _lowLevelSetAWGSimpleDeltaPhase(self, waveform, deltaPhase, offsetVoltage, pkToPk, indexMode, shots, triggerType, triggerSource): """ waveform should be an array of shorts. """ waveformPtr = waveform.ctypes.data_as(POINTER(c_int16)) m = self.lib.ps6000SetSigGenArbitrary( c_int16(self.handle), c_uint32(int(offsetVoltage * 1E6)), # offset voltage in microvolts c_uint32(int(pkToPk * 1E6)), # pkToPk in microvolts c_uint32(int(deltaPhase)), # startDeltaPhase c_uint32(int(deltaPhase)), # stopDeltaPhase c_uint32(0), # deltaPhaseIncrement c_uint32(0), # dwellCount waveformPtr, # arbitraryWaveform c_int32(len(waveform)), # arbitraryWaveformSize c_enum(0), # sweepType for deltaPhase c_enum(0), # operation (adding random noise and whatnot) c_enum(indexMode), # single, dual, quad c_uint32(shots), c_uint32(0), # sweeps c_uint32(triggerType), c_uint32(triggerSource), c_int16(0)) # extInThreshold self.checkResult(m)
def get_rotation(self): raw_data = self.__bus.read_i2c_block_data(self.__dev_id, C.MPU6050_RA_GYRO_XOUT_H, 6) gyro = [0] * 3 gyro[0] = ctypes.c_int16(raw_data[0] << 8 | raw_data[1]).value gyro[1] = ctypes.c_int16(raw_data[2] << 8 | raw_data[3]).value gyro[2] = ctypes.c_int16(raw_data[4] << 8 | raw_data[5]).value return gyro
def getTimestepFromTimebase(self, timebase): time_interval = c_int32() m = self.lib.ps3000_get_timebase(c_int16(self.handle), c_int16(timebase), c_uint32(512), byref(time_interval), c_void_p(), c_int16(1), c_void_p()) if m == 0: raise IOError('Error calling %s: invalid parameters given' % (inspect.stack()[1][3])) return (time_interval.value / 1.0E9)
def set_microstepping(self, ms, board_ind=0): """ sets the microstepping value int power i.e 7 = 2^7 """ board_ind = ctypes.c_int16(board_ind) ms = ctypes.c_int16(ms) self.cmd.send_command(7, (board_ind, ms))
def rotate(self, direction, sps, board_ind=0): """ rotates the motor in the direction of dir at sps steps per second """ board_ind = ctypes.c_int16(board_ind) direction = ctypes.c_int16(direction) sps = ctypes.c_int16(sps) self.cmd.send_command(11, (board_ind, direction, sps))
def move_steps(self, direction, steps, board_ind=0): """ moves number of steps in the direction specified """ board_ind = ctypes.c_int16(board_ind) direction = ctypes.c_int16(direction) steps = ctypes.c_int16(steps) self.cmd.send_command(12, (board_ind, direction, steps))
def get_acceleration(self): raw_data = self.__bus.read_i2c_block_data(self.__dev_id, C.MPU6050_RA_ACCEL_XOUT_H, 6) accel = [0] * 3 accel[0] = ctypes.c_int16(raw_data[0] << 8 | raw_data[1]).value accel[1] = ctypes.c_int16(raw_data[2] << 8 | raw_data[3]).value accel[2] = ctypes.c_int16(raw_data[4] << 8 | raw_data[5]).value return accel
def _lowLevelIsReady(self): ready = c_int16() m = self.lib.ps4000aIsReady(c_int16(self.handle), byref(ready)) self.checkResult(m) if ready.value: return True else: return False
def rect(self, i): left = c_int16() right = c_int16() top = c_int16() bottom = c_int16() self._rect(self, i, ctypes.byref(left), ctypes.byref(right), ctypes.byref(top), ctypes.byref(bottom)) return (left.value, right.value, top.value, bottom.value)
def _lowLevelIsReady(self): ready = c_int16() ready = self.lib.ps3000_ready(c_int16(self.handle)) if ready > 0: return True elif ready == 0: return False else: raise IOError("ps3000_ready returned %d" % ready.value)
def _lowLevelSetSimpleTrigger(self, enabled, trigsrc, threshold_adc, direction, delay, timeout_ms): # TODO: Fix 'auto' which is where trigger occurs in block. # Delay is not used m = self.lib.ps3000_set_trigger( c_int16(self.handle), c_enum(trigsrc), c_int16(threshold_adc), c_enum(direction), c_int16(delay), c_int16(timeout_ms)) self.checkResult(m)
def _lowLevelGetUnitInfo(self, info): s = create_string_buffer(256) m = self.lib.ps3000_get_unit_info( c_int16(self.handle), byref(s), c_int16(len(s)), c_enum(info)) self.checkResult(m) # should this bee ascii instead? # I think they are equivalent... return s.value.decode('utf-8')
def _lowLevelRunBlock(self, numPreTrigSamples, numPostTrigSamples, timebase, oversample, segmentIndex): timeIndisposedMs = c_int32() m = self.lib.ps6000RunBlock( c_int16(self.handle), c_uint32(numPreTrigSamples), c_uint32(numPostTrigSamples), c_uint32(timebase), c_int16(oversample), byref(timeIndisposedMs), c_uint32(segmentIndex), c_void_p(), c_void_p()) self.checkResult(m) return timeIndisposedMs.value
def _lowLevelGetUnitInfo(self, info): s = create_string_buffer(256) m = self.lib.ps3000_get_unit_info(c_int16(self.handle), byref(s), c_int16(len(s)), c_enum(info)) if m == 0: raise IOError('Error calling %s: parameter out of range' % (inspect.stack()[1][3])) else: print('%d bytes returned' % (m)) # should this be ascii instead? # I think they are equivalent... return s.value.decode('utf-8')
def _lowLevelSetSigGenBuiltInSimple(self, offsetVoltage, pkToPk, waveType, frequency, shots, triggerType, triggerSource): m = self.lib.ps2000_set_sig_gen_built_in( c_int16(self.handle), c_int32(int(offsetVoltage * 1000000)), c_int32(int(pkToPk * 1000000)), c_int16(waveType), c_float(frequency), c_float(frequency), c_float(0), c_float(0), c_enum(0), c_uint32(0)) self.checkResult(m)
def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, BWLimited): m = self.lib.ps5000aSetChannel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange), c_float(VOffset)) self.checkResult(m) if BWLimited: m = self.lib.ps5000aSetBandwidthFilter(c_int16(self.handle), c_enum(chNum), c_enum(1)) else: m = self.lib.ps5000aSetBandwidthFilter(c_int16(self.handle), c_enum(chNum), c_enum(0)) self.checkResult(m)
def _lowLevelOpenUnitProgress(self): complete = c_int16() progressPercent = c_int16() handle = c_int16() m = self.lib.ps4000OpenUnitProgress(byref(handle), byref(progressPercent), byref(complete)) self.checkResult(m) # if we only wanted to return one value, we could do somethign like # progressPercent = progressPercent * (1 - 0.1 * complete) return (progressPercent, complete)
def _lowLevelGetValues(self, numSamples, startIndex, downSampleRatio, downSampleMode, segmentIndex): numSamplesReturned = c_uint32() numSamplesReturned.value = numSamples overflow = c_int16() m = self.lib.ps4000aGetValues( c_int16(self.handle), c_uint32(startIndex), byref(numSamplesReturned), c_uint32(downSampleRatio), c_enum(downSampleMode), c_uint16(segmentIndex), byref(overflow)) self.checkResult(m) return (numSamplesReturned.value, overflow.value)
def _lowLevelChangePowerSource(self, powerstate): m = self.lib.ps3000aChangePowerSource( c_int16(self.handle), c_enum(powerstate)) self.checkResult(m)
def read_segment(self, import_neuroshare_segment=True, lazy=False): """ Arguments: import_neuroshare_segment: import neuroshare segment as SpikeTrain with associated waveforms or not imported at all. """ assert not lazy, 'Do not support lazy' seg = Segment(file_origin=os.path.basename(self.filename), ) if sys.platform.startswith('win'): neuroshare = ctypes.windll.LoadLibrary(self.dllname) elif sys.platform.startswith('linux'): neuroshare = ctypes.cdll.LoadLibrary(self.dllname) neuroshare = DllWithError(neuroshare) # elif sys.platform.startswith('darwin'): # API version info = ns_LIBRARYINFO() neuroshare.ns_GetLibraryInfo(ctypes.byref(info), ctypes.sizeof(info)) seg.annotate(neuroshare_version=str(info.dwAPIVersionMaj) + '.' + str(info.dwAPIVersionMin)) # open file hFile = ctypes.c_uint32(0) neuroshare.ns_OpenFile(ctypes.c_char_p(self.filename), ctypes.byref(hFile)) fileinfo = ns_FILEINFO() neuroshare.ns_GetFileInfo(hFile, ctypes.byref(fileinfo), ctypes.sizeof(fileinfo)) # read all entities for dwEntityID in range(fileinfo.dwEntityCount): entityInfo = ns_ENTITYINFO() neuroshare.ns_GetEntityInfo(hFile, dwEntityID, ctypes.byref(entityInfo), ctypes.sizeof(entityInfo)) # EVENT if entity_types[entityInfo.dwEntityType] == 'ns_ENTITY_EVENT': pEventInfo = ns_EVENTINFO() neuroshare.ns_GetEventInfo(hFile, dwEntityID, ctypes.byref(pEventInfo), ctypes.sizeof(pEventInfo)) if pEventInfo.dwEventType == 0: # TEXT pData = ctypes.create_string_buffer( pEventInfo.dwMaxDataLength) elif pEventInfo.dwEventType == 1: # CVS pData = ctypes.create_string_buffer( pEventInfo.dwMaxDataLength) elif pEventInfo.dwEventType == 2: # 8bit pData = ctypes.c_byte(0) elif pEventInfo.dwEventType == 3: # 16bit pData = ctypes.c_int16(0) elif pEventInfo.dwEventType == 4: # 32bit pData = ctypes.c_int32(0) pdTimeStamp = ctypes.c_double(0.) pdwDataRetSize = ctypes.c_uint32(0) ea = Event(name=str(entityInfo.szEntityLabel), ) times = [] labels = [] for dwIndex in range(entityInfo.dwItemCount): neuroshare.ns_GetEventData(hFile, dwEntityID, dwIndex, ctypes.byref(pdTimeStamp), ctypes.byref(pData), ctypes.sizeof(pData), ctypes.byref(pdwDataRetSize)) times.append(pdTimeStamp.value) labels.append(str(pData.value)) ea.times = times * pq.s ea.labels = np.array(labels, dtype='S') seg.events.append(ea) # analog if entity_types[entityInfo.dwEntityType] == 'ns_ENTITY_ANALOG': pAnalogInfo = ns_ANALOGINFO() neuroshare.ns_GetAnalogInfo(hFile, dwEntityID, ctypes.byref(pAnalogInfo), ctypes.sizeof(pAnalogInfo)) dwIndexCount = entityInfo.dwItemCount pdwContCount = ctypes.c_uint32(0) pData = np.zeros((entityInfo.dwItemCount, ), dtype='float64') total_read = 0 while total_read < entityInfo.dwItemCount: dwStartIndex = ctypes.c_uint32(total_read) dwStopIndex = ctypes.c_uint32(entityInfo.dwItemCount - total_read) neuroshare.ns_GetAnalogData( hFile, dwEntityID, dwStartIndex, dwStopIndex, ctypes.byref(pdwContCount), pData[total_read:].ctypes.data_as( ctypes.POINTER(ctypes.c_double))) total_read += pdwContCount.value signal = pq.Quantity(pData, units=pAnalogInfo.szUnits, copy=False) # t_start dwIndex = 0 pdTime = ctypes.c_double(0) neuroshare.ns_GetTimeByIndex(hFile, dwEntityID, dwIndex, ctypes.byref(pdTime)) anaSig = AnalogSignal( signal, sampling_rate=pAnalogInfo.dSampleRate * pq.Hz, t_start=pdTime.value * pq.s, name=str(entityInfo.szEntityLabel), ) anaSig.annotate(probe_info=str(pAnalogInfo.szProbeInfo)) seg.analogsignals.append(anaSig) # segment if entity_types[ entityInfo. dwEntityType] == 'ns_ENTITY_SEGMENT' and import_neuroshare_segment: pdwSegmentInfo = ns_SEGMENTINFO() if not str(entityInfo.szEntityLabel).startswith('spks'): continue neuroshare.ns_GetSegmentInfo(hFile, dwEntityID, ctypes.byref(pdwSegmentInfo), ctypes.sizeof(pdwSegmentInfo)) nsource = pdwSegmentInfo.dwSourceCount pszMsgBuffer = ctypes.create_string_buffer(" " * 256) neuroshare.ns_GetLastErrorMsg(ctypes.byref(pszMsgBuffer), 256) for dwSourceID in range(pdwSegmentInfo.dwSourceCount): pSourceInfo = ns_SEGSOURCEINFO() neuroshare.ns_GetSegmentSourceInfo( hFile, dwEntityID, dwSourceID, ctypes.byref(pSourceInfo), ctypes.sizeof(pSourceInfo)) pdTimeStamp = ctypes.c_double(0.) dwDataBufferSize = pdwSegmentInfo.dwMaxSampleCount * pdwSegmentInfo.dwSourceCount pData = np.zeros((dwDataBufferSize), dtype='float64') pdwSampleCount = ctypes.c_uint32(0) pdwUnitID = ctypes.c_uint32(0) nsample = int(dwDataBufferSize) times = np.empty((entityInfo.dwItemCount), dtype='f') waveforms = np.empty( (entityInfo.dwItemCount, nsource, nsample), dtype='f') for dwIndex in range(entityInfo.dwItemCount): neuroshare.ns_GetSegmentData( hFile, dwEntityID, dwIndex, ctypes.byref(pdTimeStamp), pData.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), dwDataBufferSize * 8, ctypes.byref(pdwSampleCount), ctypes.byref(pdwUnitID)) times[dwIndex] = pdTimeStamp.value waveforms[dwIndex, :, :] = pData[:nsample * nsource].reshape( nsample, nsource).transpose() sptr = SpikeTrain( times=pq.Quantity(times, units='s', copy=False), t_stop=times.max(), waveforms=pq.Quantity(waveforms, units=str(pdwSegmentInfo.szUnits), copy=False), left_sweep=nsample / 2. / float(pdwSegmentInfo.dSampleRate) * pq.s, sampling_rate=float(pdwSegmentInfo.dSampleRate) * pq.Hz, name=str(entityInfo.szEntityLabel), ) seg.spiketrains.append(sptr) # neuralevent if entity_types[ entityInfo.dwEntityType] == 'ns_ENTITY_NEURALEVENT': pNeuralInfo = ns_NEURALINFO() neuroshare.ns_GetNeuralInfo(hFile, dwEntityID, ctypes.byref(pNeuralInfo), ctypes.sizeof(pNeuralInfo)) pData = np.zeros((entityInfo.dwItemCount, ), dtype='float64') dwStartIndex = 0 dwIndexCount = entityInfo.dwItemCount neuroshare.ns_GetNeuralData( hFile, dwEntityID, dwStartIndex, dwIndexCount, pData.ctypes.data_as(ctypes.POINTER(ctypes.c_double))) times = pData * pq.s t_stop = times.max() sptr = SpikeTrain( times, t_stop=t_stop, name=str(entityInfo.szEntityLabel), ) seg.spiketrains.append(sptr) # close neuroshare.ns_CloseFile(hFile) seg.create_many_to_one_relationship() return seg
def _lowLevelClearDataBuffers(self, channel): m = self.lib.ps6000SetDataBuffers(c_int16(self.handle), c_enum(channel), c_void_p(), c_void_p(), c_uint32(0), c_enum(0)) self.checkResult(m)
def release_card(self): releaseErr = ctypes.c_int16(self.dll.Release_Card(self.card_id)) if releaseErr.value != 0: self.log(message="Release_Card: Non-zero status code:" + str(releaseErr.value)) return
def _lowLevelClearDataBuffer(self, channel, segmentIndex): """Clear the data in the picoscope.""" m = self.lib.ps2000aSetDataBuffer( c_int16(self.handle), c_enum(channel), c_void_p(), c_uint32(0), c_uint32(segmentIndex), c_enum(0)) self.checkResult(m)
def awaitCaptureComplete(self): ready = ctypes.c_int16(0) check = ctypes.c_int16(0) while ready.value == check.value: self.status["isReady"] = ps.ps5000aIsReady(self.chandle, ctypes.byref(ready))
import numpy as np from picosdk.usbtc08 import usbtc08 as tc08 from picosdk.functions import assert_pico2000_ok import sys from time import sleep import time import datetime #from pylab import * filename = sys.argv[1] # Create chandle and status ready for use chandle = ctypes.c_int16() status = {} # open unit status["open_unit"] = tc08.usb_tc08_open_unit() assert_pico2000_ok(status["open_unit"]) chandle = status["open_unit"] # set mains rejection to 50 Hz status["set_mains"] = tc08.usb_tc08_set_mains(chandle, 0) assert_pico2000_ok(status["set_mains"]) # set up channel # therocouples types and int8 equivalent # B=66 , E=69 , J=74 , K=75 , N=78 , R=82 , S=83 , T=84 , ' '=32 , X=88 f = open(filename, "w+")
def _lowLevelClearDataBuffer(self, channel, segmentIndex): """data should be a numpy array.""" m = self.lib.ps4000SetDataBuffer(c_int16(self.handle), c_enum(channel), c_void_p(), c_uint32(0), c_enum(0)) self.checkResult(m)
preTriggerFraction = 0.3 samples = int(1E6) # samples = preTriggerSamples + postTriggerSamples preTriggerSamples = int(samples * preTriggerFraction) postTriggerSamples = samples - preTriggerSamples # First, we are going to create the folder if it isn't there already # The external drive folder mydir = "/mnt/extdrive" mydir = os.path.join(mydir, datetime.now().strftime('%Y-%m-%d')) #mydir = os.path.join( os.getcwd(), datetime.now().strftime('%Y-%m-%d')) if not os.path.isdir(mydir): os.makedirs(mydir) # Create handle and status ready for use status = {} handle = ctypes.c_int16() # Actually c-handle # Opens the device status["openunit"] = ps.ps2000aOpenUnit(ctypes.byref(handle), None) try: assert_pico_ok(status["openunit"]) except: # powerstate becomes the status number of openunit powerstate = status["openunit"] # If powerstate is the same as 282 then it will run this if statement if powerstate == 282: # Changes the power input to "PICO_POWER_SUPPLY_NOT_CONNECTED" status["ChangePowerSource"] = ps.ps2000aChangePowerSource(handle, 282)
def _lowLevelStop(self): m = self.lib.ps3000aStop(c_int16(self.handle)) self.checkResult(m)
def _lowLevelCloseUnit(self): m = self.lib.ps3000aCloseUnit(c_int16(self.handle)) self.checkResult(m)
def _lowLevelFlashLed(self, times): m = self.lib.ps3000aFlashLed(c_int16(self.handle), c_int16(times)) self.checkResult(m)
def _lowLevelSetNoOfCaptures(self, numCaptures): m = self.lib.ps3000aSetNoOfCaptures(c_int16(self.handle), c_uint16(numCaptures)) self.checkResult(m)
def _lowLevelSigGenSoftwareControl(self, triggerType): m = self.lib.ps3000aSigGenSoftwareControl( c_int16(self.handle), c_enum(triggerType)) self.checkResult(m)
def maximum_value(self, device): if not hasattr(self, '_maximum_value'): return (2**15) - 1 max_adc = c_int16(0) self._maximum_value(c_int16(device.handle), byref(max_adc)) return max_adc.value
def state(self, val=None): if val == None: return Inp32(ctypes.c_int16(self.port)) else: Out32(ctypes.c_int16(self.port), ctypes.c_int16(val))
def _python_close_unit(self, handle): return self._close_unit(c_int16(handle))
# # PicoScope 5000 (A API) Signal Generator Example # This example demonstrates how to use the PicoScope 5000 Series (ps5000a) driver API functions to set up the signal generator to do the following: # # 1. Output a sine wave # 2. Output a square wave # 3. Output a sweep of a square wave signal import ctypes from picosdk.ps5000a import ps5000a as ps import time from picosdk.functions import assert_pico_ok status = {} chandle = ctypes.c_int16() # Open the device status["openUnit"] = ps.ps5000aOpenUnit(ctypes.byref(chandle), None, 1) try: assert_pico_ok(status["openUnit"]) except: # PicoNotOkError: powerStatus = status["openUnit"] if powerStatus == 286: status["changePowerSource"] = ps.ps5000aChangePowerSource(chandle, powerStatus) elif powerStatus == 282: status["changePowerSource"] = ps.ps5000aChangePowerSource(chandle, powerStatus)
def _lowLevelFlashLed(self, times): m = self.lib.ps2000_flash_led(c_int16(self.handle)) self.checkResult(m)
def getAccelZ(self): data = ctypes.c_int16(self.bus.read_word_data( MPU60X0.ACCEL_ZOUT)).value return data / self.accel_scale
def __new__(cls, val): val = ctypes.c_int16(val).value return super().__new__(cls, val)
def getTemp(self): data = ctypes.c_int16(self.bus.read_word_data(MPU60X0.TEMP_OUT)).value return data / self.temp_scale + self.temp_offset
def asynchronous_double_buffered_analog_input_read(self, sample_freq, sample_count, card_buffer_size=500000, verbose=False, channel=0): ''' Non-Triggered Double-Buffered Asynchronous Analog Input Continuous Read Steps: [Adlink PCIS-DASK manual,page 47] 1. AI_XXXX_Config Configure the card for the asynchronous mode 2. AI_AsyncDblBufferMode Enable double buffered mode 3. AI_ContReadChannel Read from a single channel (=0) 4. while not stop: 4.1 if (AI_AsyncDblBufferHaldReady): #Check if buffer is half full] 4.1.1 AI_AsyncDblBufferTransfer #Transfer data from card buffer into user buffer 5. AI_AsyncClear 6. Convert all data to volts and return ''' #AI_AsyncDblBufferMode - initialize Double Buffer Mode buffModeErr = ctypes.c_int16( self.dll.AI_AsyncDblBufferMode(c_ushort(self.card_id), ctypes.c_bool(1))) if verbose or buffModeErr.value != 0: self.log(message="AI_AsyncDblBufferMode: Non-zero status code" + str(buffModeErr.value)) #card buffer cardBuffer = (c_ushort * card_buffer_size)() #user buffers user_buffer_size = old_div( card_buffer_size, 2) #half due to being full when buffer is read nbuff = int(math.ceil(sample_count / float(user_buffer_size))) # uBs = [(c_double*user_buffer_size)()]*nbuff uBs = [] print(uBs) # oBs = [(c_double*user_buffer_size)()]*nbuff oBs = [] if verbose: self.log(message="Number of user buffers:" + str(nbuff)) #AI_ContReadChanne readErr = ctypes.c_int16( self.dll.AI_ContReadChannel( c_ushort(self.card_id), #CardNumber c_ushort(channel), #Channel c_ushort(adlink9812_constants.AD_B_1_V), #AdRange cardBuffer, #Buffer c_uint32(card_buffer_size), #ReadCount c_double(sample_freq), #SampleRate (Hz) c_ushort( adlink9812_constants.ASYNCH_OP) #SyncMode - Asynchronous )) if verbose or readErr.value != 0: self.log(message="AI_ContReadChannel: Non-zero status code" + str(readErr.value)) #AI_AsyncDblBufferHalfReader #I16 AI_AsyncDblBufferHalfReady (U16 CardNumber, BOOLEAN *HalfReady,BOOLEAN *StopFlag) for i in range(nbuff): currentBuffer = (c_double * user_buffer_size)() halfReady = c_bool(0) stopFlag = c_bool(0) while halfReady.value != True: buffReadyErr = ctypes.c_int16( self.dll.AI_AsyncDblBufferHalfReady( c_ushort(self.card_id), ctypes.byref(halfReady), ctypes.byref(stopFlag))) if buffReadyErr.value != 0: self.log(message="buffReadErr:" + str(buffReadyErr.value)) self.log(message="HalfReady:" + str(halfReady.value)) #AI_AsyncDblBufferTransfer #I16 AI_AsyncDblBufferTransfer (U16 CardNumber, U16 *Buffer) buffTransferErr = ctypes.c_int16( self.dll.AI_AsyncDblBufferTransfer(c_ushort( self.card_id), ctypes.byref(currentBuffer))) uBs.append(currentBuffer) if buffTransferErr.value != 0: self.log(message="buffTransferErr:" + str(buffTransferErr.value)) accessCnt = ctypes.c_int32(0) clearErr = ctypes.c_int16( self.dll.AI_AsyncClear(self.card_id, ctypes.byref(accessCnt))) if verbose: self.log(message="AI_AsyncClear,AccessCnt:" + str(accessCnt.value)) #concatenate user buffer onto existing numpy array #reinitialize user buffer for i in range(nbuff): oB = (c_double * user_buffer_size)() convertErr = ctypes.c_int16( self.dll.AI_ContVScale( c_ushort(self.card_id), #CardNumber c_ushort(adlink9812_constants.AD_B_1_V), #AdRange uBs[i], #DataBuffer - array storing raw 16bit A/D values oB, #VoltageArray - reference to array storing voltages c_uint32( user_buffer_size ) #Sample count - number of samples to be converted )) oBs.append(oB) if convertErr.value != 0: self.log(message="AI_ContVScale: Non-zero status code:" + str(convertErr.value)) return np.concatenate(oBs)
def process_qmsg(self, msg): m_type = ctypes.c_int16(msg.type() & 0xffff).value # lower 16 bits of msg.type() is signed message type m_slot = int(msg.arg1()) & 0x1 # message slot id m_ts = float(msg.arg2()) # message sender timestamp m_buf = msg.to_string() # message data if m_type == -1: # Sync Timeout if self.debug >= 9: sys.stderr.write("%s [%d] Timeout waiting for sync sequence\n" % (log_ts.get(), self.msgq_id)) if self.msgq_id == 0: # primary/control channel self.cc_timeouts += 1 if self.cc_timeouts >= CC_HUNT_TIMEOUTS: self.cc_timeouts = 0 self.current_state = self.states.IDLE self.tune_next_chan() return else: # secondary/voice channel pass elif m_type >= 0: # Receiving a PDU means sync must be present if self.msgq_id == 0: self.cc_timeouts = 0 # If voice channel not identified, begin LCN search if (self.msgq_id > 0) and (self.current_state == self.states.SRCH) and (self.tune_time + VC_SRCH_TIME < time.time()): self.tune_next_chan() # log received message if self.debug >= 10: d_buf = "0x" for byte in m_buf: d_buf += format(get_ordinals(byte),"02x") sys.stderr.write("%s [%d] DMR PDU: lcn(%d), state(%d), type(%d), slot(%d), data(%s)\n" % (log_ts.get(), self.msgq_id, self.chan_list[self.current_chan], self.current_state, m_type, m_slot, d_buf)) if m_type == 0: # CACH SLC self.rx_CACH_SLC(m_buf) elif m_type == 1: # CACH CSBK pass elif m_type == 2: # SLOT PI self.rx_SLOT_PI(m_slot, m_buf) elif m_type == 3: # SLOT VLC self.rx_SLOT_VLC(m_slot, m_buf) elif m_type == 4: # SLOT TLC self.rx_SLOT_TLC(m_slot, m_buf) elif m_type == 5: # SLOT CSBK self.rx_SLOT_CSBK(m_slot, m_buf) elif m_type == 6: # SLOT MBC pass elif m_type == 7: # SLOT ELC self.rx_SLOT_ELC(m_slot, m_buf) elif m_type == 8: # SLOT ERC pass elif m_type == 9: # SLOT ESB pass else: # Unknown Message return # If this is Capacity Plus, try to keep the first receiver tuned to a control channel if (self.current_type == 1) and (self.msgq_id == 0) and (self.current_state > self.states.CC): if self.debug >= 1: sys.stderr.write("%s [%d] Looking for control channel\n" % (log_ts.get(), self.msgq_id)) self.cc_timeouts = 0 self.current_state = self.states.IDLE self.tune_next_chan()
MOT_LimitSwitchMakeOnHomeSwapped = c_word(0x84) MOT_LimitSwitchBreakOnHomeSwapped = c_word(0x85) MOT_LimitSwitchModes = c_word # enum MOT_LimitSwitchSWModes MOT_LimitSwitchSWModeUndefined = c_word(0x00) MOT_LimitSwitchIgnored = c_word(0x01) MOT_LimitSwitchStopImmediate = c_word(0x02) MOT_LimitSwitchStopProfiled = c_word(0x03) MOT_LimitSwitchIgnored_Rotational = c_word(0x81) MOT_LimitSwitchStopImmediate_Rotational = c_word(0x82) MOT_LimitSwitchStopProfiled_Rotational = c_word(0x83) MOT_LimitSwitchSWModes = c_word # enum MOT_LimitsSoftwareApproachPolicy DisallowIllegalMoves = c_int16(0) AllowPartialMoves = c_int16(1) AllowAllMoves = c_int16(2) MOT_LimitsSoftwareApproachPolicy = c_int16 # enum MOT_PID_LoopMode MOT_PIDLoopModeDisabled = c_word(0x00) MOT_PIDOpenLoopMode = c_word(0x01) MOT_PIDClosedLoopMode = c_word(0x02) MOT_PID_LoopMode = c_word # enum MOT_MovementModes LinearRange = c_int(0x00) RotationalUnlimited = c_int(0x01) RotationalWrapping = c_int(0x02) MOT_MovementModes = c_int
message = create_string_buffer(1024) tlPM.getCalibrationMsg(message) print(c_char_p(message.raw).value) time.sleep(0.5) power_measurements = [] times = [] count = 0 powers = (c_double * 20)() timestamps = (c_uint16 * 20)() flag = c_uint16(1) wavelength = c_double(470) print(wavelength.value) print(tlPM.setWavelength(wavelength)) print(tlPM.getWavelength(c_int16(0), byref(wavelength))) print(wavelength.value) print(tlPM.setArrMeasurement(flag)) print(tlPM.getArrMeasurement(byref(flag))) print(flag) count = c_uint16(20) #interval = c_uint16(10000) print(count.value) tlPM.getPowerArrayMeasurement(byref(count), byref(timestamps), byref(powers)) #tlPM.getPowerMeasurementSequence(count,interval,powers) print(count.value) for i in range(20): print(timestamps[i], powers[i]) #print(powers.value) tlPM.close()
def _lowLevelSetNoOfCaptures(self, nCaptures): m = self.lib.ps6000SetNoOfCaptures(c_int16(self.handle), c_uint32(nCaptures)) self.checkResult(m)
def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, BWLimited): m = self.lib.ps3000_set_channel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange)) self.checkResult(m)
def _lowlevelPingUnit(self): m = self.lib.ps3000aPingUnit(c_int16(self.handle)) return m
def _lowLevelGetMaxSegments(self): maxSegments = c_int16() m = self.lib.ps3000aGetMaxSegments(c_int16(self.handle), byref(maxSegments)) self.checkResult(m) return maxSegments.value