def remoteRegWrite(self, destination, address, data): """Performs regWrite on a remote Pozyx device. Args: destination: Network ID of destination device. integer ID or NetworkID(ID). address: Register address to start the writing operation on. data: Contains the data to be written. ByteStructure-derived object. Returns: POZYX_SUCCESS, POZYX_FAILURE, POZYX_TIMEOUT """ if len(data) > PozyxConstants.MAX_BUF_SIZE - 1: return POZYX_FAILURE send_data = Data([0, address] + data.data, 'BB' + data.data_format) status = self.regFunction(PozyxRegisters.WRITE_TX_DATA, send_data, Data([])) if status != POZYX_SUCCESS: return status self.getInterruptStatus(SingleRegister()) status = self.sendTXWrite(destination) if status != POZYX_SUCCESS: return status return self.checkForFlag(PozyxBitmasks.INT_STATUS_FUNC, 0.5)
def remoteRegWrite(self, destination, address, data): """ Performs regWrite on a remote Pozyx device. Args: destination: Network ID of destination device. integer ID or NetworkID(ID). address: Register address to start the writing operation on. data: Contains the data to be written. ByteStructure-derived object. Returns: POZYX_SUCCESS, POZYX_FAILURE, POZYX_TIMEOUT """ if is_reg_writable(address) == 0: return POZYX_FAILURE if len(data) > MAX_BUF_SIZE - 1: return POZYX_FAILURE send_data = Data([0, address] + data.data, 'BB' + data.data_format) status = self.regFunction(POZYX_TX_DATA, send_data, Data([])) if status == POZYX_FAILURE: return status self.regRead(POZYX_INT_STATUS, SingleRegister()) params = Data([destination, 0x04], 'HB') status = self.regFunction(POZYX_TX_SEND, params, Data([])) if status == POZYX_FAILURE: return status return self.checkForFlag(POZYX_INT_STATUS_FUNC, 0.1)
def useFunction(self, function, params=None, data=None, remote_id=None): """ Activates a Pozyx register function either locally or remotely. Args: address: The function address Kwargs: params: A ByteStructure - derived object that contains the parameters for the function. data: A ByteStructure - derived object that is the container of the read data. remote_id: Remote ID for remote read. Returns: POZYX_SUCCESS, POZYX_FAILURE, POZYX_TIMEOUT Example: >>> self.useFunction(POZYX_DEVICES_CLEAR) """ if params is None: params = Data([]) if data is None: data = Data([]) if remote_id is None: status = self.regFunction(function, params, data) else: status = self.remoteRegFunction(remote_id, function, params, data) return status
def readRXBufferData(self, data): """ Reads the device's receive buffer's data completely. Args: data: Container for the data to be read from the receiver buffer. Returns: POZYX_SUCCESS, POZYX_FAILURE """ if data.byte_size > MAX_BUF_SIZE: return POZYX_FAILURE status = POZYX_SUCCESS if data.byte_size < MAX_SERIAL_SIZE: params = Data([0, data.byte_size]) status &= self.regFunction(POZYX_RX_DATA, params, data) else: runs = int(data.byte_size / MAX_SERIAL_SIZE) s = '' for i in range(runs): params = Data([i * MAX_SERIAL_SIZE, MAX_SERIAL_SIZE]) d = Data([0] * MAX_SERIAL_SIZE) status &= self.regFunction(POZYX_RX_DATA, params, d) s += d.byte_data params = Data([ runs * MAX_SERIAL_SIZE, data.byte_size - runs * MAX_SERIAL_SIZE ]) d = Data([0] * (data.byte_size - runs * MAX_SERIAL_SIZE)) status &= self.regFunction(POZYX_RX_DATA, params, d) s += d.byte_data data.load_bytes(s) return status
def __init__(self, ids=None, list_size=0): """Initializes the DeviceList object with either IDs or its size.""" ids = [] if ids is None else ids if list_size != 0 and ids == []: Data.__init__(self, [0] * list_size, 'H' * list_size) else: Data.__init__(self, ids, 'H' * len(ids))
def readRXBufferData(self, data, offset=0): """Reads the device's receive buffer's data completely. Args: data: Container for the data to be read from the receiver buffer. offset (optional): Offset of where in the RX buffer to start read Returns: POZYX_SUCCESS, POZYX_FAILURE """ if data.byte_size + offset > PozyxConstants.MAX_BUF_SIZE: return POZYX_FAILURE _MAX_SERIAL_SIZE = PozyxConstants.MAX_SERIAL_SIZE status = POZYX_SUCCESS runs = int(data.byte_size / _MAX_SERIAL_SIZE) total_byte_data = "" for i in range(runs): partial_data = Data([0] * _MAX_SERIAL_SIZE) status &= self.regFunction( PozyxRegisters.READ_RX_DATA, Data([offset + i * _MAX_SERIAL_SIZE, partial_data.byte_size]), partial_data) total_byte_data += partial_data.byte_data partial_data = Data([0] * (data.byte_size - runs * _MAX_SERIAL_SIZE)) status &= self.regFunction( PozyxRegisters.READ_RX_DATA, Data([offset + runs * _MAX_SERIAL_SIZE, partial_data.byte_size]), partial_data) total_byte_data += partial_data.byte_data data.load_bytes(total_byte_data) return status
def useFunction(self, function, params=None, data=None, remote_id=None): """Activates a Pozyx register function either locally or remotely. Args: address: The function address Kwargs: params: A ByteStructure - derived object that contains the parameters for the function. data: A ByteStructure - derived object that is the container of the read data. remote_id: Remote ID for remote read. Returns: POZYX_SUCCESS, POZYX_FAILURE, POZYX_TIMEOUT Example: >>> self.useFunction(PozyxRegisters.CLEAR_DEVICES) """ if not is_functioncall(function): if not self.suppress_warnings: warn("Register 0x%0.02x isn't a function register" % function, stacklevel=3) params = Data([]) if params is None else params data = Data([]) if data is None else data if remote_id is None: return self.regFunction(function, params, data) else: return self.remoteRegFunction(remote_id, function, params, data)
def writeTXBufferData(self, data, offset=0): """Writes data to the device's transmit buffer at the offset address. Args: data: Data to write to the Pozyx buffer. Has to be a ByteStructure derived object. offset (optional): Offset in buffer to start writing data Returns: POZYX_SUCCESS, POZYX_FAILURE """ if not dataCheck(data): data = Data(data) if offset + data.byte_size > PozyxConstants.MAX_BUF_SIZE: return POZYX_FAILURE # have to account for the parameter taking up a byte _MAX_SERIAL_SIZE = PozyxConstants.MAX_SERIAL_SIZE - 1 status = POZYX_SUCCESS data = Data(data.transform_to_bytes()) runs = int(data.byte_size / _MAX_SERIAL_SIZE) for i in range(runs): status &= self.regFunction( PozyxRegisters.WRITE_TX_DATA, Data([offset + i * _MAX_SERIAL_SIZE] + data[i * _MAX_SERIAL_SIZE:(i + 1) * _MAX_SERIAL_SIZE]), Data([])) return status & self.regFunction( PozyxRegisters.WRITE_TX_DATA, Data([offset + runs * _MAX_SERIAL_SIZE] + data[runs * _MAX_SERIAL_SIZE:]), Data([]))
def sendTXBufferData(self, destination): """ Sends the transmit buffer's data to the destination device. Args: destination: Network ID of destination. integer ID or NetworkID(ID) Returns: POZYX_SUCCESS, POZYX_FAILURE """ if dataCheck(destination): destination = destination[0] # see what I did there. params = Data([destination, 0x06], 'HB') status = self.regFunction(POZYX_TX_SEND, params, Data([])) return status
def __init__(self, port, baudrate=115200, timeout=0.1, print_output=False): """Initializes the PozyxSerial object. See above for details.""" self.print_output = print_output try: self.ser = Serial(port, baudrate, timeout=timeout) except: print( "Couldn't connect with Pozyx, wrong/busy serial port, or pySerial not installed.") raise SystemExit sleep(0.25) regs = Data([0, 0, 0]) if self.regRead(POZYX_WHO_AM_I, regs) == POZYX_FAILURE: print("Connected to Pozyx, but couldn't read serial data.") raise SystemExit self._hw_version = regs[1] self._sw_version = regs[2] if regs[0] != 0x43: print("WHO AM I returned 0x%0.2x, something is wrong with Pozyx." % regs[0]) raise SystemExit
def writeTXBufferData(self, data, offset=0): """ Writes data to the device's transmit buffer at the offset address. Args: data: Data to write to the Pozyx buffer. Has to be a ByteStructure derived object. Kwargs: offset: Offset in buffer to start writing data Returns: POZYX_SUCCESS, POZYX_FAILURE """ if offset + data.byte_size > MAX_BUF_SIZE: return POZYX_FAILURE # have to account for the parameter taking up a byte _MAX_SERIAL_SIZE = MAX_SERIAL_SIZE - 1 status = POZYX_SUCCESS data = Data(data.transform_to_bytes()) runs = int(data.byte_size / _MAX_SERIAL_SIZE) for i in range(runs): params = Data([i * _MAX_SERIAL_SIZE] + data[i * _MAX_SERIAL_SIZE:(i + 1) * _MAX_SERIAL_SIZE]) status &= self.regFunction(POZYX_TX_DATA, params, Data([])) params = Data([runs * _MAX_SERIAL_SIZE] + data[runs * _MAX_SERIAL_SIZE:]) return status & self.regFunction(POZYX_TX_DATA, params, Data([]))
def remoteRegRead(self, destination, address, data): """ Performs regRead on a remote Pozyx device. Args: destination: Network ID of destination device. integer ID or NetworkID(ID). address: Register address to start the read operation from. data: Container for the read data. ByteStructure-derived object. Returns: POZYX_SUCCESS, POZYX_FAILURE, POZYX_TIMEOUT """ if dataCheck(destination): destination = destination[0] if is_reg_readable(address) == 0: return POZYX_FAILURE if len(data) > MAX_BUF_SIZE: return POZYX_FAILURE if destination == 0: return POZYX_FAILURE send_data = Data([0, address, data.byte_size]) status = self.regFunction(POZYX_TX_DATA, send_data, Data([])) if status == POZYX_FAILURE: return status self.regRead(POZYX_INT_STATUS, SingleRegister()) params = Data([destination, 0x02], 'HB') status = self.regFunction(POZYX_TX_SEND, params, Data([])) if status == POZYX_FAILURE: return status status = self.checkForFlag(POZYX_INT_STATUS_FUNC, 1) if status == POZYX_SUCCESS: rx_info = Data([0, 0], 'HB') self.regRead(POZYX_RX_NETWORK_ID, rx_info) if rx_info[0] == destination and rx_info[1] == data.byte_size: status = self.readRXBufferData(data) return status else: return POZYX_FAILURE return status
def remoteRegRead(self, destination, address, data): """Performs regRead on a remote Pozyx device. Args: destination: Network ID of destination device. integer ID or NetworkID(ID). address: Register address to start the read operation from. data: Container for the read data. ByteStructure-derived object. Returns: POZYX_SUCCESS, POZYX_FAILURE, POZYX_TIMEOUT """ if dataCheck(destination): destination = destination[0] if len(data) > PozyxConstants.MAX_BUF_SIZE: return POZYX_FAILURE if destination == 0: return POZYX_FAILURE send_data = Data([0, address, data.byte_size]) status = self.regFunction(PozyxRegisters.WRITE_TX_DATA, send_data, Data([])) if status != POZYX_SUCCESS: return status self.getInterruptStatus(SingleRegister()) status = self.sendTXRead(destination) if status != POZYX_SUCCESS: return status status = self.checkForFlag(PozyxBitmasks.INT_STATUS_FUNC, 1) if status == POZYX_SUCCESS: rx_info = RXInfo() self.getRxInfo(rx_info) if rx_info.remote_id == destination and rx_info.amount_of_bytes == data.byte_size: status = self.readRXBufferData(data) return status else: return POZYX_FAILURE return status
def remoteRegFunction(self, destination, address, params, data): """Performs regFunction on a remote Pozyx device. Args: destination: Network ID of destination device. integer ID or NetworkID(ID). address: Register address to start the read operation from. params: Parameters for the register function. ByteStructure-derived object of uint8s. data: Container for the data returned by the register function. ByteStructure-derived object. Returns: POZYX_SUCCESS, POZYX_FAILURE, POZYX_TIMEOUT """ send_data = Data([0, address] + params.data, 'BB' + params.data_format) status = self.regFunction(PozyxRegisters.WRITE_TX_DATA, send_data, Data([])) if status != POZYX_SUCCESS: return status self.getInterruptStatus(SingleRegister()) status = self.sendTXFunction(destination) if status != POZYX_SUCCESS: return status status = self.checkForFlag(PozyxBitmasks.INT_STATUS_FUNC, 1) if status == POZYX_SUCCESS: rx_info = RXInfo() self.getRxInfo(rx_info) if rx_info.remote_id == destination and rx_info.amount_of_bytes == data.byte_size + 1: return_data = Data([0] + data.data, 'B' + data.data_format) status = self.readRXBufferData(return_data) if status != POZYX_SUCCESS: return status if len(return_data) > 1: data.load(return_data[1:]) return return_data[0] else: return POZYX_FAILURE return status
def sendTX(self, destination, operation): """Sends the data in the transmit buffer to destination ID. Helper for sendData. Args: destination: Network ID of destination. integer ID or NetworkID(ID) operation: Type of TX operation. These vary depending on the desired operation. Returns: POZYX_SUCCESS, POZYX_FAILURE """ if dataCheck(destination): destination = destination[0] return self.regFunction(PozyxRegisters.SEND_TX_DATA, TXInfo(destination, operation), Data([]))
def __init__(self, port, baudrate=115200, timeout=0.1, write_timeout=0.1, print_output=False, debug_trace=False): """Initializes the PozyxSerial object. See above for details.""" self.print_output = print_output try: if os.name == "posix": self.ser = Serial(port, baudrate, timeout=timeout) else: self.ser = Serial(port, baudrate, timeout=timeout, write_timeout=write_timeout) except Exception as exc: print( "Couldn't connect with Pozyx, wrong/busy serial port, or pySerial not installed.") print str(exc) if debug_trace: import traceback import sys traceback.print_tb(sys.exc_info()[2]) raise SystemExit sleep(0.25) regs = Data([0, 0, 0]) if self.regRead(POZYX_WHO_AM_I, regs) == POZYX_FAILURE: print("Connected to Pozyx, but couldn't read serial data.") if debug_trace: import traceback import sys traceback.print_tb(sys.exc_info()[2]) raise SystemExit self._hw_version = regs[1] self._sw_version = regs[2] if regs[0] != 0x43: print("WHO AM I returned 0x%0.2x, something is wrong with Pozyx." % regs[0]) raise SystemExit
def remoteRegFunction(self, destination, address, params, data): """ Performs regFunction on a remote Pozyx device. Args: destination: Network ID of destination device. integer ID or NetworkID(ID). address: Register address to start the read operation from. params: Parameters for the register function. ByteStructure-derived object of uint8s. data: Container for the data returned by the register function. ByteStructure-derived object. Returns: POZYX_SUCCESS, POZYX_FAILURE, POZYX_TIMEOUT """ if is_functioncall(address) == 0: return POZYX_FAILURE send_data = Data([0, address] + params.data, 'BB' + params.data_format) status = self.regFunction(POZYX_TX_DATA, send_data, Data([])) if status == POZYX_FAILURE: return status self.regRead(POZYX_INT_STATUS, SingleRegister()) tx_params = Data([destination, 0x08], 'HB') status = self.regFunction(POZYX_TX_SEND, tx_params, Data([])) if status == POZYX_FAILURE: return status status = self.checkForFlag(POZYX_INT_STATUS_FUNC, 1) if status == POZYX_SUCCESS: rx_info = Data([0, 0], 'HB') self.regRead(POZYX_RX_NETWORK_ID, rx_info) if rx_info[0] == destination and rx_info[1] == data.byte_size + 1: return_data = Data([0] + data.data, 'B' + data.data_format) status = self.readRXBufferData(return_data) if status == POZYX_FAILURE: return status if len(return_data) > 1: data.load(return_data[1:]) return return_data[0] else: return POZYX_FAILURE return status
def __init__(self, network_id=0): """Initializes the NetworkID object.""" Data.__init__(self, [network_id], 'H') self.id = network_id
from pypozyx import (PozyxSerial, get_first_pozyx_serial_port) from pypozyx.definitions.registers import POZYX_WHO_AM_I from pypozyx.structures.generic import Data, SingleRegister #from pythonosc.udp_client import SimpleU serial_port = get_first_pozyx_serial_port() print(serial_port) pozyx = PozyxSerial(serial_port) data = Data([0] * 5) #remote_id = 0x675b #remote_id = 0x0 #pozyx.getRead(POZYX_WHO_AM_I, data, remote_id=remote_id) #print('who am i: 0x%0.2x' % data[0]) #print('firmware version: 0x%0.2x' % data[1]) #print('hardware version: 0x%0.2x' % data[2]) #print('self test result: %s' % bin(data[3])) #print('error: 0x%0.2x' % data[4]) whoami = SingleRegister() pozyx.regRead(POZYX_WHO_AM_I, whoami) # which is pozyx.getWhoAmI(whoami) print(whoami)
def sendTX(self, destination, operation): if dataCheck(destination): destination = destination[0] return self.regFunction(PozyxRegisters.POZYX_TX_SEND, TXInfo(destination, operation), Data([]))