def __init__(self, handler):
super(Vehicle, self).__init__(handler)
self.payload1 = Payload()
self.payload2 = Payload()
self.payload3 = Payload()
self.payload4 = Payload()
def processPacket(self, packet):
# Don't process packets if coordinator function halted
self.accessLock.acquire()
if self._running == False:
self.accessLock.release()
return
self.accessLock.release()
type = packet['id']
if type == 'rx_long_addr':
#print "RX Long Addr type packet received."
addr_data = (packet.get('source_addr'))[0:8]
addr = unpack('>Q', addr_data)
pld = Payload(packet.get('rf_data'))
self._handleRx(addr, pld)
elif type == 'rx':
#print "RX type packet received."
addr_data = (packet.get('source_addr'))[0:2]
addr = unpack('>H', addr_data)
pld = Payload(packet.get('rf_data'))
self._handleRx(addr, pld)
elif type == 'rx_io_data_long_addr':
#print "RX IO Data Long Addr type packet received."
addr_data = (packet.get('source_addr'))[0:2]
addr = unpack('>Q', addr_data)
self._handleOther(packet)
elif type == 'rx_io_data':
addr_data = (packet.get('source_addr'))[0:2]
addr = unpack('>H', addr_data)
pld = Payload(packet.get('rf_data'))
addr = unpack('H', pld.data)
self._handleOther(packet)
elif type == 'tx_status':
#print "TX Status type packet received."
self._handleOther(packet)
elif type == 'status':
#print "Status type packet received."
self._handleOther(packet)
elif type == 'at_response':
#print "AT Response type packet received."
self._handleOther(packet)
elif type == 'remote_at_response':
#print "Remote AT Response type packet received."
self._handleOther(packet)
else:
pass
def processPacket(self, packet):
pld = Payload(packet.get('rf_data'))
type = pld.type
data = pld.data
status = pld.status
if type == Commands['RAW_FRAME_RESPONSE']:
data_flag = str(self.block_size) + 'B'
raw = unpack('HHH' + data_flag, data)
frame_num = raw[0]
row = raw[1] * self.hardware_row_subsample
col = raw[2]
pixels = raw[3::]
#print "Received row: " + str(row) + " col: " + str(col)
self.writeBlock(row, col, pixels)
elif type == Commands['CENTROID_REPORT']:
raw = unpack('4H2B', data)
self.mergeImages()
self.drawCentroid(raw[0:2])
self.drawMax(raw[2:4])
print "Max lum: " + str(raw[4]) + " avg: " + str(raw[5])
self.updateImage()
self.displayFrameRate()
else:
print "Invalid command: " + str(type)
def testParseBytesToBytes(self):
# b'DB\x04\x00\x00\x00\x00\x00\x00\x00ABCD1997'
parser = Parser(BYTES_ENCODED)
parser_test_function(self,
parser=parser,
code="D",
dtype="B",
length=4,
payload=b'ABCD',
remaining=0)
head = Head(code=parser.code,
dtype=parser.dtype,
length=parser.length,
remaining=parser.remaining)
head_test_function(self,
head=head,
code="D",
dtype="B",
length=4,
remaining=0)
payload = Payload(data=parser.payload,
dtype=parser.dtype,
length=parser.length)
payload_test_function(self,
payload=payload,
data=b'ABCD',
dtype="B",
length=4)
def testParseBytesToInt(self):
parser = Parser(INT_ENCODED)
parser_test_function(self,
parser=parser,
code="D",
dtype="I",
length=2,
payload=257,
remaining=256)
head = Head(code=parser.code,
dtype=parser.dtype,
length=parser.length,
remaining=parser.remaining)
head_test_function(self,
head=head,
code="D",
dtype="I",
length=2,
remaining=256)
payload = Payload(data=parser.payload,
dtype=parser.dtype,
length=parser.length)
payload_test_function(self,
payload=payload,
data=257,
dtype="I",
length=2)
def testParseBytesToStr(self):
# b'DS\x04\x00\x00\x00\x00\x00\x00\x00ABCD1997'
parser = Parser(data=STR_ENCODED)
parser_test_function(self,
parser=parser,
code="D",
dtype="S",
length=4,
payload="ABCD",
remaining=0)
head = Head(code=parser.code,
dtype=parser.dtype,
length=parser.length,
remaining=parser.remaining)
head_test_function(self,
head=head,
code="D",
dtype="S",
length=4,
remaining=0)
payload = Payload(data=parser.payload,
dtype=parser.dtype,
length=parser.length)
payload_test_function(self,
payload=payload,
data="ABCD",
dtype="S",
length=4)
def sendDirectory(self):
print "Broadcasting directory"
data_strings = []
keySet = self.clients.keys()
data_pack = ''
bytes = 0
for key in keySet:
entry = self.clients[key]
if entry['Status'] != 'Assigned':
continue
new_data = pack('QLH', entry['UUID'], entry['Timestamp'], entry['Address'])
print "Packing: " + str(entry['UUID']) + "\t" + hex(entry['Address']) + "\t" + str(entry['Timestamp'])
data_pack = data_pack + new_data
bytes = bytes + len(new_data)
# If the next pack would cause packet to exceed size, delimit
if bytes + len(new_data) > 100:
data_strings.append(data_pack)
data_pack = ''
bytes = 0
# Catch undelimited data
if bytes != 0:
data_strings.append(data_pack)
# Send all data
for data in data_strings:
print "Sending directory update packet..."
pld = Payload(data = data, status = 0, type = Commands['DIR_UPDATE_RESPONSE'])
self.tx_callback(dest = BROADCAST_ADDRESS, packet = str(pld))
def apply(self, transaction, context):
fprint('=== come to apply ===')
header = transaction.header
payload = Payload(transaction.payload)
state = State(context)
_validate_timestamp(payload.timestamp)
fprint('=== payload.action ===')
fprint(payload.data)
if payload.action == payload_pb2.SupplyPayload.CREATE_AGENT:
_create_agent(
state=state,
public_key=header.signer_public_key,
payload=payload
)
elif payload.action == payload_pb2.SupplyPayload.CREATE_ITEM:
_create_item(
state=state,
public_key=header.signer_public_key,
payload=payload)
elif payload.action == payload_pb2.SupplyPayload.UPDATE_ITEM:
_update_item(
state=state,
public_key=header.signer_public_key,
payload=payload)
elif payload.action == payload_pb2.SupplyPayload.TRANFER_ITEM:
_tranfer_item(
state=state,
public_key=header.signer_public_key,
payload=payload)
else:
raise InvalidTransaction('Unhandled action')
def _streamVideo(self, device):
frame_index = 1
fps = 0
counter = 0
cap = cv2.VideoCapture(self.videosource)
cap.set(3, self.width)
cap.set(4, self.height)
cap.set(5, self.frame)
payload = Payload(device, self.width, self.height)
start_time = time.time()
try:
while True:
_, image = cap.read()
payload.setPayloadParam(time.time(), image, frame_index)
self.pub_socket.send(payload.get())
seconds = time.time() - start_time
if seconds > 1:
fps = counter
counter = 0
start_time = time.time()
outstr = "Frames: {}, FPS: {}".format(frame_index, fps)
sys.stdout.write('\r' + outstr)
counter = counter + 1
frame_index = frame_index + 1
except (KeyboardInterrupt, SystemExit):
print('Exit due to keyboard interrupt')
except Exception as ex:
print('Python error with no Exception handler:')
print('Traceback error:', ex)
traceback.print_exc()
finally:
cap.release()
sys.exit(0)
def write(self, raw_payload, who=None):
"""Writes payload to the _current_payload_out which is
automatically transferred once the client requests the size of
the payload.
"""
with self._next_payload_lock:
self._next_payload_out = Payload(raw_payload)
def setRemoteControlValues(self, thrust, steer, elevator):
data_pack = pack('3f', thrust, steer, elevator)
if self.debugPrint:
print "Setting RC values to thrust: " + str(thrust) + "\tsteer: " + str(steer) + \
"\televator: " + str(elevator)
pld = Payload(data=data_pack, status=0, type=Commands['SET_RC_VALUES'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def main():
region = "Winterthur"
payload_winterthur = Payload()
winterthur_code = get_region_codes(region)
payload_winterthur.change_region(winterthur_code)
for link in retreive_links(payload_winterthur.payload):
parse_link(link, region)
def testParseHandshakeToBytes(self):
parser = Parser(HANDSHAKE_ENCODED)
parser_test_function(self,
parser=parser,
code="H",
dtype="B",
length=0,
payload=b"",
remaining=0)
head = Head(code=parser.code,
dtype=parser.dtype,
length=parser.length,
remaining=parser.remaining)
head_test_function(self,
head=head,
code="H",
dtype="B",
length=0,
remaining=0)
payload = Payload(data=parser.payload,
dtype=parser.dtype,
length=parser.length)
payload_test_function(self,
payload=payload,
data=b"",
dtype="B",
length=0)
def requestCamParams(self):
data_pack = pack('H', 0)
if self.debugPrint:
print "Requesting camera parameters..."
pld = Payload(data=data_pack,
status=0,
type=Commands['CAM_PARAM_REQUEST'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def setRegulatorMode(self, flag):
data_pack = pack('B', flag)
if self.debugPrint:
print "Setting regulator state to " + str(flag)
pld = Payload(data=data_pack,
status=0,
type=Commands['SET_REGULATOR_MODE'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def setRegulatorRateFilter(self, filter_coeffs):
data_pack = pack('2H8f', *filter_coeffs)
if self.debugPrint:
print "Setting filter coefficients of " + str(filter_coeffs)
pld = Payload(data=data_pack,
status=0,
type=Commands['SET_REGULATOR_RATE_FILTER'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def setRegulatorRef(self, ref):
data_pack = pack(4 * 'f', *ref)
#if self.debugPrint:
#print "Setting quaternion reference to: " + str(ref)
pld = Payload(data=data_pack,
status=0,
type=Commands['SET_REGULATOR_REF'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def setRegulatorOffsets(self, offsets):
data_pack = pack(3 * 'f', *offsets)
#if self.debugPrint:
# print "Setting offsets to: " + str(offsets)
pld = Payload(data=data_pack,
status=0,
type=Commands['SET_REGULATOR_OFFSETS'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def requestDirDump(self, addr, pan):
data_pack = pack('HH', addr, pan)
if self.debugPrint:
print "Requesting directory dump of: " + str(addr) + " " + str(pan)
pld = Payload(data=data_pack,
status=0,
type=Commands['DIR_DUMP_REQUEST'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def setBackgroundFrame(self):
data_pack = pack('L', 0)
if self.debugPrint:
print "Capturing and setting background frame."
pld = Payload(data=data_pack,
status=0,
type=Commands['SET_BACKGROUND_FRAME'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def setEstimateRunning(self, mode):
data_pack = pack('B', mode)
if self.debugPrint:
print "Setting pose estimation mode to: " + str(mode)
pld = Payload(data=data_pack,
status=0,
type=Commands['SET_ESTIMATE_RUNNING'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def requestRawFrame(self):
data_pack = pack('L', 0)
if self.debugPrint:
print "Requesting raw frame."
pld = Payload(data=data_pack,
status=0,
type=Commands['RAW_FRAME_REQUEST'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def requestTelemetry(self):
data_pack = pack('L', 0)
if self.debugPrint:
print "Requesting telemetry."
pld = Payload(data=data_pack,
status=0,
type=Commands['REQUEST_TELEMETRY'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def setTelemetrySubsample(self, period):
data_pack = pack('H', period)
if self.debugPrint:
print "Setting telemetry subsample period to " + str(period)
pld = Payload(data=data_pack,
status=0,
type=Commands['SET_TELEM_SUBSAMPLE'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def getGyroCalibParam(self):
data_pack = pack('H', 0)
if self.debugPrint:
print "Requesting gyro offsets..."
pld = Payload(data=data_pack,
status=0,
type=Commands['GET_GYRO_CALIB_PARAM'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def setSlewLimit(self, limit):
data_pack = pack('f', limit)
if self.debugPrint:
print "Setting slew rate limit to: " + str(limit) + " radians/sec."
pld = Payload(data=data_pack,
status=0,
type=Commands['SET_SLEW_LIMIT'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def requestAttitude(self):
data_pack = pack('H', 0)
if self.debugPrint:
print "Requesting attitude."
pld = Payload(data=data_pack,
status=0,
type=Commands['REQUEST_ATTITUDE'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def requestDumpData(self, start_page, end_page, tx_size):
data_pack = pack('3H', start_page, end_page, tx_size)
if self.debugPrint:
print "Requesting memory from page " + str(start_page) + " to " + str(end_page) +\
", " + str(tx_size) + " bytes at a time."
pld = Payload(data=data_pack,
status=0,
type=Commands['GET_MEM_CONTENTS'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def startSensorDump(self, datasets):
data_pack = pack('H', datasets)
if self.debugPrint:
print "Requesting " + str(
datasets) + " samples to be written to flash."
pld = Payload(data=data_pack,
status=0,
type=Commands['RECORD_SENSOR_DUMP'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
def runGyroCalib(self, samples):
data_pack = pack('H', samples)
if self.debugPrint:
print "Requesting gyro calibration of " + str(
samples) + " samples."
pld = Payload(data=data_pack,
status=0,
type=Commands['RUN_GYRO_CALIB'])
self.tx_callback(dest=self.endpoint_addr, packet=str(pld))
