def __init__(self, name, config, axes, encoders, shutters, switches): self.__name = name self.__config = StaticConfig(config) self.__initialized_axis = dict() self.__initialized_hw = Cache(self, "initialized", default_value=False) self.__lock = lock.Semaphore() self.__initialized_hw_axis = dict() self._axes = dict() self._encoders = dict() self._shutters = dict() self._switches = dict() self.__initialized_encoder = dict() self._tagged = dict() self.axis_settings = ControllerAxisSettings() for encoder_name, encoder_class, encoder_config in encoders: encoder = encoder_class(encoder_name, self, encoder_config) self._encoders[encoder_name] = encoder self.__initialized_encoder[encoder] = False for axis_name, axis_class, axis_config in axes: axis = axis_class(axis_name, self, axis_config) self._axes[axis_name] = axis axis_tags = axis_config.get('tags') if axis_tags: for tag in axis_tags.split(): self._tagged.setdefault(tag, []).append(axis) # For custom attributes and commands. # NB : AxisRef has no controller. if not isinstance(axis, AxisRef): set_custom_members(self, axis, axis.controller._initialize_axis) ## self.__initialized_axis[axis] = False self.__initialized_hw_axis[axis] = Cache(axis, "initialized", default_value=False) if axis_config.get("encoder"): encoder_name = axis_config.get("encoder") ENCODER_AXIS[encoder_name] = axis_name for obj_config_list, object_dict in ((shutters, self._shutters), (switches, self._switches)): for obj_name, obj_class, obj_config in obj_config_list: if obj_class is None: raise ValueError( "You have to specify a **class** for object named: %s" % obj_name) object_dict[obj_name] = obj_class(obj_name, self, obj_config)
def init_device(self): Device.init_device(self) config = { 'serial_url': self.SerialUrl, } self._linkam = linkam(self.Name, config) self._lock = lock.Semaphore() self._filename = "" self._profileData = [0.0, 0.0, 0.0] self._linkam.subscribe(self._profileCompleteCallback) if self._linkam is not None: attr = self.get_device_attr().get_attr_by_name("temperature") attr.set_write_value(self._linkam.getTemperature()) self.set_state(tango.DevState.ON)
def __init__(self, host, port, eol='\n', # end of line for each rx message timeout=5., # default timeout for read write ): self._log = logging.getLogger('Sock({0}:{1})'.format(host, port)) self._host = host self._port = port self._fd = None self._timeout = timeout self._connected = False self._eol = eol self._data = '' self._event = event.Event() self._raw_read_task = None self._lock = lock.Semaphore()
def __init__(self,url = None,pad = 0,sad = 0,timeout = 1.,tmo = 13, eot = 1,eos = '\n') : self._gpib_kwargs = { 'url' : url, 'pad' : pad, 'sad' : sad, 'tmo' : tmo, 'timeout' : timeout, 'eos' : eos} self._eos = eos self._timeout = timeout self._lock = lock.Semaphore() self._raw_handler = None self._logger = logging.getLogger(str(self)) self._debug = self._logger.debug self.gpib_type = self.ENET self._data = ""
def __init__(self,manager,table_id,type): self.id = table_id self.game = None self.table_type = type self.manager = manager self.players = {} self.dealer = -1 self.deal_counter = 0 self.deal_trigger = 0 self.restart_game() self.redis = manager.redis self.table_key = "table_" + str(manager.service.serviceId) + "_" + str(table_id) self.sender = TableEventSender(self) self.lock = lock.Semaphore() self.ready_time = 0 self.table_event_queue = Queue() gevent.spawn_later(1,self.real_send_event)
def __init__(self,service): self.service = service if service != None: self.redis = service.server.redis else: self.redis = None self.tables = {} self.room_id = service.serviceId self.session = Session() self.dal = DataAccess(self.redis) if self.redis != None: self.room_key = "room_users_" + str(self.room_id) self.redis.delete(self.room_key) self.redis.hset(self.room_key,"info","") keys = self.redis.keys("table_" + str(service.serviceId) + "*") for k in keys: self.redis.delete(k) self.lock = lock.Semaphore() gevent.spawn_later(5,self.scan_idle_player)
def __init__(self,node,*args,**kwargs) : self._serial = serial.Serial(*args,**kwargs) self.node = node self.lock = lock.Semaphore()
from gevent import subprocess, pywsgi, queue, socket, spawn, lock from gevent.subprocess import CalledProcessError from hashlib import sha512 from pathlib import Path from tempfile import mkstemp import json import os import subprocess import toml import requests PROFILES_TOML_PATH = '/var/lib/hpos-admin-api/hpos-admin-features.toml' app = Flask(__name__) rebuild_queue = queue.PriorityQueue() state_lock = lock.Semaphore() def rebuild_worker(): while True: (_, cmd) = rebuild_queue.get() rebuild_queue.queue.clear() subprocess.run(cmd) def rebuild(priority, args): rebuild_queue.put((priority, ['nixos-rebuild', 'switch'] + args)) def get_state_path(): hpos_config_file_symlink = os.getenv('HPOS_CONFIG_PATH')
def __init__(self, attempt_list_storage: TransactionAttemptListStorage) -> None: self._attempt_list_storage = attempt_list_storage self._lock = lock.Semaphore() self._locked_attempt_lists = [] # type: List[str]
def __init__(self, name, config): """ Linkam controller with either hot stage or dsc stage config_-- controller configuration, """ self.name = name self._logger = logging.getLogger(str(self)) logging.basicConfig(level=10) try: self._cnx = get_comm(config, SERIAL, baudrate=19200, eol='\r', timeout=10) except ValueError: if "serial_url" in config: warn( "'serial_url' keyword is deprecated. Use 'serial' instead", DeprecationWarning) comm_cfg = {'serial': {'url': config['serial_url']}} self._cnx = get_comm(comm_cfg, baudrate=19200, eol='\r', timeout=10) else: raise ValueError, "Must specify serial" #Possible values of the status byte self.STOPPED = 0x1 self.HEATING = 0x10 self.COOLING = 0x20 self.HOLDINGLIMIT = 0x30 self.HOLDINGTIME = 0x40 self.HOLDINGTEMP = 0x50 self.StatusToString = { self.STOPPED: "Stopped", self.HEATING: "Heating", self.COOLING: "Cooling", self.HOLDINGLIMIT: "Holding the limit time", self.HOLDINGTEMP: "Holding the current temperature", } # Linkam error codes self.LINKAM_COOLING_TOOFAST = 0x01 self.LINKAM_OPEN_CIRCUIT = 0x02 self.LINKAM_POWER_SURGE = 0x04 self.LINKAM_EXIT_300 = 0x08 self.LINKAM_LINK_ERROR = 0x20 self.LINKAM_OK = 0x80 self.ErrorToString = { self.LINKAM_COOLING_TOOFAST: "Cooling too fast", self.LINKAM_OPEN_CIRCUIT: "Stage not connected or sensor is open circuit", self.LINKAM_POWER_SURGE: "Current protection due to overload", self.LINKAM_EXIT_300: "No Exit (300 TS 1500 tried to exit profile at a temperature > 300 degrees)", self.LINKAM_LINK_ERROR: "Problems with RS-232 data transmission - RESET Linkam !", self.LINKAM_OK: "OK" } self._maximumTemp = config.get('max_temp', 1500.0) self._minimumTemp = config.get('min_temp', -196.0) self._model = config.get('model', "T95") self._profile_task = None self._lock = lock.Semaphore() self._hasDSC = self._hasDscStage() (self._state, self._errCode, _, _) = self._getStatus() self._temperature = self.getTemperature() self._limit = self._temperature self._rampNb = 1 self._rate = 10 self._holdTime = 1 self._dscSamplingRate = 0.3 self._statusString = None self._pumpSpeed = 0 self._dscValue = 0. self._startingRamp = 1 self._pollTime = 0.1 self._pipe = os.pipe() self._hold = True self._tstamp = 0 self._profileCompleteCallback = None self._profileData = [[]]
def __init__(self, name, config): """ FireFlash hardware controller. name -- the controller's name config -- controller configuration, in this dictionary we need to have: command_url -- url of the command port control_url -- url of the control port """ # Status bits for getStatus command self.StatusBits = {'IDLE': 0, 'BUSY': 1, 'REMOTE': 2, 'STREAMING': 4} # Status bits for Remote Data Toggle self.ToggleBits = {'OFF': 0, 'XFIT': 1, 'YFIT': 2, 'COG': 4} try: self.command_socket = get_comm(self.config['command'], ctype=TCP) except KeyError: command_url = config["command_url"] warn("'command_url' keyword is deprecated." \ " Use 'command: tcp' instead", DeprecationWarning) comm_cfg = {'tcp': {'url': command_url}} self.command_socket = get_comm(comm_cfg) try: self.control_socket = get_comm(self.config['control'], ctype=TCP) except KeyError: control_url = config["control_url"] warn("'control_url' keyword is deprecated." \ " Use 'control: tcp' instead", DeprecationWarning) comm_cfg = {'tcp': {'url': control_url}} self.control_socket = get_comm(comm_cfg) # Commands ready packed in network byte order self.commandReset = struct.pack(">H", 0xAA00) self.commandInterrupt = struct.pack(">H", 0xAA01) self.commandStatus = struct.pack(">H", 0xAA02) self.commandDataToggle = struct.pack(">H", 0xAA03) self.commandGetDeviceInfo = struct.pack(">H", 0xAA20) self.commandSetConfig = struct.pack(">H", 0xAA22) self.commandGetConfig = struct.pack(">H", 0xAA21) self.commandGetIntTime = struct.pack(">H", 0xAA23) self.commandSetIntTime = struct.pack(">H", 0xAA24) self.commandSetParams = struct.pack(">H", 0xAA26) self.commandGetParams = struct.pack(">H", 0xAA27) self.commandReadImage16 = struct.pack(">H", 0xAA30) self.commandReadImage8 = struct.pack(">H", 0xAA31) self.commandReadDark16 = struct.pack(">H", 0xAA32) self.commandAve16Sum32 = struct.pack(">H", 0xAA33) self.commandContinuous = struct.pack(">H", 0xAA37) self.commandStreamData = struct.pack(">H", 0xAA3A) self._errorCode2string = { self.NO_ERROR: "No Error", self.CODE1: "Error parsing .ini file", self.CODE2: "Could not establish network connection", self.CODE3: "Network data transfer failed", self.CODE4: "Incorrect FPGA type", self.CODE5: "Invalid argument or config param error", self.CODE6: "I^C-bus communication error", self.CODE7: "Memory initialization error", self.CODE8: "I^C-bus initialization error" } # Device Info structure keys self._deviceInfoKeys = [ 'ProcessorType', 'ProcessorVersion', 'FPGAType', 'FPGAVersion', 'BoardType', 'BoardVersion', 'BuidYear', 'BuildMonth', 'Buildday', 'BuildHour', 'BuildMinute', 'BuildSecond', 'SWMajor', 'SWMinor', 'SWbuild', 'FirmWare Major', 'FirmWareMinor', 'FirmWareBuild' ', BoardID' ] # Device configuration parameter keys self._deviceConfigKeys = [ 'Settings', 'Gain', 'Offset', 'LineIntTime', 'YEnd', 'FrameIntTime', 'YStart', 'XStart', 'XEnd', 'AdcPhase', 'SubtractDarkImage' ] #Image Descriptor keys self._imageDescriptorKeys = [ 'FrameNb', 'IntegrationTime', 'XSize', 'YSize', 'InternalPtr' ] self._quadConfigKeys = [ 'XCentre', 'YCentre', 'WinStartX', 'WinEndX', 'WinStartY', 'WinEndY' ] self._sensorConfigKeys = ['YSize', 'DarkImageSubtract'] #device parameter keys self._deviceParameterKeys = [ 'configurationKeys', 'DAC0Keys', 'DAC1Keys', 'DAC2keys', 'DAC3Keys', 'fitParameterKeys', 'verticalFitResultCriteria', 'horizontalFitResultCriteria' ] self._configurationKeys = [ 'Control', 'XStart', 'YStart', 'Width', 'Height', 'Gain', 'SensorFineOffset', 'SensorCourseOffset', 'IntegrationTime', 'ImageClock', 'AdcPhase', 'Orientation', 'RampInc' ] self._DAC0Keys = self._DAC1Keys = self._DAC2Keys = self._DAC3Keys = [ 'MinOutVoltage', 'MaxOutVoltage', 'MinDACCode', 'MaxDACCode', 'Action;' ] self._fitParameterKeys = [ 'MaxDeltaChiSq', 'Threshold', 'MaxIter', 'FilterSpan', 'FilterCtrl' ] self._fitResultCriteriaKeys = [ 'MaxWidth', 'MinWidth', 'MinRSQ', 'MinAmp', 'CalibCoeff', 'CalibOffset' ] self._logger = logging.getLogger("NanoBpmCtrl.NanoBpm") logging.basicConfig(level=logging.INFO) self._logger.setLevel(logging.DEBUG) self._controlWord = 0 self._nbFramesToSum = 8 self._thread = None self._lock = lock.Semaphore() self._remoteDataSelector = 0 self._frameNbAcquired = -1 self._actionByte = 0 self._imageDescriptor = None self._configurationParameters = None self._dac0Parameters = None self._dac1Parameters = None self._dac2Parameters = None self._dac3Parameters = None self._fitParameters = None self._vertFitResultParameters = None self._horFitResultParameters = None self._deviceInfo = self.getDeviceInfo() self._deviceConfig = self.getDeviceConfig() self._deviceParameters = self.getDeviceParameters() # This defines the quad window as the full Image - We do not use the Quad's ROI self._quadConfig = OrderedDict( zip(self._quadConfigKeys, ((self._deviceConfig['XEnd'] - self._deviceConfig['XStart']) / 2, (self._deviceConfig['YEnd'] - self._deviceConfig['YStart']) / 2, self._deviceConfig['XStart'], self._deviceConfig['XEnd'], self._deviceConfig['YStart'], self._deviceConfig['YEnd'])))
def __init__(self, *args, **kwargs): Controller.__init__(self, *args, **kwargs) self.socket_lock = lock.Semaphore()