def parse_data(self):
logger.info('GPS: reading and parsing a line of NMEA data')
data = self.gps.readline()
# convert data to string to parse into list
data_string = "".join([chr(b) for b in data])
data_list = data_string.split(',')
# parse NMEA sentence
parsed_data = []
if data_list[0] == '$GPRMC':
# get longitude
print(type(data_list[4]))
if data_list[4] == 'S':
parsed_data.append((float(data_list[3]) / 10 / 10) * -1)
else:
parsed_data.append((float(data_list[3]) / 10 / 10))
# get latitude
if data_list[6] == 'W':
parsed_data.append((float(data_list[5]) / 10 / 10) * -1)
else:
parsed_data.append((float(data_list[5]) / 10 / 10))
logger.info(parsed_data)
return parsed_data
def test_simple_launch(setup_active_vessel, krpc_connect):
vessel = setup_active_vessel
conn = krpc_connect
logger.info("Initiating Simple Launch sequence")
success = simple_launch(conn, vessel)
assert success
conn.close()
async def periodic():
while True:
if not api.get_clock().is_open:
logger.info('exit as market is not open')
sys.exit(0)
await asyncio.sleep(30)
positions = api.list_positions()
pos = [p for p in positions if p.symbol == args.symbol]
scalp.checkup(pos[0] if len(pos) > 0 else None)
def begin(self):
logger.info('Start camera. Open Video Capture object')
if not self.cap.isOpened():
self.cap.open(self.gstreamer_pipeline(), cv2.CAP_GSTREAMER)
logger.info('Starting thread for video capture')
if not hasattr(self, 'thread') or not self.thread.isAlive():
self.thread = threading.Thread(target=self._capture)
self.thread.start()
def __init__(self):
logger.info('MPU: Opening i2c device @/dev/i2c-1, addr 0x68')
self.device = pylibi2c.I2CDevice('/dev/i2c-1', 0x68)
self.device.delay = 10
self.device.page_bytes = 8
self.device.flags = pylibi2c.I2C_M_IGNORE_NAK
time.sleep(3)
logger.info('MPU: disabling sleep mode')
i2cdev.setSleepMode(self.device, enabled=0)
self.gyro_cal_x = 0
self.gyro_cal_y = 0
self.gyro_cal_z = 0
def view(self):
if not hasattr(self, 'thread_2') or not self.thread_2.isAlive():
logger.info('Starting live view')
# Create window and configure it
cv2.namedWindow(self.window_name, cv2.WINDOW_NORMAL)
cv2.resizeWindow(self.window_name, 640, 480)
cv2.moveWindow(self.window_name, 0, 0)
cv2.setWindowTitle(self.window_name, 'Live View')
font = cv2.FONT_HERSHEY_PLAIN
self.thread_2 = threading.Thread(target=self._view)
self.thread_2.start()
def calibrate(self):
logger.info('MPU: calibrating gyroscope')
for i in range(500):
self.gyro_cal_x += self.read_gyro_x()
self.gyro_cal_y += self.read_gyro_y()
self.gyro_cal_z += self.read_gyro_z()
#print(self.gyro_cal_x)
#print(self.gyro_cal_y)
#print(self.gyro_cal_z)
self.gyro_cal_x /= 1000
self.gyro_cal_y /= 1000
self.gyro_cal_z /= 1000
print(self.gyro_cal_x)
print(self.gyro_cal_y)
print(self.gyro_cal_z)
def end(self):
logger.info('Stopping camera. Released Video Capture object')
if hasattr(self, 'cap'):
self.cap.release()
logger.info('Joining video capture thread')
if hasattr(self, 'thread'):
self.thread.join()
if hasattr(self, 'thread_2'):
logger.info('Joining live view thread')
self.thread_2.join()
logger.info('Closing window(s) and de-alloc any assoc. memory')
cv2.destroyAllWindows()
def main(args):
logger.info("Inside main function")
api = alpaca.REST()
stream = alpaca.StreamConn()
logger.info("Instantiating scalp object with arguments ...")
scalp = algo.Algo(api=api, symbol=args.symbol, lot=args.lot)
@stream.on(r'^AM')
async def on_bars(conn, channel, data):
scalp.on_bar(data)
@stream.on(r'trade_updates')
async def on_trade_updates(conn, channel, data):
logger.info(f'trade_updates {data}')
symbol = data.order['symbol']
if symbol == args.symbol:
scalp.on_order_update(data.event, data.order)
async def periodic():
while True:
if not api.get_clock().is_open:
logger.info('exit as market is not open')
sys.exit(0)
await asyncio.sleep(30)
positions = api.list_positions()
pos = [p for p in positions if p.symbol == args.symbol]
scalp.checkup(pos[0] if len(pos) > 0 else None)
channels = ['trade_updates', args.symbol]
loop = stream.loop
loop.run_until_complete(
asyncio.gather(
stream.subscribe(channels),
periodic(),
))
async def on_trade_updates(conn, channel, data):
logger.info(f'trade_updates {data}')
symbol = data.order['symbol']
if symbol == args.symbol:
scalp.on_order_update(data.event, data.order)
await asyncio.sleep(30)
positions = api.list_positions()
pos = [p for p in positions if p.symbol == args.symbol]
scalp.checkup(pos[0] if len(pos) > 0 else None)
channels = ['trade_updates', args.symbol]
loop = stream.loop
loop.run_until_complete(
asyncio.gather(
stream.subscribe(channels),
periodic(),
))
if __name__ == '__main__':
fmt = '%(asctime)s:%(filename)s:%(lineno)d:%(levelname)s:%(name)s:%(message)s'
# logger.basicConfig(level=logging.INFO, format=fmt)
logger.setLevel(logging.INFO)
fh = logging.FileHandler('test.log')
fh.setFormatter(logging.Formatter(fmt))
logger.addHandler(fh)
parser = argparse.ArgumentParser()
parser.add_argument('symbol', nargs='+')
parser.add_argument('--lot', type=float, default=2000)
logger.info("Calling main ....")
main(parser.parse_args())
def _set_update_rate(self, rate=1000):
# Packet type 220 PMTK_SET_NMEA_UPDATERATE
# Unit milliseconds
logger.info('GPS: setting update rate to 1 Hz')
self.gps.send_command(b"PMTK220, 1000") # 1 Hz
def readByte(i2cdevice, reg_addr):
# read 1 byte starting from reg_addr
logger.info('Reading 1 byte starting from %x' % reg_addr)
return i2cdevice.ioctl_read(reg_addr, 1)
cv2.imshow(self.window_name, self.image)
# if user hits 'q' key, close window
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# if capture is off
if not self.ret:
break
def _capture(self):
while True:
# read frame and allow in-place modification
ret, frame = self.cap.read()
self.ret = ret
if ret:
self.image = frame
self.image.setflags(write=1)
else:
break
if __name__ == "__main__":
logger.info('Running quick camera test')
try:
cam = Camera()
cam.begin()
cam.view()
except:
cam.end()
def has_fix(self):
# True if a current fix for location info is available
logger.info('GPS: checking if current fix for location info is avail')
return self.gps.has_fix
def __init__(self):
logger.info('MAG: initializing magnometer')
i2c = busio.I2C(board.SCL, board.SDA)
self.sensor = adafruit_lsm303dlh_mag.LSM303DLH_Mag(i2c)
import ctypes
import pylibi2c
import time
from log_setup import logger
from utils import i2cdev
logger.info('Opening i2c device @/dev/i2c-1, addr 0x68')
i2c = pylibi2c.I2CDevice('/dev/i2c-1', 0x68)
i2c.delay = 10
logger.info('Set delay = 10')
i2c.page_bytes = 8
logger.info('Set page bytes = 8')
i2c.flags = pylibi2c.I2C_M_IGNORE_NAK
logger.info('Set flags to ignore i2c device nak signal')
#i2cdev.setSleepMode(i2c, 0)
time.sleep(3)
pwr_reg = i2cdev.readByte(i2c, 0x6B)
#print(i2c.read(0x0, 256))
print(pwr_reg)
#logger.debug('Reading PWR MGMT register field')
#print(pwr_reg)
while True:
data = i2c.read(0x43, 6)
def _get_frozen_graph(graph_path):
logger.info('Reading graph file: %s' % self.graph_path)
with tf.gfile.GFile(pb_file, 'rb') as f:
graph_def = tf.compat.v1.GraphDef()
graph_def.ParseFromString(f.read())
return graph_def
def _config():
logger.info('Configuring tf session')
self.tf_config = tf.compat.v1.ConfigProto()
self.tf_config.gpu_options.allow_growth = True
def run_motor_test():
print("Start: ")
motor_left = 0
motor_right = 1
forward = 0
backward = 1
if not myMotor.is_connected():
print("Motor driver not connected!", file=sys.stderr)
else:
print("Motor driver connection established.")
logger.info('Initializing operation of SCMD module')
myMotor.begin()
logger.info('Initialization complete')
myMotor.set_drive(0, 0, 0)
myMotor.set_drive(1, 0, 0)
logger.info('Motor speeds set to zero')
#sys.exit(0)
myMotor.enable()
logger.info('Enabled motor driver functions')
time.sleep(1)
logger.info('Start test')
#logger.info('Left Motor test, forward direction')
for speed in range(80, 255):
print(speed)
myMotor.set_drive(motor_left, forward, speed)
time.sleep(.05)
for speed in range(254, 20, -1):
print(speed)
myMotor.set_drive(motor_left, forward, speed)
time.sleep(.05)
#logger.info('Left Motor test, backward direction')
for speed in range(80, 255):
print(speed)
myMotor.set_drive(motor_left, backward, speed)
time.sleep(.05)
for speed in range(254, 20, -1):
print(speed)
myMotor.set_drive(motor_left, backward, speed)
time.sleep(.05)
logger.info('Right Motor test, forward direction')
for speed in range(80, 255):
print(speed)
myMotor.set_drive(motor_right, forward, speed)
time.sleep(.05)
for speed in range(254, 20, -1):
print(speed)
myMotor.set_drive(motor_right, forward, speed)
time.sleep(.05)
#logger.info('Right Motor test, backward direction')
for speed in range(80, 255):
print(speed)
myMotor.set_drive(motor_right, backward, speed)
time.sleep(.05)
for speed in range(254, 20, -1):
print(speed)
myMotor.set_drive(motor_right, backward, speed)
time.sleep(.05)
myMotor.set_drive(0, 0, 0)
myMotor.set_drive(1, 0, 0)
logger.info('Test complete')
def go_to_chkpt(self, chkpt):
while True:
current_loc = self.gps.parse_data()
if current_loc == (None,None):
logger.info('GPS: waiting to establish current location fix')
continue
else:
logger.info('Current coordinates (%f, %f)' % current_loc)
distance_to_chkpt = self.gps.distance(current_loc, chkpt).km
direction_to_chkpt = self.gps.direction(current_loc, chkpt)
heading = self.mag.heading()
logger.info('Distance to checkpoint: %f' % distance_to_chkpt)
logger.info('Desired heading: %f' % direction_to_chkpt)
logger.info('Actual heading: %f' % heading)
if distance_to_chkpt <= 0.01:
self.stop()
logger.info('ROBOT: arrived at checkpoint')
break
else:
if abs(direction_to_chkpt - heading) <= 10:
self.fwd()
else:
a = direction_to_chkpt - 360
b = heading - a
c = b - 360
if c <= 180 and c >= 0:
self.left_turn()
else:
self.right_turn()
def _set_output(self):
# Packet type 314 PMTK314_API_SET_NMEA_OUTPUT
# Turn on Recommended Minimum Info (RMC)
logger.info('GPS: setting RMC as NMEA output format')
self.gps.send_command(b"PMTK314,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0")