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()
