def _end_transaction_and_read(self, length=_READ_LENGTH):
"""End the transaction by reading from the device.
According to the official documentation, as well as Craig's open-source
implementation (libSiUSBXp), it should be necessary to check the queue
size and read data in chunks. However, leviathan and its derivatives
seem to work fine without this complexity; we currently try the same
approach.
"""
msg = self.device.read(_PRO_READ_ENDPOINT, length, _READ_TIMEOUT)
_LOGGER.debug('received %s', LazyHexRepr(msg))
self.device.release()
return msg
def write(self, data):
"""Write raw report to HID.
The buffer should follow the semantics of the Linux HIDRAW API.
> The first byte of the buffer passed to write() should be set to the
> report number. If the device does not use numbered reports, the
> first byte should be set to 0. The report data itself should begin
> at the second byte.
"""
LOGGER.debug('writting report 0x%02x with %d bytes: %r', data[0],
len(data) - 1, LazyHexRepr(data, start=1))
return self.hiddev.write(data)
def get_feature_report(self, report_id, length):
"""Get feature report that matches `report_id` from HID.
If the device does not use numbered reports, set `report_id` to 0.
Unlike `read`, the returned data follows semantics similar to `write`
and `send_feature_report`: the first byte will always contain the
report ID (or 0), and the report data itself will being at the second
byte.
"""
data = self.hiddev.get_feature_report(report_id, length)
_LOGGER.debug('got feature report 0x%02x with %d bytes: %r', data[0],
len(data) - 1, LazyHexRepr(data, start=1))
return data
def read(self, length):
"""Read raw report from HID.
The returned data follows the semantics of the Linux HIDRAW API.
> On a device which uses numbered reports, the first byte of the
> returned data will be the report number; the report data follows,
> beginning in the second byte. For devices which do not use numbered
> reports, the report data will begin at the first byte.
"""
self.hiddev.set_nonblocking(False)
data = self.hiddev.read(length)
_LOGGER.debug('read %d bytes: %r', len(data), LazyHexRepr(data))
return data
def send_feature_report(self, data):
"""Send feature report to HID.
The buffer should follow the semantics of `write`.
> The first byte of the buffer passed to write() should be set to the
> report number. If the device does not use numbered reports, the
> first byte should be set to 0. The report data itself should begin
> at the second byte.
"""
LOGGER.debug('sending feature report 0x%02x with %d bytes: %r',
data[0],
len(data) - 1, LazyHexRepr(data, start=1))
return self.hiddev.send_feature_report(data)
def write(self, data):
"""Write raw report to HID.
The buffer should follow the semantics of the Linux HIDRAW API.
> The first byte of the buffer passed to write() should be set to the
> report number. If the device does not use numbered reports, the
> first byte should be set to 0. The report data itself should begin
> at the second byte.
"""
_LOGGER.debug('writting report 0x%02x with %d bytes: %r', data[0],
len(data) - 1, LazyHexRepr(data, start=1))
res = self.hiddev.write(data)
if res < 0:
raise OSError('Could not write to device')
if res != len(data):
_LOGGER.debug('wrote %d total bytes, expected %d', res, len(data))
return res
def send_feature_report(self, data):
"""Send feature report to HID.
The buffer should follow the semantics of `write`.
> The first byte of the buffer passed to write() should be set to the
> report number. If the device does not use numbered reports, the
> first byte should be set to 0. The report data itself should begin
> at the second byte.
"""
_LOGGER.debug('sending feature report 0x%02x with %d bytes: %r',
data[0],
len(data) - 1, LazyHexRepr(data, start=1))
res = self.hiddev.send_feature_report(data)
if res < 0:
raise OSError('Could not send feature report to device')
if res != len(data):
_LOGGER.debug('sent %d total bytes, expected %d', res, len(data))
return res
def write_block_data(self, address, register, data):
"""Write a block of byte data to a given register."""
_LOGGER.debug('writing block data @ 0x%02x:0x%02x: %r', address,
register, LazyHexRepr(data))
return self._smbus.write_block_data(address, register, data)
def read_block_data(self, address, register):
"""Read a block of up to 32 bytes from a given register."""
data = self._smbus.read_block_data(address, register)
_LOGGER.debug('read block data @ 0x%02x:0x%02x: %r', address,
register, LazyHexRepr(data))
return data
def _write(self, data):
"""Write data to the AIO and log"""
_LOGGER.debug('write %s', LazyHexRepr(data))
self.device.write(_PRO_WRITE_ENDPOINT, data, _WRITE_TIMEOUT)
def write(self, endpoint, data, timeout=None):
"""Write to endpoint."""
_LOGGER.debug('writting %d bytes: %r', len(data), LazyHexRepr(data))
return self.usbdev.write(endpoint, data, timeout=timeout)
def read(self, endpoint, length, timeout=None):
"""Read from endpoint."""
data = self.usbdev.read(endpoint, length, timeout=timeout)
_LOGGER.debug('read %d bytes: %r', len(data), LazyHexRepr(data))
return data
