Commands/Validators.py - master - zinskiy09/Align3.0

Commands/Validators.py
361 строка10 KB
Sasha
add project files
17 сен 2025, 06:48
17 сен 2025, 06:48323d13e
from Configurator import Config
from tango import DeviceProxy, Except

config = Config.Configuration()
platforms = config.get_platform_axes()
platform_ax_conversion = {}

for platform in platforms:
    platform_servers = config.get_server_by_axes(platform)
    platform_ax_conversion[platform] = float(
        DeviceProxy(platform_servers).get_property(['Conversion'])['Conversion'][0])

info = config.get_info('PM2100')['slots']
meas_servers = config.get_servers('MeasuringInstruments')['PM2100']
ax_servers = {}
for ax in platforms:
    ax_servers[ax] = config.get_server_by_axes(ax)

DICT_PMS = {}
for key, values in info.items():
    for value in values:
        DICT_PMS[value] = key

PMS_SERVERS = {}
for server in meas_servers:
    slot = server.split('/')[1]
    PMS_SERVERS[slot] = server

VALID_PMS = {val for value in info.values() for val in value}
VALID_CHANNELS = {1, 2, 3, 4, '1', '2', '3', '4'}

alignments_servers = config.get_servers('Alignments')
ALIGNMENTS = {}
for name, value in alignments_servers.items():
    ALIGNMENTS[name] = DeviceProxy(value[0]) if isinstance(value[0], str) else None


def is_number(value):
    if isinstance(value, bool):
        return False
    if isinstance(value, (int, float)):
        return True
    if isinstance(value, str):
        try:
            float(value)
            return True
        except (ValueError, TypeError):
            return False
    return False


def is_bool(value):
    if isinstance(value, bool):
        return True
    if isinstance(value, str):
        val = value.strip().lower()
        return val in ('true', 'false')

    return False


def is_speed(value):
    if is_number(value):
        if int(value) in {1, 2, 3, 4, 5, 6, 7, 8, 9}:
            return True
    return False


def endpow(value):
    if is_number(value):
        if int(value) > 15 or int(value) < -110:
            return False
        return True


def valid_step_value(axis, value):
    if (abs(float(value)) < platform_ax_conversion[axis.split('*')[0]]):
        raise Except.throw_exception('RelativeMove', 'Низкое значение шага оси {}'.format(axis),
                                     'SystemDevice.RelativeMove()')


def valid_dist_value(step, dist, axis):
    if abs(float(dist)) < abs(float(step)) * 2:
        Except.throw_exception('RelativeMove', 'Низкое значение расстояния оси {}'.format(axis),
                               'SystemDevice.RelativeMove()')


def trg_validate(axis):
    if axis not in ['L_Y', 'L_Z', 'R_Y', 'R_Z', 'A_Y', 'A_Z', 'N_Y', 'N_Z', 'S_Y', 'S_Z']:
        Except.throw_exception('RelativeMove', 'Ось {} не может быть использована в режиме триггера'.format(axis),
                               'SystemDevice.RelativeMove()')


def axes_validate(axes):
    ax_set = set(axes)
    if len(ax_set) != len(axes):
        Except.throw_exception('RelativeMove', 'Названия осей совпадают', 'SystemDevice.RelativeMove()')


def check_axis_shift(axis):
    shift = False
    if '*' in axis:
        axis = axis.split('*')[0]
        shift = True
    return axis, shift


def meter_validator(meter):
    if isinstance(meter, dict):
        for slot in meter['meter']:
            if slot[0] not in VALID_PMS:
                return False
        return True
    elif isinstance(meter, str):
        if meter in VALID_PMS:
            return True
    else:
        return False


def channels_validator(channels):
    if isinstance(channels, dict):
        for group in channels['channels']:  # [[1]][[2]][[3]][[4]]
            valid_channels = VALID_CHANNELS.copy()
            for channel in group:  # 1, 2, 3, 4
                if channel in valid_channels:
                    valid_channels.discard(channel)
                else:
                    return False
        return True
    elif isinstance(channels, str):
        if channels in VALID_CHANNELS:
            return True
    else:
        return False


PARAMS_VALIDATION = {
    'meter': meter_validator,
    'channels': channels_validator,
    'axis': set(platforms),
    'step': is_number,
    'dist': is_number,
    'speed': is_speed,
    'endpow': endpow,
    'trg': is_bool,
}

COMMANDS_STRUCT = {
    'GridAlign': {
        12:
            ['meter', 'channels', 'axis_1', 'step_1', 'dist_1', 'speed_1',
             'axis_2', 'step_2', 'dist_2', 'speed_2', 'endpow', 'trg'],
        8:
            ['meter', 'channels', 'axis_1', 'step_1', 'dist_1', 'speed_1', 'endpow', 'trg']},

    'GridAlignBlind': {20:
                           ['meter', 'channels', 'axis_1', 'step_1', 'dist_1', 'speed_1', 'axis_2', 'step_2', 'dist_2',
                            'speed_2', 'axis_3', 'step_3', 'dist_3', 'speed_3', 'axis_1', 'step_1', 'dist_1', 'speed_1',
                            'endpow', 'trg']},

    'HillClimb': {13:
                      ['meter', 'channels', 'axis_1', 'step_1', 'speed_1', 'min_1', 'axis_2', 'step_2', 'speed_2',
                       'min_2', 'eps',
                       'delta', 'num'],
                  14: ['meter', 'channels', 'axis_1', 'step_1', 'speed_1', 'min_1', 'axis_2', 'step_2', 'speed_2',
                       'min_2', 'eps',
                       'delta', 'num', 'cont']},
    'RollAlign': {
        16: ['meter1', 'channels1', 'meter2', 'channels2', 'dist', 'axis_1', 'step_1', 'dist_1', 'speed_1', 'axis_2',
             'step_2', 'dist_2', 'speed_2', 'axis_3', 'speed_3', 'endpow']},
    'LoopAlign': {
        15: ['meter', 'channels', 'axis_1', 'step_1', 'dist_1', 'speed_1', 'axis_2',
             'step_2', 'dist_2', 'speed_2', 'axis_3', 'step_3', 'dist_3', 'speed_3', 'endpow']},
    'BalanceAlign': {
        12:
            ['meter', 'channels', 'axis_1', 'step_1', 'dist_1', 'speed_1',
             'axis_2', 'step_2', 'dist_2', 'speed_2', 'endpow', 'trg']
    },
    'MaxAlign': {
        12:
            ['meter', 'channels', 'axis_1', 'step_1', 'dist_1', 'speed_1',
             'axis_2', 'step_2', 'dist_2', 'speed_2', 'endpow', 'trg']
    },
}

PROPERTIES_MATCH = {
    'meter': ['MeterModuleName', 'MeterName'],
    'channels': ['Channels', 'MeterChan', 'Chanels'],
    'axis_1': 'AxisName1',
    'axis_2': 'AxisName2',
    'axis_3': 'AxisName3',
    'axis_4': 'AxisName4',
    'dist_1': 'Dist1',
    'dist_2': 'Dist2',
    'dist_3': 'Dist3',
    'dist_4': 'Dist4',
    'step_1': 'Step1',
    'step_2': 'Step2',
    'step_3': 'Step3',
    'step_4': 'Step4',
    'speed_1': 'Speed1',
    'speed_2': 'Speed2',
    'speed_3': 'Speed3',
    'speed_4': 'Speed4',
    'endpow': 'EndPower',
    'trg': 'Trig',
    'shift': 'AxisShift'
}


class MeterSet:

    def __init__(self, meter_names):
        self.meter_names = []
        if isinstance(meter_names, list):
            for meter in meter_names:
                print(meter)
                self.meter_names.append(DICT_PMS[meter[0]])
        else:
            self.meter_names.append(DICT_PMS[meter_names])
        self.serv_names = []
        for meter in self.meter_names:
            self.serv_names.append(PMS_SERVERS[meter])

    def get_serv_names(self):
        return self.serv_names


class ChannelSet:

    def __init__(self, channels):
        print(channels, 'каналы')
        self.channels = channels

    def get_channels(self):
        return str(self.channels)


class AxisSet:

    def __init__(self, axis_name):
        self.axis_name = axis_name

    def get_axis(self):
        return ax_servers[str(self.axis_name)]


class StepSet:

    def __init__(self, value):
        self.step = value

    def get_step(self):
        return [str(self.step)]


class DistSet:

    def __init__(self, value):
        self.dist = value

    def get_dist(self):
        return [str(self.dist)]


class SpeedSet:

    def __init__(self, value):
        self.speed = value

    def get_speed(self):
        return [str(self.speed)]


class EndpowSet:

    def __init__(self, value):
        self.endpow = value

    def get_endpow(self):
        return [str(self.endpow)]


class TrgSet:

    def __init__(self, value):
        self.trg = value

    def get_trg(self):
        return [str(self.trg)]


class ShiftSet:

    def __init__(self, value):
        self.shift = value

    def get_shift(self):
        return [str(self.shift)]


class SetVal:

    def __init__(self, name, value):
        self.name = name
        self.value = value
        if name == 'meter':
            prop = MeterSet(value).get_serv_names()
        elif name == 'channels':
            prop = ChannelSet(value).get_channels()
        elif 'axis' in name:
            prop = AxisSet(value).get_axis()
        elif 'step' in name:
            prop = StepSet(value).get_step()
        elif 'dist' in name:
            prop = DistSet(value).get_dist()
        elif 'speed' in name:
            prop = SpeedSet(value).get_speed()
        elif name == 'endpow':
            prop = EndpowSet(value).get_endpow()
        elif name == 'trg':
            prop = TrgSet(value).get_trg()
        elif name == 'shift':
            prop = ShiftSet(value).get_shift()
        else:
            prop = None
        self.prop = prop

    def get(self):
        if self.prop is not None:
            return self.prop
        else:
            raise ValueError(self.name, self.value)


class SetProperty:

    def __init__(self, align_name, property_dict, cmd_dict):
        self.align_name = align_name
        self.cmd_dict = cmd_dict
        self.property_dict = property_dict

    def _set_value(self):
        new_dict = {}
        for name, value in self.cmd_dict.items():
            new_dict[name] = SetVal(name, value).get()
        self.cmd_dict = new_dict

    def set_property(self):
        self._set_value()
        for name, value in self.cmd_dict.items():
            if isinstance(PROPERTIES_MATCH[name], list):
                for prop_name in PROPERTIES_MATCH[name]:
                    if prop_name in self.property_dict:
                        self.property_dict[prop_name] = value
            else:
                if PROPERTIES_MATCH[name] in self.property_dict:
                    self.property_dict[PROPERTIES_MATCH[name]] = value
        ALIGNMENTS[self.align_name].put_property(self.property_dict)
        print('Свойства вставлены успешно!')