def __init__(self, thunderBorgInstance, ultraBorgInstance, tickSpeed):
self.tb = thunderBorgInstance
self.ub = ultraBorgInstance
self.logger = Telemetry(self.__class__.__name__, "log").get()
self.going = 'straight'
self.__defaultTurnRatio = 0.16
self.steeringPosition = 0
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 main(self):
multiprocessing.Semaphore(2)
_worker = None
_connectionFailureCount = 0
_connected = False
commandDictionary = {
PidTypes.SPEED: obd.commands.SPEED,
PidTypes.FUEL_LEVEL: obd.commands.FUEL_LEVEL,
PidTypes.RPM: obd.commands.RPM,
PidTypes.MAF: obd.commands.MAF,
PidTypes.RUN_TIME: obd.commands.RUN_TIME
}
while _connected == False:
if (_connectionFailureCount > 0):
time.sleep(randint(0, (2 ** _connectionFailureCount) - 1))
try:
ports = obd.scan_serial()
connection = obd.OBD(ports[0])
_connected = True
except:
_connectionFailureCount += 1
while True and _connected == True:
if self._helper.api_service_is_on() == True:
_worker = multiprocessing.Process(target=self.apiWorker, args=())
else:
_worker = multiprocessing.Process(target=self.logWorker, args=())
_worker.start()
speedForFuelConsumption = None
mafForFuelConsumption = None
timestampForFuelConsumption = None
for key in commandDictionary:
response = connection.query(commandDictionary[key], force=True)
if response.value != None:
digitResponse = self._helper.getNumberFromString(str(response.value))
if key == 1:
speedForFuelConsumption = digitResponse
if key == 4:
mafForFuelConsumption = digitResponse
timestampForFuelConsumption = response.time
telemetry = Telemetry(key.name, digitResponse, Units(key.value).name, response.time)
self._telemetryQueue.put(telemetry)
self._logQueue.put(telemetry)
if speedForFuelConsumption != None and mafForFuelConsumption != None and timestampForFuelConsumption != None:
fuelConsumptionTelemetry = self._helper.calculateFuelConsumption(speedForFuelConsumption, mafForFuelConsumption, timestampForFuelConsumption)
self._telemetryQueue.put(fuelConsumptionTelemetry)
self._logQueue.put(fuelConsumptionTelemetry)
def __init__(self, thunderBorgInstance, ultraBorgInstance, tickSpeed):
self.tb = thunderBorgInstance
self.ub = ultraBorgInstance
self.tickSpeed = tickSpeed
self.safeDistance = 500 # mm
self.steeringPosition = 0.0
self.logger = Telemetry(self.__class__.__name__, "log").get()
self.ub.SetServoPosition4(self.steeringPosition)
if not self.tb.foundChip:
boards = ThunderBorg.ScanForThunderBorg()
if len(boards) == 0:
self.logger.info(
'No ThunderBorg found, check you are attached :)')
else:
self.logger.info(
"No ThunderBorg at address %02X, but we did find boards:" %
(self.tb.i2cAddress))
for board in boards:
print(' %02X (%d)' % (board, board))
self.logger.info(
'If you need to change the I2C address change the setup line so it is correct, e.g.'
)
self.logger.info('self.tb.i2cAddress = 0x%02X' % (boards[0]))
sys.exit()
# Ensure the communications failsafe has been enabled!
failsafe = False
for i in range(5):
self.tb.SetCommsFailsafe(True)
failsafe = self.tb.GetCommsFailsafe()
if failsafe:
break
if not failsafe:
self.logger.info('Board %02X failed to report in failsafe mode!' %
(self.tb.i2cAddress))
sys.exit()
self.driveRight = 1.0
self.driveLeft = 1.0
# Power settings
# Total battery voltage to the ThunderBorg
self.voltageIn = 3.7 * 4
# Maximum motor voltage, we limit it to 95% to allow the RPi to get uninterrupted power
self.voltageOut = self.voltageIn * 0.95
# Setup the power limits
if self.voltageOut > self.voltageIn:
self.maxPower = 0.5
else:
self.maxPower = self.voltageOut / float(self.voltageIn)
self.speed = self.maxPower
self.tb.MotorsOff()
self.center()
def test(self):
multiprocessing.Semaphore(1)
_worker = multiprocessing.Process(target=self.apiWorker, args=())
with open("testSet.json") as file:
telemetries = json.load(file)
for telemetry in telemetries:
self._telemetryQueue.put(Telemetry(telemetry['pidType'], telemetry['pidValue'], telemetry['unit'], telemetry['timestamp']))
_worker.start()
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 test_url(self):
tel = Telemetry()
question = {
'id': 1,
'title': 'telemetry test',
'observable':
'https://stackoverflow.com/questions/11624190/python-convert-string-to-byte-array',
'observable_type': 'U',
'begin_datetime': '2019-07-01T14:34:19Z',
'end_datetime': '2019-07-10T14:34:19Z',
'max_rounds': 1,
'algorithm': 'M',
'params': '{"p":0.1}',
'completed': False
}
(status, count) = tel.handle_observable(question)
self.assertEqual(status, 'OK')
self.assertGreater(count, 0)
question = {
'id': 1,
'title': 'telemetry test',
'observable': 'https://www.gotomeet.me/auth/gateway',
'observable_type': 'U',
'begin_datetime': '2019-07-01T14:34:19Z',
'end_datetime': '2019-07-10T14:34:19Z',
'max_rounds': 1,
'algorithm': 'M',
'params': '{"p":0.1}',
'completed': False
}
(status, count) = tel.handle_observable(question)
self.assertEqual(status, 'OK')
self.assertGreater(count, 0)
question = {
'id': 1,
'title': 'telemetry test',
'observable': 'https://mail.google.com/mail/u/1/?pli=1',
'observable_type': 'U',
'begin_datetime': '2019-07-01T14:34:19Z',
'end_datetime': '2019-07-10T14:34:19Z',
'max_rounds': 1,
'algorithm': 'M',
'params': '{"p":0.1}',
'completed': False
}
(status, count) = tel.handle_observable(question)
self.assertEqual(status, 'OK')
self.assertGreater(count, 0)
def test_domain(self):
tel = Telemetry()
question = {
'id': 1,
'title': 'telemetry test',
'observable': 'google.com',
'observable_type': 'D',
'begin_datetime': '2019-07-01T14:34:19Z',
'end_datetime': '2019-07-10T14:34:19Z',
'max_rounds': 1,
'algorithm': 'M',
'params': '{"p":0.1}',
'completed': False
}
(status, count) = tel.handle_observable(question)
self.assertEqual(status, 'OK')
self.assertGreater(count, 0)
question = {
'id': 1,
'title': 'telemetry test',
'observable': 'stackexchange.com',
'observable_type': 'D',
'begin_datetime': '2019-07-01T14:34:19Z',
'end_datetime': '2019-07-10T14:34:19Z',
'max_rounds': 1,
'algorithm': 'M',
'params': '{"p":0.1}',
'completed': False
}
(status, count) = tel.handle_observable(question)
self.assertEqual(status, 'OK')
self.assertGreater(count, 0)
question = {
'id': 1,
'title': 'telemetry test',
'observable': 'github.com',
'observable_type': 'D',
'begin_datetime': '2019-07-01T14:34:19Z',
'end_datetime': '2019-07-10T14:34:19Z',
'max_rounds': 1,
'algorithm': 'M',
'params': '{"p":0.1}',
'completed': False
}
(status, count) = tel.handle_observable(question)
self.assertEqual(status, 'OK')
self.assertGreater(count, 0)
def test_IP(self):
tel = Telemetry()
question = {
'id': 1,
'title': 'telemetry test',
'observable': '127.0.0.1',
'observable_type': 'I',
'begin_datetime': '2019-07-01T14:34:19Z',
'end_datetime': '2019-07-10T14:34:19Z',
'max_rounds': 1,
'algorithm': 'M',
'params': '{"p":0.1}',
'completed': False
}
(status, count) = tel.handle_observable(question)
self.assertEqual(status, 'OK')
self.assertGreater(count, 0)
question = {
'id': 1,
'title': 'telemetry test',
'observable': '0.0.0.0',
'observable_type': 'I',
'begin_datetime': '2019-07-01T14:34:19Z',
'end_datetime': '2019-07-10T14:34:19Z',
'max_rounds': 1,
'algorithm': 'M',
'params': '{"p":0.1}',
'completed': False
}
(status, count) = tel.handle_observable(question)
self.assertEqual(status, 'OK')
self.assertEqual(count, 0)
question = {
'id': 1,
'title': 'telemetry test',
'observable': '140.82.114.25',
'observable_type': 'I',
'begin_datetime': '2019-07-01T14:34:19Z',
'end_datetime': '2019-07-10T14:34:19Z',
'max_rounds': 1,
'algorithm': 'M',
'params': '{"p":0.1}',
'completed': False
}
(status, count) = tel.handle_observable(question)
self.assertEqual(status, 'OK')
self.assertGreater(count, 0)
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
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 parse_mmf(self):
self.offset_area = 0
self.set_offset()
data = Telemetry()
self.first_area(data)
self.second_area(data)
self.third_area(data)
self.fourth_area(data)
self.fifth_area(data)
self.sixth_area(data)
self.seventh_area(data)
self.eighth_area(data)
self.ninth_area(data)
self.tenth_area(data)
self.eleventh_area(data)
return data
def main():
# parser is an object that holds the command line argument options
parser = ArgumentParser()
# Enables to serve test web page for back-end.
parser.add_argument("-t", "--test", action="store_true")
# Enables to boot up the APRS server
parser.add_argument("-A", "--aprs", action="store_true")
# Enables to boot up the telemetry server
parser.add_argument("-T", "--telemetry", action="store_true")
# Parse command line arguments
args = parser.parse_args()
# Read configuration file
config = ConfigParser()
config.read("config.cfg")
# Lock for synchronized logging
lock = Lock()
# Prevents from overwriting existing files
log_num = 0
while os.path.exists("telemetry-%03d.log" % log_num):
log_num += 1
log = open("telemetry-%03d.log" % log_num, "w")
threads = []
if args.aprs:
aprs_rx = int(config.get("Ports", "aprs_rx"))
server = AprsReceiver("127.0.0.1", aprs_rx, sio, lock, log)
thread = threading.Thread(target=server.listen)
thread.daemon = True
threads.append(thread)
if args.telemetry:
telemetry_rx = int(config.get("Ports", "telemetry_rx"))
server = Telemetry("127.0.0.1", telemetry_rx, sio, lock, log)
thread = threading.Thread(target=server.listen)
thread.daemon = True
threads.append(thread)
# Use socketio as middleware is test flag is false
if args.test == False:
global app
app = socketio.Middleware(sio)
# Start up all servers
for thread in threads:
thread.start()
port = int(config.get("Ports", "main_tx"))
try:
# Sets the server to listen on a specific port for incoming
# connections
eventlet.wsgi.server(eventlet.listen(('', port)),
app,
log_output=False)
except KeyboardInterrupt:
pass
log.close()
print("end")
return
from time import sleep, time_ns
from json import dumps
from kafka import KafkaProducer
from telemetry import Telemetry
from random import random
producer = KafkaProducer(bootstrap_servers=['localhost:9092'],
value_serializer=lambda x: dumps(x).encode('utf-8'))
try:
while True:
inputData = random() * 100
data = Telemetry('12de34', str(inputData), time_ns())
producer.send('test', value=data)
producer.flush()
sleep(5)
finally:
producer.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
"""
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()
# 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:
return False
CONNECTION_STRING = sys.argv[1]
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()
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)
#from chassis import Chassis
from telemetry import Telemetry
from chassis import Chassis
#192.168.1.107
IP_ADDRESS = '10.0.0.22'
PORT = 65432
SSID = 'utmresak'
telemetry = Telemetry(IP_ADDRESS, PORT, 'wlan0', SSID)
chassis = Chassis()
while True:
connected = telemetry.ping()
if not connected: #failsafe condition
chassis.stop_all(
) #for extra safety but technically redundant as telemetry.speed is set to 0 failsafe condition
telemetry.get_connection(IP_ADDRESS, PORT)
chassis.drive(int(telemetry.speed * 100))
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", ",")
rmq_host = (len(sys.argv) > 1) and sys.argv[1] or os.environ.get(
"RMQ_PORT_5672_TCP_ADDR", "feed")
# pause between each message (0.000002 ~8k/s)
sleep_time = (len(sys.argv) > 2) and sys.argv[2] or os.environ.get(
"DELAY_MESS", 0.5)
# object identifier (car-a, car-b, etc...)
vin = (len(sys.argv) > 3) and sys.argv[3] or 'VIN{}'.format(vin_generator())
try:
client = mqtt.Client()
client.username_pw_set(rmq_user, password=rmq_pass)
client.connect(rmq_host)
for data in Telemetry():
input_mess = {
'VIN': vin,
'time': datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
}
input_mess['telemetry'], input_mess['gps'] = data
client.publish(topic="mqtt.device.telemetry",
payload=json.dumps(input_mess),
qos=0)
#from pprint import pprint
#pprint(input_mess)
time.sleep(float(sleep_time))
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()