X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=bindings%2Fpython%2Fsigrok%2Fcore%2Fclasses.py;h=f4d2e60e9f40fe2a8e8b7dd4515830e50d33b31b;hb=01169de39195e2e54e4534504b60ed2408129b81;hp=4bbda25d6f5369214eca0fd3cfa6f8ece59551b2;hpb=1cad2115477176001f44cbe8a46a3c74e650f866;p=libsigrok.git diff --git a/bindings/python/sigrok/core/classes.py b/bindings/python/sigrok/core/classes.py index 4bbda25d..f4d2e60e 100644 --- a/bindings/python/sigrok/core/classes.py +++ b/bindings/python/sigrok/core/classes.py @@ -1,5 +1,5 @@ ## -## This file is part of the sigrok project. +## This file is part of the libsigrok project. ## ## Copyright (C) 2013 Martin Ling ## @@ -23,7 +23,8 @@ from .lowlevel import * from . import lowlevel import itertools -__all__ = ['Error', 'Context', 'Driver', 'Device', 'Session', 'Packet'] +__all__ = ['Error', 'Context', 'Driver', 'Device', 'Session', 'Packet', 'Log', + 'LogLevel', 'PacketType', 'Quantity', 'Unit', 'QuantityFlag', 'ConfigKey'] class Error(Exception): @@ -34,12 +35,6 @@ def check(result): if result != SR_OK: raise Error(result) -def config_key(name): - if not name.lower() == name: - raise AttributeError - key_name = "SR_CONF_" + name.upper() - return getattr(lowlevel, key_name) - def gvariant_to_python(value): type_string = g_variant_get_type_string(value) if type_string == 't': @@ -68,8 +63,10 @@ def python_to_gvariant(value): return g_variant_new_string(value) if isinstance(value, Fraction): array = new_gvariant_ptr_array(2) - gvariant_ptr_array_setitem(array, 0, value.numerator) - gvariant_ptr_array_setitem(array, 1, value.denominator) + gvariant_ptr_array_setitem(array, 0, + g_variant_new_uint64(value.numerator)) + gvariant_ptr_array_setitem(array, 1, + g_variant_new_uint64(value.denominator)) result = g_variant_new_tuple(array, 2) delete_gvariant_ptr_array(array) return result @@ -118,18 +115,22 @@ class Driver(object): def name(self): return self.struct.name - def scan(self): + def scan(self, **kwargs): if not self._initialized: check(sr_driver_init(self.context.struct, self.struct)) self._initialized = True - devices = [] - device_list = sr_driver_scan(self.struct, None) - device_list_item = device_list - while device_list_item: - ptr = device_list_item.data - device_ptr = gpointer_to_sr_dev_inst_ptr(ptr) - devices.append(Device(self, device_ptr)) - device_list_item = device_list_item.next + options = [] + for name, value in kwargs.items(): + key = getattr(ConfigKey, name.upper()) + src = sr_config() + src.key = key.id + src.data = python_to_gvariant(value) + options.append(src.this) + option_list = python_to_gslist(options) + device_list = sr_driver_scan(self.struct, option_list) + g_slist_free(option_list) + devices = [Device(self, gpointer_to_sr_dev_inst_ptr(ptr)) + for ptr in gslist_to_python(device_list)] g_slist_free(device_list) return devices @@ -147,12 +148,13 @@ class Device(object): self.struct = struct def __getattr__(self, name): - key = config_key(name) + key = getattr(ConfigKey, name.upper()) data = new_gvariant_ptr_ptr() try: - check(sr_config_get(self.driver.struct, key, data, self.struct)) + check(sr_config_get(self.driver.struct, + key.id, data, self.struct)) except Error as error: - if error.errno == SR_ERR_ARG: + if error.errno == SR_ERR_NA: raise NotImplementedError( "Device does not implement %s" % name) else: @@ -162,11 +164,12 @@ class Device(object): def __setattr__(self, name, value): try: - key = config_key(name) + key = getattr(ConfigKey, name.upper()) except AttributeError: super(Device, self).__setattr__(name, value) return - check(sr_config_set(self.struct, key, python_to_gvariant(value))) + check(sr_config_set(self.struct, + key.id, python_to_gvariant(value))) @property def vendor(self): @@ -194,6 +197,9 @@ class Session(object): def add_device(self, device): check(sr_session_dev_add(device.struct)) + def open_device(self, device): + check(sr_dev_open(device.struct)) + def add_callback(self, callback): wrapper = partial(callback_wrapper, self, callback) check(sr_session_datafeed_python_callback_add(wrapper)) @@ -216,15 +222,18 @@ class Packet(object): @property def type(self): - return self.struct.type + return PacketType(self.struct.type) @property def payload(self): if self._payload is None: pointer = self.struct.payload - if self.struct.type == SR_DF_LOGIC: + if self.type == PacketType.LOGIC: self._payload = Logic(self, void_ptr_to_sr_datafeed_logic_ptr(pointer)) + elif self.type == PacketType.ANALOG: + self._payload = Analog(self, + void_ptr_to_sr_datafeed_analog_ptr(pointer)) else: raise NotImplementedError( "No Python mapping for packet type %ѕ" % self.struct.type) @@ -243,8 +252,101 @@ class Logic(object): self._data = cdata(self.struct.data, self.struct.length) return self._data +class Analog(object): + + def __init__(self, packet, struct): + self.packet = packet + self.struct = struct + self._data = None + + @property + def num_samples(self): + return self.struct.num_samples + + @property + def mq(self): + return Quantity(self.struct.mq) + + @property + def unit(self): + return Unit(self.struct.unit) + + @property + def mqflags(self): + return QuantityFlag.set_from_mask(self.struct.mqflags) + + @property + def data(self): + if self._data is None: + self._data = float_array.frompointer(self.struct.data) + return self._data + +class Log(object): + + @property + def level(self): + return LogLevel(sr_log_loglevel_get()) + + @level.setter + def level(self, l): + check(sr_log_loglevel_set(l.id)) + + @property + def domain(self): + return sr_log_logdomain_get() + + @domain.setter + def domain(self, d): + check(sr_log_logdomain_set(d)) + +class EnumValue(object): + + _enum_values = {} + + def __new__(cls, id): + if cls not in cls._enum_values: + cls._enum_values[cls] = {} + if id not in cls._enum_values[cls]: + value = super(EnumValue, cls).__new__(cls) + value.id = id + cls._enum_values[cls][id] = value + return cls._enum_values[cls][id] + +class LogLevel(EnumValue): + pass + +class PacketType(EnumValue): + pass + +class Quantity(EnumValue): + pass + +class Unit(EnumValue): + pass + +class QuantityFlag(EnumValue): + + @classmethod + def set_from_mask(cls, mask): + result = set() + while mask: + new_mask = mask & (mask - 1) + result.add(cls(mask ^ new_mask)) + mask = new_mask + return result + +class ConfigKey(EnumValue): + pass + for symbol_name in dir(lowlevel): - prefix = 'SR_DF_' - if symbol_name.startswith(prefix): - name = symbol_name[len(prefix):] - setattr(Packet, name, getattr(lowlevel, symbol_name)) + for prefix, cls in [ + ('SR_LOG_', LogLevel), + ('SR_DF_', PacketType), + ('SR_MQ_', Quantity), + ('SR_UNIT_', Unit), + ('SR_MQFLAG_', QuantityFlag), + ('SR_CONF_', ConfigKey)]: + if symbol_name.startswith(prefix): + name = symbol_name[len(prefix):] + value = getattr(lowlevel, symbol_name) + setattr(cls, name, cls(value))