"""
Test bandwidth of 915 MHz telemetry radios to explore streaming real-time data
from the rocket, in-flight.
"""
from sys import path, stdout
path.insert(0, "../../lib")
from telemetry import Telemetry
from time import time
if __name__ == "__main__":
# Create and connect to telemetry radio.
receiver = Telemetry(port="/dev/ttyUSB0", baud=57600)
print "Waiting for messages to be sent."
messagesRead = 0
bytesRead = 0
while True:
bytesAvailable = receiver.bytesAvailable()
if bytesAvailable > 0: # bytes are waiting to be read
received = receiver.read(bytesAvailable)
messagesRead += 1
bytesRead += bytesAvailable
stdout.write("#{}:\t{} bytes [{} bytes total]\n".format(
messagesRead, bytesAvailable, bytesRead))
def main(winstyle=0):
from gdpr_consents import gdpr_concents
player_name, consent = gdpr_concents()
Telemetry(player_name, consent)
# Initialize pygame
if pg.get_sdl_version()[0] == 2:
pg.mixer.pre_init(44100, 32, 2, 1024)
pg.init()
if pg.mixer and not pg.mixer.get_init():
print("Warning, no sound")
pg.mixer = None
pg.mixer = None
fullscreen = False
# Set the display mode
winstyle = 0 # |FULLSCREEN
bestdepth = pg.display.mode_ok(SCREENRECT.size, winstyle, 32)
screen = pg.display.set_mode(SCREENRECT.size, winstyle, bestdepth)
# Load images, assign to sprite classes
# (do this before the classes are used, after screen setup)
img = load_image("player1.gif")
Player.images = [img, pg.transform.flip(img, 1, 0)]
img = load_image("explosion1.gif")
Explosion.images = [img, pg.transform.flip(img, 1, 1)]
Alien.images = [load_image(im) for im in ("alien1.gif", "alien2.gif", "alien3.gif")]
Bomb.images = [load_image("bomb.gif")]
Shot.images = [load_image("shot.gif")]
# decorate the game window
icon = pg.transform.scale(Alien.images[0], (32, 32))
pg.display.set_icon(icon)
pg.display.set_caption("Pygame Aliens")
pg.mouse.set_visible(0)
# create the background, tile the bgd image
bgdtile = load_image("background.gif")
background = pg.Surface(SCREENRECT.size)
for x in range(0, SCREENRECT.width, bgdtile.get_width()):
background.blit(bgdtile, (x, 0))
screen.blit(background, (0, 0))
pg.display.flip()
# load the sound effects
boom_sound = load_sound("boom.wav")
shoot_sound = load_sound("car_door.wav")
if pg.mixer:
music = os.path.join(main_dir, "data", "house_lo.wav")
pg.mixer.music.load(music)
pg.mixer.music.play(-1)
# Initialize Game Groups
aliens = pg.sprite.Group()
shots = pg.sprite.Group()
bombs = pg.sprite.Group()
all = pg.sprite.RenderUpdates()
lastalien = pg.sprite.GroupSingle()
# assign default groups to each sprite class
Player.containers = all
Alien.containers = aliens, all, lastalien
Shot.containers = shots, all
Bomb.containers = bombs, all
Explosion.containers = all
Score.containers = all
# Create Some Starting Values
global score
alienreload = ALIEN_RELOAD
clock = pg.time.Clock()
# initialize our starting sprites
global SCORE
player = Player(player_name)
Alien() # note, this 'lives' because it goes into a sprite group
if pg.font:
all.add(Score())
# Run our main loop whilst the player is alive.
while player.alive():
# get input
for event in pg.event.get():
if event.type == pg.QUIT:
return
if event.type == pg.KEYDOWN and event.key == pg.K_ESCAPE:
return
elif event.type == pg.KEYDOWN:
if event.key == pg.K_f:
if not fullscreen:
print("Changing to FULLSCREEN")
screen_backup = screen.copy()
screen = pg.display.set_mode(
SCREENRECT.size, winstyle | pg.FULLSCREEN, bestdepth
)
screen.blit(screen_backup, (0, 0))
else:
print("Changing to windowed mode")
screen_backup = screen.copy()
screen = pg.display.set_mode(
SCREENRECT.size, winstyle, bestdepth
)
screen.blit(screen_backup, (0, 0))
pg.display.flip()
fullscreen = not fullscreen
keystate = pg.key.get_pressed()
# clear/erase the last drawn sprites
all.clear(screen, background)
# update all the sprites
all.update()
# handle player input
direction = keystate[pg.K_RIGHT] - keystate[pg.K_LEFT]
player.move(direction)
firing = keystate[pg.K_SPACE]
if not player.reloading and firing and len(shots) < MAX_SHOTS:
Shot(player.gunpos())
if pg.mixer:
shoot_sound.play()
player.reloading = firing
# Create new alien
if alienreload:
alienreload = alienreload - 1
elif not int(random.random() * ALIEN_ODDS):
Alien()
alienreload = ALIEN_RELOAD
# Drop bombs
if lastalien and not int(random.random() * BOMB_ODDS):
Bomb(lastalien.sprite)
# Detect collisions between aliens and players.
for alien in pg.sprite.spritecollide(player, aliens, 1):
if pg.mixer:
boom_sound.play()
Explosion(alien)
Explosion(player)
SCORE = SCORE + 1
player.kill()
# See if shots hit the aliens.
for alien in pg.sprite.groupcollide(shots, aliens, 1, 1).keys():
if pg.mixer:
boom_sound.play()
Explosion(alien)
SCORE = SCORE + 1
# See if alien boms hit the player.
for bomb in pg.sprite.spritecollide(player, bombs, 1):
if pg.mixer:
boom_sound.play()
Explosion(player)
Explosion(bomb)
player.kill()
fps = pg.font.Font(None, 30).render(str(int(clock.get_fps())), True, pg.Color('white'))
screen.blit(fps, (50, 50))
# draw the scene
dirty = all.draw(screen)
pg.display.update(dirty)
# cap the framerate at 40fps. Also called 40HZ or 40 times per second.
clock.tick(40)
if pg.mixer:
pg.mixer.music.fadeout(1000)
pg.time.wait(1000)
pg.quit()
TEMPERATURE_ALERT = 40.0
# global counters
RECEIVE_CALLBACKS = 0
SEND_CALLBACKS = 0
BLOB_CALLBACKS = 0
TWIN_CALLBACKS = 0
SEND_REPORTED_STATE_CALLBACKS = 0
METHOD_CALLBACKS = 0
EVENT_SUCCESS = "success"
EVENT_FAILED = "failed"
# chose HTTP, AMQP or MQTT as transport protocol
PROTOCOL = IoTHubTransportProvider.HTTP
telemetry = Telemetry()
MSG_TXT = "{\"deviceId\": \"%s\",\"rec_time\": \"%s\",\"hum_out\": %d,\"temp_out\": %.1f,\"hum_in\": %d,\"temp_in\": %.1f, \"abs_pres\": %.1f,\"wind_gust\": %.1f,\"wind_avg\": %.1f,\"wind_dir\": %d,\"wind_pos\": \"%s\",\"rain_total\": %.1f}"
def receive_message_callback(message, counter):
global RECEIVE_CALLBACKS
message_buffer = message.get_bytearray()
size = len(message_buffer)
print("Received Message [%d]:" % counter)
print(" Data: <<<%s>>> & Size=%d" %
(message_buffer[:size].decode("utf-8"), size))
map_properties = message.properties()
key_value_pair = map_properties.get_internals()
print(" Properties: %s" % key_value_pair)
counter += 1
RECEIVE_CALLBACKS += 1
class Vision():
"""Vision class to handle PixyCam Data"""
COLOUR_WHITE = 7 # White
COLOUR_RED = 2 # Red
COLOUR_BLUE = 3 # Blue
COLOUR_YELLOW = 4 # Yellow
COLOUR_GREEN = 5 # Green
COLOUR_UNKNOWN = -99 # Default
RED_TURN_POSITION = 0
BLUE_TURN_POSITION = 1
YELLOW_TURN_POSITION = 2
GREEN_TURN_POSITION = 3
PIXY_RES_X = 320
PIXY_RES_Y = 200
ball_positions = [
BlockPosition(COLOUR_RED),
BlockPosition(COLOUR_BLUE),
BlockPosition(COLOUR_YELLOW),
BlockPosition(COLOUR_GREEN)
]
__biggest_block_in_frame = dict()
def __init__(self, steering, motors):
super(Vision, self).__init__()
self.__steering = steering
self.__motors = motors
self.__logger = Telemetry(self.__class__.__name__, "csv").get()
self.__logger.info(
'Frame, Block Type, Signature, X, Y, Width, Height, Size, Angle, Distance, Factor, MovingFor, Pan Position, Action'
)
self.__objectHeight = 46 # mm
self.__focalLength = 2.4 # mm
pixy_init()
def initialise(self, visionAttribs, ptc):
self.__visionAttributes = visionAttribs
self.__tilt_position = self.__visionAttributes.startTiltAngle
self.__pan_position = self.__visionAttributes.startPanAngle
self.__pan_tilt_controller = ptc
self.__pan_tilt_controller.pan_absolute(0)
self.__pan_tilt_controller.tilt_absolute(0)
def scan(self):
print("self.__pan_position = " + str(self.__pan_position))
str(self.__pan_tilt_controller.pan_absolute(self.__pan_position))
str(self.__pan_tilt_controller.tilt_absolute(self.__tilt_position))
time.sleep(0.5)
not_in_view = True
first_colour_found = False
colour_code = self.COLOUR_UNKNOWN
colours_found = False
blocks = BlockArray(100)
frame = 0
strOp = ""
factor = False
while colours_found != True:
try:
count = pixy_get_blocks(100, blocks)
if count > 0:
first_colour_found = True
frameKey = 'frame' + str(frame)
self.__biggest_block_in_frame = BlockPosition(
self.COLOUR_UNKNOWN, frameKey)
for index in range(0, count):
bsign = blocks[index].signature
btype = blocks[index].type
bx = blocks[index].x
by = blocks[index].y
bwidt = blocks[index].width
bheig = blocks[index].height
bsize = bwidt * bheig
angle = blocks[index].angle
bdist = (self.__objectHeight *
self.__focalLength) / bheig
factor = 0
if (self.__biggest_block_in_frame.size < bsize):
self.__biggest_block_in_frame.size = bsize
self.__biggest_block_in_frame.colour = int(bsign)
self.__biggest_block_in_frame.x = int(bx)
self.__biggest_block_in_frame.y = int(by)
self.__biggest_block_in_frame.width = int(bwidt)
self.__biggest_block_in_frame.size = int(bsize)
self.__biggest_block_in_frame.pan_position = self.__pan_position
factor = self.__update_if_better_block_position(
self.__biggest_block_in_frame)
strOp = (
'%d, %d, %d, %f, %f, %f, %f, %f, %f, %f, %s, %d, %f, %s'
% (frame, btype, bsign, bx, by, bwidt, bheig, bsize,
angle, bdist, str(factor), colour_code,
self.__pan_position, 'scanning'))
self.__pan_position = self.__pan_position + \
self.__pan_tilt_controller.abs_pan_per_degree
self.__pan_tilt_controller.pan_absolute(self.__pan_position)
if strOp != "":
self.__logger.info(strOp)
frame += 1
time.sleep(0.02)
colours_found = self.__all_colours_found(
) and self.__pan_position > (
self.__visionAttributes.maxPanAngle) * 0.95
except KeyboardInterrupt:
pixy_close()
print("Closed Pixy")
raise
except:
tb = traceback.format_exc()
e = sys.exc_info()[0]
print(tb)
if (self.__motors):
self.__motors.shutdown()
raise
def __update_if_better_block_position(self, current_block_position):
if ((current_block_position.size >
self.__visionAttributes.targetMinSize) and
((current_block_position.x + current_block_position.width) < 220)
and ((current_block_position.y > 15))
and ((current_block_position.y < 140))):
ball_position = self.__get_ball_position_of_colour(
current_block_position.colour)
x_distance_from_center = abs(self.ball_positions[ball_position].x -
self.PIXY_RES_X / 2)
new_x_distance_from_center = abs(current_block_position.x -
self.PIXY_RES_X / 2)
if (new_x_distance_from_center < x_distance_from_center):
self.ball_positions[ball_position] = current_block_position
return True
else:
return False
else:
return False
def __get_ball_position_of_colour(self, colour):
index = 0
for ball_position in self.ball_positions:
if ball_position.colour == colour:
return index
else:
index = index + 1
return -1
def __all_colours_found(self):
for ball_position in self.ball_positions:
if ball_position.pan_position == 360:
return False
return True
def goto_ball_position(self, ball_position, previous_position=0):
reached = False
self.__pan_position = 0
self.__pan_tilt_controller.pan(self.__pan_position)
turn_by = (ball_position.pan_position - previous_position) * -135
self.__motors.rotate(turn_by, 0.5)
# self.__pan_tilt_controller.tilt(-0.05)
self.__pan_position = 0
self.__pan_tilt_controller.pan(self.__pan_position)
while reached == False:
tracked = False
current_block_position = self.track(ball_position.colour)
tracked = current_block_position != None
if tracked:
current_block_position.factor = current_block_position.pan_position
# if(current_block_position.y < current_block_position.height / 2):
# while (current_block_position.y < current_block_position.height / 2):
# self.__pan_tilt_controller.tilt(
# self.__pan_tilt_controller.current_tilt - self.__pan_tilt_controller.abs_tilt_per_degree)
self.drive_to(current_block_position,
current_block_position.colour)
print("Size: " + str(current_block_position.size))
reached = current_block_position.size >= self.__visionAttributes.targetMaxSize
else:
self.__motors.stop()
self.__steering.steerAbsolute(0)
self.__motors.reverse()
self.__motors.clear_reverse_history()
def track(self, colour_code):
centered = False
blocks = BlockArray(100)
pan_dir = 'left'
current_block_position = BlockPosition()
frame = -1
while centered == False:
frame = frame + 1
count = pixy_get_blocks(100, blocks)
if count > 0:
for index in range(0, count):
current_block_position.colour = blocks[index].signature
btype = blocks[index].type
current_block_position.x = blocks[index].x
current_block_position.y = blocks[index].y
current_block_position.width = blocks[index].width
current_block_position.height = blocks[index].height
current_block_position.size = current_block_position.width * \
current_block_position.height
angle = blocks[index].angle
bdist = (self.__objectHeight * self.__focalLength
) / current_block_position.height
if (int(current_block_position.colour) == int(colour_code)
):
if current_block_position.x > 160:
pan_dir = 'right'
else:
pan_dir = 'left'
if ((current_block_position.size >
self.__visionAttributes.targetMinSize)
and (current_block_position.x <
((self.PIXY_RES_X / 2) -
(current_block_position.width / 2)))
and (current_block_position.x >
(self.PIXY_RES_X / 2) -
(current_block_position.width))
# and ((current_block_position.y > 15))
# and ((current_block_position.y < 140))
):
self.__pan_tilt_controller.pan_absolute(
self.__pan_position)
self.__steering.steerAbsolute(self.__pan_position *
2)
current_block_position.pan_position = self.__pan_position
strOp = (
'%d, %d, %d, %f, %f, %f, %f, %f, %f, %f, %s, %d, %f, %s'
% (frame, btype, current_block_position.colour,
current_block_position.x,
current_block_position.y,
current_block_position.width,
current_block_position.height,
current_block_position.size, angle, bdist,
"Found Colour & Size", colour_code,
self.__pan_position, 'tracking'))
self.__logger.info(strOp)
centered = True
else:
strOp = (
'%d, %d, %d, %f, %f, %f, %f, %f, %f, %f, %s, %d, %f, %s'
% (frame, btype, current_block_position.colour,
current_block_position.x,
current_block_position.y,
current_block_position.width,
current_block_position.height,
current_block_position.size, angle, bdist,
"Size Not Matched", colour_code,
self.__pan_position, 'tracking'))
self.__logger.info(strOp)
else:
strOp = (
'%d, %d, %d, %f, %f, %f, %f, %f, %f, %f, %s, %d, %f, %s'
% (frame, btype, current_block_position.colour,
current_block_position.x,
current_block_position.y,
current_block_position.width,
current_block_position.height,
current_block_position.size, angle, bdist,
"Colour Not Matched", colour_code,
self.__pan_position, 'tracking'))
self.__logger.info(strOp)
if centered == False:
print("Centered == False && count > 0")
pan_dir = self.__pan(pan_dir)
time.sleep(0.01)
else:
print("Centered == False && count == 0")
pan_dir = self.__pan(pan_dir)
time.sleep(0.01)
return current_block_position
def __pan(self, pan_dir):
if pan_dir == 'left':
self.__pan_position = self.__pan_position + \
self.__pan_tilt_controller.abs_pan_per_degree
if self.__pan_position > self.__visionAttributes.maxPanAngle:
pan_dir = 'right'
elif pan_dir == 'right':
self.__pan_position = self.__pan_position - \
self.__pan_tilt_controller.abs_pan_per_degree
if self.__pan_position < self.__visionAttributes.minPanAngle:
pan_dir = 'left'
if (self.__pan_position < self.__visionAttributes.maxPanAngle) and (
self.__pan_position > self.__visionAttributes.minPanAngle):
self.__pan_tilt_controller.pan_absolute(self.__pan_position)
self.__steering.steerAbsolute(self.__pan_position * -2)
print('__pan_position applied to ' + str(self.__pan_position))
return pan_dir
def drive_to(self, current_block_position, colour_code):
print("Driving to: " + str(current_block_position.pan_position) +
" : " + str(current_block_position.colour))
self.__steering.steerAbsolute(current_block_position.pan_position * -2)
self.__motors.move(1, 1, 0.3, True)
time.sleep(0.02)
# self.track(current_block_position.colour)
# def approach(self, current_block_position, colour_code):
# reached = False
# blocks = BlockArray(100)
# frame = 0
# while reached == False:
# try:
# if('colour' in self.__biggest_block_in_frame):
# if (self.__biggest_block_in_frame['colour'] == colour_code):
# # print('colour match')
#
# if(self.__biggest_block_in_frame['bsize'] > self.__visionAttributes.targetMinSize
# and self.__biggest_block_in_frame['bsize'] < self.__visionAttributes.targetMaxSize):
# self.__steering.steerAbsolute(0)
# else:
# self.__motors.move(1, 1, 0)
#
# if(self.__biggest_block_in_frame['bsize'] >= self.__visionAttributes.targetMaxSize):
# self.__motors.move(1, 1, 0)
#
# reached = True
# else:
#
# reached = False
# else:
# self.__motors.move(1, 1, 0)
# else:
# self.__motors.move(1, 1, 0)
#
# count = pixy_get_blocks(100, blocks)
# if count > 0:
#
# # Blocks found #
# frameKey = 'frame' + str(frame)
#
# # self.__biggest_block_in_frame = {frameKey: 0}
# for index in range(0, count):
# bsign = blocks[index].signature
# btype = blocks[index].type
# bx = blocks[index].x
# by = blocks[index].y
# bwidt = blocks[index].width
# bheig = blocks[index].height
# bsize = bwidt * bheig
# angle = blocks[index].angle
# bdist = (self.__objectHeight *
# self.__focalLength) / bheig
# factor = 0
# if (int(bsign) == int(colour_code)):
# if((frameKey in self.__biggest_block_in_frame and self.__biggest_block_in_frame[frameKey] < bsize)
# or ((frameKey in self.__biggest_block_in_frame) == False)):
# self.__biggest_block_in_frame[frameKey] = bsize
# self.__biggest_block_in_frame['colour'] = int(
# bsign)
# self.__biggest_block_in_frame['bx'] = int(
# bx)
# self.__biggest_block_in_frame['bwidt'] = int(
# bwidt)
# self.__biggest_block_in_frame['bsize'] = int(
# bsize)
#
# if self.__biggest_block_in_frame['bx'] > 160:
# panDirection = 'right'
# else:
# panDirection = 'left'
# if panDirection == 'left':
# self.__pan_position += self.__pan_tilt_controller.abs_pan_per_degree
# if self.__pan_position > self.__visionAttributes.maxPanAngle:
# panDirection = 'right'
# elif panDirection == 'right':
# self.__pan_position -= self.__pan_tilt_controller.abs_pan_per_degree
# if self.__pan_position < self.__visionAttributes.minPanAngle:
# panDirection = 'left'
# self.__pan_tilt_controller.pan_absolute(
# self.__pan_position)
#
# self.__biggest_block_in_frame['factor'] = self.__pan_position
# if('factor' in self.__biggest_block_in_frame):
# factor = self.__biggest_block_in_frame['factor']
# if(factor > 0):
# # go Left
# if (factor > 0.33):
# # spin
# print(
# 'spinning left @ factor:' + str(factor))
# self.__motors.rotate(
# factor * 135 * -1)
# self.__pan_position = 0
# self.__pan_tilt_controller.pan_absolute(
# self.__pan_position)
# else:
# # steer
# factor = factor / -1
# self.__steering.steerAbsolute(
# factor)
# self.__motors.move(1, 1, 1)
#
# elif(self.__biggest_block_in_frame['factor'] < 0):
# # goright
# if (factor < -0.33):
# # spin
# print(
# 'spinning Right @ factor:' + str(factor))
# self.__motors.rotate(
# factor * 135 * -1)
# self.__pan_position = 0
# self.__pan_tilt_controller.pan_absolute(
# self.__pan_position)
# else:
# # steer
# factor = factor / -1
# self.__steering.steerAbsolute(
# factor)
# self.__motors.move(1, 1, 1)
# else:
# print('going straight')
# factor = 0
# self.__steering.steerAbsolute(factor)
# self.__motors.move(1, 1, 1)
# else:
# print('going nowhere')
#
# self.__motors.move(1, 1, 1)
# else:
# self.__biggest_block_in_frame = {}
# strOp = ('%d, %d, %d, %f, %f, %f, %f, %f, %f, %f, %f, %d, %f, %s' % (
# frame, btype, bsign, bx, by, bwidt, bheig, bsize, angle, bdist, factor, colour_code, self.__pan_position, 'approaching'))
# self.__logger.info(strOp)
# frame += 1
# time.sleep(0.02)
#
# except KeyboardInterrupt:
# self.dispose()
# raise
# except:
# self.dispose()
#
# tb = traceback.format_exc()
# e = sys.exc_info()[0]
# print(tb)
# if(self.__motors):
# self.__motors.shutdown()
# raise
#
# def search(self, colour_code):
# found = False
# blocks = BlockArray(100)
# frame = 0
# panDirection = 'right'
#
# while found == False:
# try:
# count = pixy_get_blocks(100, blocks)
# if count > 0:
# # print('count > 0')
# # Blocks found #
# frameKey = 'frame' + str(frame)
# # print(count)
#
# self.__biggest_block_in_frame = {frameKey: 0}
# for index in range(0, count):
# bsign = blocks[index].signature
# btype = blocks[index].type
# bx = blocks[index].x
# by = blocks[index].y
# bwidt = blocks[index].width
# bheig = blocks[index].height
# bsize = bwidt * bheig
# angle = blocks[index].angle
# bdist = (self.__objectHeight *
# self.__focalLength) / bheig
# factor = 0
# if (int(bsign) == int(colour_code)):
# if(self.__biggest_block_in_frame[frameKey] < bsize):
# self.__biggest_block_in_frame[frameKey] = bsize
# self.__biggest_block_in_frame['colour'] = int(
# bsign)
# self.__biggest_block_in_frame['bx'] = int(
# bx)
# self.__biggest_block_in_frame['bwidt'] = int(
# bwidt)
# self.__biggest_block_in_frame['bsize'] = int(
# bsize)
#
# if(self.__biggest_block_in_frame[frameKey] > self.__visionAttributes.targetMinSize
# and ((self.__biggest_block_in_frame['bx'] + self.__biggest_block_in_frame['bwidt']) < 220)):
# found = True
# return self.__biggest_block_in_frame[frameKey]
# else:
# if panDirection == 'left':
# self.__pan_position += self.__pan_tilt_controller.abs_pan_per_degree
# if self.__pan_position > self.__visionAttributes.maxPanAngle:
# panDirection = 'right'
# elif panDirection == 'right':
# self.__pan_position -= self.__pan_tilt_controller.abs_pan_per_degree
# if self.__pan_position < self.__visionAttributes.minPanAngle:
# panDirection = 'left'
# self.__pan_tilt_controller.pan_absolute(
# self.__pan_position)
# found = False
#
# strOp = ('%d, %d, %d, %f, %f, %f, %f, %f, %f, %f, %f, %d, %f, %s' % (
# frame, btype, bsign, bx, by, bwidt, bheig, bsize, angle, bdist, factor, colour_code, self.__pan_position, 'searching'))
#
# else:
# strOp = ""
#
# if strOp != "":
# self.__logger.info(strOp)
# frame += 1
# time.sleep(0.01)
# except KeyboardInterrupt:
#
# pixy_close()
#
# raise
# except:
# tb = traceback.format_exc()
# e = sys.exc_info()[0]
# print(tb)
# if(self.__motors):
# self.__motors.shutdown()
# raise
def dispose(self):
pixy_close()
args = parser.parse_args()
if not args.session:
parser.print_help()
exit()
session = Session(session=args.session)
if args.simulate:
simulator = Simulator()
ergometer = Ergometer(device=simulator, session=session, log=args.log)
elif args.device:
kettler = Kettler(device=args.device)
ergometer = Ergometer(device=kettler, session=session, log=args.log)
else:
parser.print_help()
exit()
telemetry = Telemetry(ergometer=ergometer, session=session)
try:
telemetry.start()
except(KeyboardInterrupt, SystemExit):
telemetry.running = False
sys.exit()
ergometer.run()
telemetry.running = False
telemetry.join()
class AzureIOTHubDataSender:
def __init__(self, connectionString):
self.CONNECTION_STRING = connectionString
self.MESSAGE_COUNT = 0
self.telemetry = Telemetry()
self.client = self.iothubClientInit()
if self.client.protocol == IoTHubTransportProvider.MQTT:
print ( "IoTHubClient is reporting state" )
reported_state = "{\"newState\":\"standBy\"}"
self.client.send_reported_state(reported_state, len(reported_state), self.sendReportedStateCallback, SEND_REPORTED_STATE_CONTEXT)
self.telemetry.send_telemetry_data(self.parseIOTHubName(self.CONNECTION_STRING), EVENT_SUCCESS, "IoT hub connection is established")
return
def iothubClientInit(self):
# prepare iothub client
client = IoTHubClient(self.CONNECTION_STRING, PROTOCOL)
client.set_option("product_info", "HappyPath_RaspberryPi-Python")
if client.protocol == IoTHubTransportProvider.HTTP:
client.set_option("timeout", TIMEOUT)
client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME)
# set the time until a message times out
client.set_option("messageTimeout", MESSAGE_TIMEOUT)
# to enable MQTT logging set to 1
if client.protocol == IoTHubTransportProvider.MQTT:
client.set_option("logtrace", 0)
# set callback after a message is received
client.set_message_callback(self.receiveMessageCallback, RECEIVE_CONTEXT)
# if MQTT or MQTT_WS is used -> set device twin callback
if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS:
client.set_device_twin_callback(self.deviceTwinCallback, TWIN_CONTEXT)
client.set_device_method_callback(self.deviceMethodCallback, METHOD_CONTEXT)
return client
# Sends the given string to the Azure IOT Hub
def sendStringToIOTHub(self, messageString):
message = IoTHubMessage(messageString)
message.message_id = "message_%d" % self.MESSAGE_COUNT
message.correlation_id = "correlation_%d" % self.MESSAGE_COUNT
self.client.send_event_async(message, self.sendConfirmationCallback, self.MESSAGE_COUNT)
status = self.client.get_send_status()
print ( "Send status: %s" % status )
self.MESSAGE_COUNT += 1
def receiveMessageCallback(self, message, counter):
global RECEIVE_CALLBACKS
message_buffer = message.get_bytearray()
size = len(message_buffer)
print ( "Received Message [%d]:" % counter )
print ( " Data: <<<%s>>> & Size=%d" % (message_buffer[:size].decode("utf-8"), size) )
map_properties = message.properties()
key_value_pair = map_properties.get_internals()
print ( " Properties: %s" % key_value_pair )
counter += 1
RECEIVE_CALLBACKS += 1
print ( " Total calls received: %d" % RECEIVE_CALLBACKS )
return IoTHubMessageDispositionResult.ACCEPTED
def sendConfirmationCallback(self, message, result, user_context):
global SEND_CALLBACKS
print ( "Confirmation[%d] received for message with result = %s" % (user_context, result) )
map_properties = message.properties()
print ( " message_id: %s" % message.message_id )
print ( " correlation_id: %s" % message.correlation_id )
key_value_pair = map_properties.get_internals()
print ( " Properties: %s" % key_value_pair )
SEND_CALLBACKS += 1
print ( " Total calls confirmed: %d" % SEND_CALLBACKS )
def deviceTwinCallback(self, update_state, payload, user_context):
global TWIN_CALLBACKS
print ( "\nTwin callback called with:\nupdateStatus = %s\npayload = %s\ncontext = %s" % (update_state, payload, user_context) )
TWIN_CALLBACKS += 1
print ( "Total calls confirmed: %d\n" % TWIN_CALLBACKS )
def sendReportedStateCallback(self, status_code, user_context):
global SEND_REPORTED_STATE_CALLBACKS
print ( "Confirmation for reported state received with:\nstatus_code = [%d]\ncontext = %s" % (status_code, user_context) )
SEND_REPORTED_STATE_CALLBACKS += 1
print ( " Total calls confirmed: %d" % SEND_REPORTED_STATE_CALLBACKS )
def deviceMethodCallback(self, method_name, payload, user_context):
global METHOD_CALLBACKS,MESSAGE_SWITCH
print ( "\nMethod callback called with:\nmethodName = %s\npayload = %s\ncontext = %s" % (method_name, payload, user_context) )
METHOD_CALLBACKS += 1
print ( "Total calls confirmed: %d\n" % METHOD_CALLBACKS )
device_method_return_value = DeviceMethodReturnValue()
device_method_return_value.response = "{ \"Response\": \"This is the response from the device\" }"
device_method_return_value.status = 200
if method_name == "start":
MESSAGE_SWITCH = True
print ( "Start sending message\n" )
device_method_return_value.response = "{ \"Response\": \"Successfully started\" }"
return device_method_return_value
if method_name == "stop":
MESSAGE_SWITCH = False
print ( "Stop sending message\n" )
device_method_return_value.response = "{ \"Response\": \"Successfully stopped\" }"
return device_method_return_value
return device_method_return_value
def print_last_message_time(self, client):
try:
last_message = client.get_last_message_receive_time()
print ( "Last Message: %s" % time.asctime(time.localtime(last_message)) )
print ( "Actual time : %s" % time.asctime() )
except IoTHubClientError as iothub_client_error:
if iothub_client_error.args[0].result == IoTHubClientResult.INDEFINITE_TIME:
print ( "No message received" )
else:
print ( iothub_client_error )
def parseIOTHubName(self, CONNECTION_STRING):
m = re.search("HostName=(.*?)\.", CONNECTION_STRING)
return m.group(1)
def document_to_telemetry(self, doc):
tel = Telemetry()
tel.set_state(doc['state'])
tel.set_doc_payload(doc["payload"])
tel.set_doc_data(doc["data"])
tel.set_n_data(doc["n_data"])
tel.set_lost_p(doc["lost_p"])
tel.set_l_data(doc["l_data"])
tel.set_p_status(doc["p_status"])
tel.set_obj_id(doc['_id'])
id_timestamp = doc["_id"].generation_time.strftime("%y-%m-%d %H:%M:%S")
tel.set_date(doc.get("date", id_timestamp)) # Compatible with < 0.4.6
return tel
class StraightLineVision():
"""Vision class to handle PixyCam Data"""
COLOUR_WHITE = 1 # White
COLOUR_RED = 2 # Red
COLOUR_BLUE = 3 # Blue
COLOUR_YELLOW = 4 # Yellow
COLOUR_GREEN = 5 # Green
COLOUR_UNKNOWN = -99 # Default
RED_TURN_POSITION = 0
BLUE_TURN_POSITION = 1
YELLOW_TURN_POSITION = 2
GREEN_TURN_POSITION = 3
PIXY_RES_X = 320
PIXY_RES_Y = 200
def __init__(self, steering, motors):
super(StraightLineVision, self).__init__()
self.__steering = steering
self.__motors = motors
self.__logger = Telemetry(self.__class__.__name__, "csv").get()
self.__logger.info(
'Frame, Block Type, Signature, X, Y, Width, Height, Size, Angle, Distance, Factor, MovingFor, Pan Position, Action')
self.__objectHeight = 46 # mm
self.__focalLength = 2.4 # mm
pixy_init()
def initialise(self, visionAttribs, ptc):
self.__visionAttributes = visionAttribs
self.__tilt_position = self.__visionAttributes.startTiltAngle
self.__pan_position = self.__visionAttributes.startPanAngle
self.__prev_pan_position = self.__pan_position
self.__pan_tilt_controller = ptc
self.__pan_tilt_controller.pan_absolute(self.__pan_position)
self.__pan_tilt_controller.tilt_absolute(
self.__tilt_position)
time.sleep(0.01)
def track(self, colour_code):
found = True
blocks = BlockArray(100)
pan_dir = 'straight'
self.__steering.reset()
while found == True:
current_block_position = BlockPosition()
frame = -1
btype = -1
angle = -1
bdist = -1
frame = frame + 1
count = pixy_get_blocks(100, blocks)
strOp = ""
if count > 0:
for index in range(0, count):
current_block_position.colour = blocks[index].signature
btype = blocks[index].type
current_block_position.x = blocks[index].x
current_block_position.y = blocks[index].y
current_block_position.width = blocks[index].width
current_block_position.height = blocks[index].height
current_block_position.size = current_block_position.width * \
current_block_position.height
angle = blocks[index].angle
bdist = (self.__objectHeight *
self.__focalLength) / current_block_position.height
if (int(current_block_position.colour) == int(colour_code)):
if current_block_position.x < ((self.PIXY_RES_X / 2) * 0.9):
pan_dir = 'left'
elif current_block_position.x > ((self.PIXY_RES_X / 2) + (self.PIXY_RES_X / 2 * 0.1)):
pan_dir = 'right'
else:
pan_dir = 'straight'
if((current_block_position.size > self.__visionAttributes.targetMinSize)
and (current_block_position.x > ((self.PIXY_RES_X / 2) - (current_block_position.width)))
and (current_block_position.x < ((self.PIXY_RES_X / 2) + (current_block_position.width)))):
status = "Found colour " + \
str(current_block_position.colour)
centered = True
pan_dir = self.__pan(pan_dir)
self.__motors.move(
1, 1, self.__visionAttributes.topSpeed, True)
else:
status = "Found colour but position not correct| pan: " + pan_dir
centered = False
pan_dir = self.__pan(pan_dir)
action = pan_dir
time.sleep(0.01)
else:
status = "Colour Not Matched| pan:" + pan_dir
action = "tracking"
else:
status = "Pixy didn't get anything" + \
" | pan:" + pan_dir
found = False
strOp = ('%d, %d, %d, %f, %f, %f, %f, %f, %f, %f, %s, %d, %f, %s' % (
frame, btype, current_block_position.colour, current_block_position.x, current_block_position.y, current_block_position.width, current_block_position.height, current_block_position.size, angle, bdist, status, colour_code, self.__pan_position, pan_dir))
self.__logger.info(strOp)
#current_block_position.centered = centered
return current_block_position
def __pan(self, pan_dir, steer=True):
if pan_dir == 'left':
new_pan_position = self.__pan_position + \
(self.__pan_tilt_controller.abs_pan_per_degree * 2)
if self.__pan_position > self.__visionAttributes.maxPanAngle:
pan_dir = 'right'
self.__pan_position = 0
elif pan_dir == 'right':
self.__pan_position = self.__pan_position - \
(self.__pan_tilt_controller.abs_pan_per_degree * 2)
if self.__pan_position < self.__visionAttributes.minPanAngle:
pan_dir = 'left'
self.__pan_position = 0
else:
self.__pan_position = 0
if (self.__pan_position < self.__visionAttributes.maxPanAngle) and (self.__pan_position > self.__visionAttributes.minPanAngle):
# self.__pan_tilt_controller.pan_absolute(
# self.__pan_position)
if steer == True:
self.__steering.steerAbsolute(
self.__pan_position * -2.0)
return pan_dir
def dispose(self):
pixy_close()
parser.add_argument('-t',
'--time',
type=float,
help="Hours to adjunt time zone, ex: -3, +4, etc.")
args = parser.parse_args()
re_sample = re.compile(
r"((?:0x....,){2}(?:0x0043,){3}0x000.,(?:0x....,){6,8})(?=(?:0x....,){2}(?:0x0043,){3}0x000.)"
)
# The file name is the first and only parameter
fname = args.file[0]
#fname = "../data/20180614-DIA/SUCHAI_20180614_130248.txt"
# The Object that parses the telemetry
tm = Telemetry(date=time.asctime())
tm.set_payload(str(3))
# Read the file and
lines = []
with open(fname) as datafile:
for line in datafile:
# Delete the debug information, type and number like: "[2018-09-10 13:55:08.296842][tm] 0x0300,0xFFA0,"
lines.append(line[47:])
# Apply the regexp to find samples like
# "0x24E3,0x4A54,0x0043,0x0043,0x0043,0x0005,0x0003,0x0036,0x0002,0x0047,0x0002,0x004F,0x0000,0x000A,"
# The regexp is evaluated over plain string, replacing \n by ","
# The regexp itself filter incomplete frames ;)
lines = "".join(lines)
lines = lines.replace("\n", ",")
# global counters
RECEIVE_CALLBACKS = 0
SEND_CALLBACKS = 0
BLOB_CALLBACKS = 0
TWIN_CALLBACKS = 0
SEND_REPORTED_STATE_CALLBACKS = 0
METHOD_CALLBACKS = 0
EVENT_SUCCESS = "success"
EVENT_FAILED = "failed"
# chose HTTP, AMQP or MQTT as transport protocol
PROTOCOL = IoTHubTransportProvider.MQTT
# String containing Hostname, Device Id & Device Key in the format:
# "HostName=<host_name>;DeviceId=<device_id>;SharedAccessKey=<device_key>"
telemetry = Telemetry()
def is_correct_connection_string():
m = re.search("HostName=.*;DeviceId=.*;", CONNECTION_STRING)
if m:
return True
else:
return False
CONNECTION_STRING = config.IOT_CONNECTION_STRING
if not is_correct_connection_string():
print("Device connection string is not correct.")
telemetry.send_telemetry_data(
class Main():
ub = UltraBorg3.UltraBorg()
tb = ThunderBorg3.ThunderBorg()
MODE_STRAIGHT_LINE_SPEED = 0
MODE_OVER_THE_RAINBOW = 1
MODE_MAZE_SOLVE = 2
MODE_DERANGED_GOLF = 3
MODE_DUCK_SHOOT = 4
MODE_OBSTACLE_COURSE = 5
MODE_PI_NOON = 6
MODE_TEST = 99
mode = MODE_OBSTACLE_COURSE
def __init__(self):
self.ub.Init()
self.tb.Init()
self.t1 = datetime.now()
self.tickSpeed = 0.05
self.us = Ultrasonics(self.ub)
self.motors = Motors(self.tb, self.ub, self.tickSpeed)
self.steering = Steering(self.tb, self.ub, self.tickSpeed)
self.teleLogger = Telemetry("telemetry", "csv").get()
self.ptc = PanTiltController(self.ub, 270, 135)
self.joystick_controller = JoystickController(self.tb, self.ub)
battMin, battMax = self.tb.GetBatteryMonitoringLimits()
battCurrent = self.tb.GetBatteryReading()
print('Battery monitoring settings:')
print(' Minimum (red) %02.2f V' % (battMin))
print(' Half-way (yellow) %02.2f V' % ((battMin + battMax) / 2))
print(' Maximum (green) %02.2f V' % (battMax))
print()
print(' Current voltage %02.2f V' % (battCurrent))
print(' Mode %s' % (self.mode))
print()
def log(self):
if (self.motors.speed != 0):
self.teleLogger.info(
'%(left)f, %(front)f, %(right)f, %(back)f, %(distanceMoved)f, %(forwardSpeed)f, %(direction)s, %(degree)f, %(ratio)f',
{
"left": self.us.left,
"front": self.us.front,
"right": self.us.right,
"back": self.us.back,
"distanceMoved": self.motors.distanceMoved,
"forwardSpeed": self.motors.forwardSpeed,
"direction": self.steering.going,
"degree": self.steering.steeringPosition,
"ratio": self.steering.sideRatio
})
def run(self):
try:
if (self.mode == self.MODE_STRAIGHT_LINE_SPEED):
print("Straight line speed")
self.modeStraightLineSpeed()
elif (self.mode == self.MODE_OVER_THE_RAINBOW):
print("Rainbow")
self.modeOverTheRainbow()
elif (self.mode == self.MODE_DERANGED_GOLF
or self.mode == self.MODE_PI_NOON
or self.mode == self.MODE_OBSTACLE_COURSE):
print("Joystick control: " + str(self.mode))
self.joystick_controller.run()
else:
# Wait for Buttons
print('Pan -62 = ' + str(self.ptc.pan(-62)))
time.sleep(1)
print('Pan 0 = ' + str(self.ptc.pan(0)))
time.sleep(1)
#
# print('Pan 62 = ' + str(self.ptc.pan(62)))
# time.sleep(1)
#
# print('Pan absolute 1.0 = ' + str(self.ptc.pan_absolute(1.0)))
# time.sleep(1)
#
# print('Pan absolute -1.0 = ' + str(self.ptc.pan_absolute(-1.0)))
# time.sleep(1)
#
# print('Pan absolute 0.0 = ' + str(self.ptc.pan_absolute(0.0)))
# time.sleep(1)
#
# print('Tilt -30 = ' + str(self.ptc.tilt(-30)))
# time.sleep(1)
# print('Tilt 0 = ' + str(self.ptc.tilt(0)))
# time.sleep(1)
#
# print('Tilt 30 = ' + str(self.ptc.tilt(30)))
# time.sleep(1)
#
# print('Tilt absolute 0.6 = ' + str(self.ptc.tilt_absolute(0.6)))
# time.sleep(1)
#
# print('Tilt absolute -0.6 = ' +
# str(self.ptc.tilt_absolute(-0.6)))
# time.sleep(1)
#
# print('Tilt absolute 0.0 = ' + str(self.ptc.tilt_absolute(0.0)))
# time.sleep(1)
except KeyboardInterrupt:
# User has pressed CTRL+C
self.ub.SetServoPosition2(0)
t2 = datetime.now()
delta = t2 - self.t1
print("Run complete in : " + str(delta.total_seconds()))
print('Done')
if (self.motors):
self.motors.shutdown()
except Exception as e:
tb = traceback.format_exc()
e = sys.exc_info()[0]
print(tb)
if (self.motors):
self.motors.shutdown()
def modeStraightLineSpeed(self):
self.straight_line_speed = StraightLineVision(self.steering,
self.motors)
self.teleLogger.info(
'left, front, right, back, distanceMoved, forwardSpeed, direction, steering position, ratio'
)
self.steering.reset()
slVa = VisionAttributes()
slVa.startTiltAngle = 0.6
slVa.startPanAngle = 0
slVa.targetMinSize = 1000
slVa.targetMaxSize = 18000
slVa.minPanAngle = -0.5
slVa.maxPanAngle = 0.5
slVa.colour = Vision.COLOUR_WHITE
slVa.targetColorPattern = Vision.COLOUR_WHITE
slVa.topSpeed = 0.6
slVa.topSpinSpeed = 1.0
self.ptc.tilt(0.5)
slsPtc = PanTiltController(self.ub, 270, 135)
slsPtc.initPanServo(5000, 1000)
self.straight_line_speed.initialise(slVa, slsPtc)
self.motors.stop()
prev_block_position = None
t1 = datetime.now()
self.straight_line_speed.track(self.straight_line_speed.COLOUR_WHITE)
t2 = datetime.now()
delta = t2 - self.t1
print("Run complete in: " + str(delta.total_seconds()))
def modeOverTheRainbow(self):
self.vision = Vision(self.steering, self.motors)
slVa = VisionAttributes()
slVa.startTiltAngle = 0.12
slVa.startPanAngle = -1.00
slVa.targetMinSize = 20
slVa.targetMaxSize = 2200
slVa.minPanAngle = -1.0
slVa.maxPanAngle = 1.0
slVa.targetColorPattern = Vision.COLOUR_WHITE
slVa.topSpeed = 1.0
slVa.topSpinSpeed = 1.0
self.motors.move(-1, -1, 0.3)
time.sleep(0.8)
self.motors.stop()
rainbowPtc = PanTiltController(self.ub, 270, 135)
rainbowPtc.initPanServo(5000, 1000)
self.vision.initialise(slVa, rainbowPtc)
time.sleep(0.5)
self.vision.scan()
print("Scan Complete")
index = 0
prev_position = 0
for ball_position in self.vision.ball_positions:
ball_position = self.vision.ball_positions[0]
print("Size: " + str(ball_position.size) + ', x :' +
str(ball_position.x) + ', y :' + str(ball_position.y) +
', pan-position :' + str(ball_position.pan_position) +
', angle : ' + str(ball_position.pan_position * 135) +
', Colour:' + str(ball_position.colour))
if (index > 0):
prev_position = self.vision.ball_positions[index -
1].pan_position
index = index + 1
self.vision.goto_ball_position(ball_position, prev_position)
def calculateFuelConsumption(self, speed, maf, timestamp):
mpg = (14.7 * 6.17 * 454 * speed * 0.621371) / (
3600 * maf) # DRIVER’S EFFICIENCY ANALYZER
litersPer100km = 282.5 / mpg
return Telemetry("CONSUMPTION", litersPer100km,
"liters_per_100_kilometers", timestamp)
id_timestamp = doc["_id"].generation_time.strftime("%y-%m-%d %H:%M:%S")
tel.set_date(doc.get("date", id_timestamp)) # Compatible with < 0.4.6
return tel
db_server = "localhost"
db_port = 27017
mongo_client = MongoClient(db_server, db_port)
db = mongo_client.suchai1_tel_database
names = db.collection_names()
for i in range(0, len(names)):
payloads = list(Telemetry.dictPayload.keys())
for j in range(0, len(payloads)):
if names[i] == payloads[j]:
update_telemetry_from_collection(Telemetry.get_collection_with_payload(mongo_client, Telemetry.dictPayload[payloads[j]]))
lagmuir_finished = []
lagmuir_others = []
for k in telemetries.keys():
if telemetries[k].payload == Telemetry.dictPayload['lagmuirProbe']:
if telemetries[k].state == 2:
lagmuir_finished.append(telemetries[k])
else:
lagmuir_others.append(telemetries[k])
for tel in lagmuir_finished:
df = tel.to_dataframe()
if 'time' in df.columns and len(df['time']) > 0:
date_string = (df.iloc[0]['time']).strftime("%Y-%m-%d_%H:%M:%S")
else:
counter += 1
rpm += 250
print(counter)
elif(data == 'c'):
counter = 0
rpm = 0
print(" Throttle", end="\nRPM")
fmt = "{:<9}" * (len(throttle_indexs) + 1)
print(fmt.format("", *throttle_indexs))
for i in range(0,430*2,20):
print("{:05} {}".format(rpm, [f'{unpack("<h", matrix.tobytes()[i:i+20][j:j+2])[0]:05}' for j in range(0, 20, 2)]))
counter += 1
rpm += 250
print(counter)
elif(data == 'i'):
if(not toggle):
print("Reading realtime data")
thread = Telemetry(ser)
thread.start()
toggle = not toggle
else:
print("Stopping telemetry")
thread.stop()
toggle = not toggle
else:
ser.write(str.encode(data))
print("Closing Serial comunication!")
ser.close()
default=N_MESSAGES,
help="how many messages to send")
parser.add_argument("-s",
"--size",
type=int,
default=MESSAGE_SIZE,
help="how big is each message in bytes")
parser.add_argument("-r",
"--rate",
type=int,
default=MESSAGE_RATE,
help="message send rate in Hertz")
args = parser.parse_args()
# create and connect to telemetry radio
transmitter = Telemetry()
firstMessage = True
estimatedTime = float(args.number) / float(args.rate)
startWrite = 0
totalWriteTime = 0
print "sending {} messages at {} Hz".format(args.number, args.rate)
print "estimated minimum total time (with message send time of 0): {} seconds".format(
estimatedTime)
print "receiver should receive {} bytes in total".format(args.number *
args.size)
startTime = time()
for m in range(args.number):
startWrite = time()
transmitter.write("x" * args.size)
totalWriteTime = time() - startWrite
def _process_tm(self, data):
ts = datetime.datetime.now(
datetime.timezone.utc).strftime("%y-%m-%d %H:%M:%S")
# Fix data ending with commands (Issue #4)
# This fix was added for compatibily with versions < 0.4.6 and can
# be removed in the future
if data[-1] == "," or data[-1] == "\n":
data = data[:-1]
# Split comma separated values
data = data.split(',')
# 1. Parse frames
# Header in all frames
t_frame = data[0] # type of frame
n_frame = data[1] # number of frame
# Header in all frames of type 0x1000 (Start) or 0x4000 (Simple)
t_data = data[2] # Type of payload
# Header in payloads frames (not tm_estado) of type 0x1000 (Start)
l_data = data[3] # length of data
p_status = data[4] # payload status
# 2. Parse data
_data_start = data[
5:] # data in frames 0x1000 (Start) and 0x4000 (Simple)
_data_conti = data[
2:] # data in frames 0x3000 (Conti) and 0x2000 (End)
# 3. Build telemetry
if t_frame == "0x0100" or t_frame == "0x0400": # it is a new frame o 0x4000
# First check if the last telemetry is alright
if len(self.telemetries) != 0:
# check if the last telemetry is finished
key, last_tel = self.telemetries.popitem()
if last_tel.get_state() != 2:
last_tel.set_state(3) # broken
self.telemetries[key] = last_tel
# Append a new telemetry
tel = Telemetry(date=ts)
tel.set_payload(t_data)
# Fix tm_estado simple vs tm_estado payload
# HACK: in tm_estado simple l_data=data[3] is the first data in the
# frame and can be only 0 or 1, but in tm_estado payload l_data is a
# big number > 1
is_simple_estado = tel.get_payload() == 0 and int(l_data, 16) <= 1
# Case simple tm_estado frame
if is_simple_estado:
tel.set_l_data("0x0001")
tel.set_p_status("0x0004")
# Fix tm_estado simple header to match payload format
# Add dummy [Time1,Time2]
tel.set_data(["0x0000", "0x0000"] + data[3:], n_frame)
# Case normal payload frame
else:
tel.set_l_data(l_data)
tel.set_p_status(p_status)
tel.set_data(_data_start, n_frame)
# Change status to received more frames
if t_frame == "0x0400":
tel.set_state(2) # Finished status
else:
tel.set_state(1) # Ongoing status
# Save current telemetry to DB
tel.save(self.mongo_client)
self.telemetries[tel.get_obj_id()] = tel
elif t_frame == "0x0200": # it is an ending frame
if len(self.telemetries
) != 0: # if this is not true something is wrong
key, tel = self.telemetries.popitem()
tel_state = tel.get_state()
# if the last frame was in progress (1) mark as finished,
# add new data and return element to list
if tel_state == 1:
tel.set_state(2) # mark finished
tel.set_data(_data_conti, n_frame)
tel.save(self.mongo_client)
self.telemetries[key] = tel
# if the last frame was finished, create a new one marked as
# broken and store in the list
elif tel_state == 2:
tel = Telemetry(date=ts)
tel.set_data(_data_conti, n_frame)
tel.set_state(3) # Mark broken
tel.save(self.mongo_client)
self.telemetries[tel.get_obj_id()] = tel
# other cases (borken, empty, etc), mark as broken, add new data
# and restore element to list
else:
tel.set_state(3) # mark broken
tel.set_data(_data_conti, n_frame)
tel.save(self.mongo_client)
self.telemetries[key] = tel
elif t_frame == "0x0300": # it is an ongoing frame
if len(self.telemetries
) != 0: # if this is not true something is wrong
key, tel = self.telemetries.popitem()
if tel.get_state() in (1, 3): # In progress or broken
tel.set_data(_data_conti, n_frame) # Update
tel.save(self.mongo_client) # Save
self.telemetries[key] = tel # Return to list
else: # tel.get_state() == 2: # last frame has finished
tel = Telemetry(date=ts) # New
tel.set_data(_data_conti, n_frame) # Update
tel.set_state(3) # Mark as broken
tel.save(self.mongo_client) # Save
self.telemetries[tel.get_obj_id()] = tel # Add to list
self.update_telemetry_table()
# global counters
RECEIVE_CALLBACKS = 0
SEND_CALLBACKS = 0
BLOB_CALLBACKS = 0
TWIN_CALLBACKS = 0
SEND_REPORTED_STATE_CALLBACKS = 0
METHOD_CALLBACKS = 0
EVENT_SUCCESS = "success"
EVENT_FAILED = "failed"
# chose HTTP, AMQP or MQTT as transport protocol
PROTOCOL = IoTHubTransportProvider.MQTT
# String containing Hostname, Device Id & Device Key in the format:
# "HostName=<host_name>;DeviceId=<device_id>;SharedAccessKey=<device_key>"
telemetry = Telemetry()
if len(sys.argv) < 2:
print(
"You need to provide the device connection string as command line arguments."
)
telemetry.send_telemetry_data(None, EVENT_FAILED,
"Device connection string is not provided")
sys.exit(0)
def is_correct_connection_string():
m = re.search("HostName=.*;DeviceId=.*;", CONNECTION_STRING)
if m:
return True
else:
# global counters
RECEIVE_CALLBACKS = 0
SEND_CALLBACKS = 0
BLOB_CALLBACKS = 0
TWIN_CALLBACKS = 0
SEND_REPORTED_STATE_CALLBACKS = 0
METHOD_CALLBACKS = 0
EVENT_SUCCESS = "success"
EVENT_FAILED = "failed"
# chose HTTP, AMQP or MQTT as transport protocol
PROTOCOL = IoTHubTransportProvider.MQTT
# String containing Hostname, Device Id & Device Key in the format:
# "HostName=<host_name>;DeviceId=<device_id>;SharedAccessKey=<device_key>"
telemetry = Telemetry()
if len(sys.argv) < 4:
print ( "You need to provide the device <type>, <id>, <connection string> as command line arguments." )
telemetry.send_telemetry_data(None, EVENT_FAILED, "Device connection string is not provided")
sys.exit(0)
def is_correct_connection_string():
m = re.search("HostName=.*;DeviceId=.*;", CONNECTION_STRING)
if m:
return True
else:
return False
DEVICE_TYPE = sys.argv[1]
DEVICE_ID = sys.argv[2]
CONNECTION_STRING = sys.argv[3]