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