def read_serial(ser: serial.Serial, q_out: queue.Queue, q_in: queue.Queue,
stop_event: threading.Event):
while (ser.isOpen()):
if stop_event.is_set(): return
if not q_in.empty():
ser.write(q_in.get() + b'\n')
q_out.put(bytestostr(ser.readline()))
class SerialSensorReader(SensorReader): def __init__(self,commConfig,sensorName,rowType=(),rateSec=60,db=None,log=None): SensorReader.__init__(self,commConfig,sensorName,rowType,rateSec,db,log) self.eol = "\n" self.delimiterPattern = "\\S+" self.delimiter = " " def initSensor(self): from serial import Serial self.serialP = Serial(**self.commConfig) self.resetSensor() def stopSensor(self): self.serialP.close() def getReadings(self): readings = [] ts = str((int(time())/self.rateSec)*self.rateSec) while self.serialP.inWaiting(): line = readlineR(self.serialP,self.eol) readings.append(self.delimiter.join([ts, line])) readings = [x for x in readings if x != None] return readings def toRow(self, reading): row = re.findall(self.delimiterPattern,reading.strip()) row = [x.strip() for x in row] return row def resetSensor(self): print "Reseting Sensor:" + self.sensorName return readlineR(self.serialP,self.eol)
def __init__(self, *args, **kwargs):
#ensure that a reasonable timeout is set
timeout = kwargs.get('timeout',0.1)
if timeout < 0.01: timeout = 0.1
kwargs['timeout'] = timeout
Serial.__init__(self, *args, **kwargs)
self.buf = ''
def main():
print "Opening serial port"
s = Serial(serial_port, serial_bauds);
print "Reading first line from port"
line = s.readline()
print "Initializing communication"
counter = 1
# debug stuff
# tic = time.time()
log = open("/home/pi/vibration/log.csv", "a")
while counter <= 1000:
counter += 1
line = s.readline()
m = re.match(serial_pattern, line)
try:
log.write("\n" + str(ts) + "," + str(counter) + "," + str(m.group(1)))
except:
log.write("\n" + str(ts) + "," + str(counter) + "," + str("NaN"))
# debug stuff
# toc = time.time()
# print(tic)
# print(toc)
log.close()
def run_host_test(self, target_name, port,
duration, verbose=False):
"""
Functions resets target and grabs by timeouted pooling test log
via serial port.
Function assumes target is already flashed with proper 'test' binary.
"""
output = ""
# Prepare serial for receiving data from target
baud = 9600
serial = Serial(port, timeout=1)
serial.setBaudrate(baud)
flush_serial(serial)
# Resetting target and pooling
reset(target_name, serial, verbose=verbose)
start_serial_timeour = time()
try:
while (time() - start_serial_timeour) < duration:
test_output = serial.read(512)
output += test_output
flush_serial(serial)
if '{end}' in output:
break
except KeyboardInterrupt, _:
print "CTRL+C break"
def __init__(self, port, baud):
Serial.__init__(self)
EventDispatcher.__init__(self)
self.port = port
self.baudrate = baud
self.listeners = {}
self.waiting = True
self.detected = False
self.readyMsg = ""
self.repeatsWaiting = False
self.messageEnd = b""
self.inUse = False
self.notFound = False
self.connectionError = False
self.lastSpeed = 1000
self.statusRequest = False
self.busy = False
self._stopping = False
self.connecting = True
try:
self.open()
except SerialException as se:
if os.name == "nt":
if str(se).find('FileNotFoundError') >= 0:
self.notFound = True
self.dispatch('connection-error')
elif str(se).find('PermissionError') >= 0:
self.inUse = True
self.connectionError = True
self.dispatch('connection-error')
return
detectThread = Thread(target=self.detectSetup)
detectThread.start()
class HashTagDisplay():
def __init__(self, delay=5, debug=False):
# duration in seconds to allow human to read display
self.delay = delay
# print messages to shell for debugging
self.debug = debug
self.ser = Serial('/dev/ttyS0', baudrate=9600, timeout=1)
def search(self, hashtag):
# search for tweets with specified hashtag
twitter_search = Twitter(domain="search.twitter.com")
return twitter_search.search(q=hashtag)
def display(self, results):
# Display each tweet in the twitter search results
for tweet in results.get('results'):
msg = "@" + tweet.get('from_user') + ": " + tweet.get('text')
#http://stackoverflow.com/questions/8689795/python-remove-non-ascii-characters-but-leave-periods-and-spaces
msg = filter(lambda x: x in string.printable, msg)
msg = re.sub('\s+',' ', msg)
if self.debug == True:
print "msg: [" + msg + "]"
for c in msg:
self.ser.write(c)
sleep(0.01)
self.ser.write('\n');
sleep(self.delay)
class XBeeWriter(object):
def __init__(self, port):
self.port = port
self._connect_serial(port)
def disconnect(self):
"""Close the serial port an disconnect from the station."""
try:
self._serial.close()
except:
pass
def reconnect(self):
"""Close the serial port and reopen again."""
self.disconnect()
self._connect_serial(self.port)
def send(self, data):
self._serial.write(data)
self._serial.flush()
def _connect_serial(self, port, timeout=None):
"""Connect to SI Reader.
@param port: serial port
"""
self._serial = Serial(port, baudrate=38400, timeout=timeout)
# flush possibly available input
self._serial.reset_input_buffer()
self._serial.reset_output_buffer()
def available_ports():
usb_serial_ports = filter(
(lambda x: x.startswith('ttyUSB')),
os.listdir('/dev'))
ports = []
for p in usb_serial_ports:
ports.append(serial_for_url('/dev/'+p, do_not_open=True))
"""
also check for old school serial ports, my hope is that this will enable
both USB serial adapters and standard serial ports
Scans COM1 through COM255 for available serial ports
returns a list of available ports
"""
for i in range(256):
try:
p = Serial(i)
p.close()
ports.append(p)
except SerialException:
pass
return ports
class SerialInstrument(object):
def __init__(self, port, baud=19200):
self.port = port
self.baud = baud
def read(self, num=None):
if num:
while self.instr.inWaiting() < num:
pass
return self.instr.read(num)
while not self.instr.inWaiting():
pass
return self.instr.read()
def write(self, data):
self.instr.write(data)
def __enter__(self):
self.instr = Serial(self.port, self.baud)
self.instr.open()
return self
def __exit__(self, type, value, tb):
self.instr.close()
def testSendAndReceive4PortsLeader(self):
"""testSendAndReceive4Ports: Creates a PortLogger, serial objects that
connect to the PortLogger, and verifies that reads and writes work"""
plogger = PortLogger(number_of_ports=4, rs485=True)
serials = []
for port_name in plogger.port_names():
new_serial = Serial(port_name)
new_serial.timeout = 1
serials.append(new_serial)
leader = serials[0]
followers = serials[1:]
self.assertEquals(len(followers), len(serials)-1)
self.assertTrue(leader) #Check that leader is not None or []
plogger.start()
for port in followers:
message = ''.join([chr(randint(32,127)) for _ in range(24)])
port.write(message)
for port2 in followers:
recvd = port2.read(len(message))
self.assertEqual('', recvd)
recvd = leader.read(len(message))
self.assertEquals(recvd, message)
message = ''.join([chr(randint(32,127)) for _ in range(24)])
leader.write(message)
for port in followers:
recvd = port.read(len(message))
self.assertEquals(recvd, message)
plogger.stop()
def testSendAndReceive2PortsLeader(self):
"""testSendAndReceive2PortsLeader: Creates a PortLogger, serial objects that
connect to the PortLogger, and verifies that reads and writes work.
The portlogger uses the leader setup"""
plogger= PortLogger(emulate=True, rs485=True )
serials = []
for port_name in plogger.port_names():
new_serial = Serial(port_name)
new_serial.timeout = 1
serials.append(new_serial)
plogger.start()
message1 = "This is a test message"
message2 = ''.join([chr(randint(32,127)) for _ in range(24)])
serials[0].write(message1)
recvd = serials[1].read(len(message1))
self.assertEqual(message1, recvd)
recvd = serials[0].read(len(message1))
self.assertEqual('', recvd)
serials[1].write(message2)
recvd = serials[0].read(len(message2))
self.assertEqual(message2, recvd)
recvd = serials[1].read(len(message2))
self.assertEqual('', recvd)
plogger.stop()
class Copernicus(object):
def __init__(self, port=None, baudrate=9600):
self.serial = Serial(port, baudrate)
def read(self):
return ord(self.serial.read(1))
def write(self, value):
return self.serial.write(chr(value))
def flush(self):
self.serial.flushInput()
def set_autoupdates(self, peripheral):
self.write(autoupdate_codes[peripheral])
def query(self, peripheral):
self.write(query_codes[peripheral])
def set_dashboard_angle(self, angle):
if 0 <= angle <= 31:
self.write(angle)
else:
ValueError("Dashboard angle out of range (0-31)")
def reset_dashboard_angle(self):
self.set_dashboard_angle(0)
def led_on(self):
self.write(33)
def led_off(self):
self.write(32)
def connect(self, port , baud = 38400 , _timeout = 1):
"""
Tries to connected to specified port, using given baudrate and timeout values
@type port: number
@param port: the port to be opened
@type baud: number
@param baud: the specified baudrate
@type _timeout: number
@param _timeout: the specified timeout value
"""
LOGMSG("Connecting to base station ...")
try:
self.serial = Serial(port,baud, timeout = _timeout)
except serialutil.SerialException:
LOGMSG ("Could not open port %d." %self.port)
LOGMSG ("Retrying to reconnect in 5 seconds..." )
time.sleep(5)
LOGMSG("Reconnecting...")
try:
self.serial = Serial(port,baud, timeout = _timeout)
except serialutil.SerialException:
LOGMSG("Could not open port %d." %self.port)
self.port = self.get_port("Maybe the PORT number is wrong? Please enter PORT number again: ");
LOGMSG("Reconnecting...")
try:
self.serial = Serial(port,baud, timeout= _timeout)
except serialutil.SerialException:
LOGMSG ("Could not open port %d. " %self.port)
LOGMSG("Please check you configurations and PORT connections!")
self.close(1)
LOGMSG("Serial connection established on port %d. Using baudrate %d and timeout %d" %(self.port, self.baud, self._timeout))
class Connexion:
"""
Manage the USB connexion.
"""
def __init__(self, tty = "/dev/ttyACM0"):
"""
Open a serial connexion on specified tty, with a 1152000
baudrate.
"""
try:
self.serial = Serial(tty, baudrate = 115200)
except SerialException:
print("Can't open", tty)
exit(1)
def read(self):
""" Read a line. """
try:
return self.serial.readline().decode("ascii", "ignore")
except OSError:
sleep(1)
return self.read()
def write(self, msg):
""" Send a string. """
self.serial.write(normalize("NFD", msg).encode("ascii", "ignore"))
def __init__(self, port=None, baudrate=None):
if port == None:
port = profile.getPreference("serial_port")
if baudrate == None:
baudrate = int(profile.getPreference("serial_baud"))
self.serial = None
if port == "AUTO":
programmer = stk500v2.Stk500v2()
for port in serialList():
try:
print "Connecting to: %s %i" % (port, baudrate)
programmer.connect(port)
programmer.close()
time.sleep(1)
self.serial = Serial(port, baudrate, timeout=2)
break
except ispBase.IspError as (e):
print "Error while connecting to %s %i" % (port, baudrate)
print e
pass
except:
print "Unexpected error while connecting to serial port:" + port, sys.exc_info()[0]
programmer.close()
elif port == "VIRTUAL":
self.serial = VirtualPrinter()
else:
try:
self.serial = Serial(port, baudrate, timeout=2)
except:
print "Unexpected error while connecting to serial port:" + port, sys.exc_info()[0]
print self.serial
class Rubinstein(object):
def __init__(self, port='/dev/ttyUSB0', baudrate=250000, timeout=0.25):
self.serial = Serial(port=port, baudrate=baudrate, timeout=timeout)
# FIXME don't know why initialization stops with this line
while self.serial.readline() != 'echo:SD init fail\n':
sleep(0.2)
self.busy = False
def command(self, cmd, timeout=float('inf')):
# FIXME needs mutex!
if self.busy or self.serial.read():
raise RuntimeError("busy")
self.busy = True
self.serial.write("{}\n".format(cmd))
response = ''
start = time()
while time() - start < timeout:
sleep(0.2)
line = self.serial.readline()
if line == 'ok\n':
# FIXME missing try/finally for busy=False
self.busy = False
return response
if len(line) > 0:
print line,
response += line
else:
raise RuntimeError(
"timeout when waiting for command {}".format(cmd))
def testSendAndReceive2Ports(self):
"""testSendAndReceive2Ports: Creates a PortLogger, serial objects that
connect to the PortLogger, and verifies that reads and writes work"""
from serial import Serial
from random import randint
plogger= PortLogger()
serials = []
for port_name in plogger.port_names():
new_serial = Serial(port_name)
new_serial.timeout = 1
serials.append(new_serial)
plogger.start()
message1 = "This is a test message"
message2 = ''.join([chr(randint(32,127)) for i in range(24)])
serials[0].write(message1)
recvd = serials[1].read(len(message1))
self.assertEqual(message1, recvd)
recvd = serials[0].read(len(message1))
self.assertEqual('', recvd)
serials[1].write(message2)
recvd = serials[0].read(len(message2))
self.assertEqual(message2, recvd)
recvd = serials[1].read(len(message2))
self.assertEqual('', recvd)
plogger.stop()
def get_present(self):
"""
Checks if RFID-RW-USB device is present.
Returns True if so, False otherwise.
"""
hmgr_if = dbus.Interface(self.bus.get_object(HAL_SERVICE, HAL_MGR_PATH),
HAL_MGR_IFACE)
serialusb_devices = set(hmgr_if.FindDeviceStringMatch('serial.type',
'usb')) & set(hmgr_if.FindDeviceStringMatch(
'info.subsystem', 'tty'))
for i in serialusb_devices:
serialusb_if = dbus.Interface(self.bus.get_object(HAL_SERVICE, i),
HAL_DEV_IFACE)
if serialusb_if.PropertyExists('info.parent'):
parent_udi = str(serialusb_if.GetProperty('info.parent'))
parent = dbus.Interface(self.bus.get_object(HAL_SERVICE,
parent_udi), HAL_DEV_IFACE)
if parent.PropertyExists('info.linux.driver') and \
str(parent.GetProperty('info.linux.driver')) == 'ftdi_sio':
device = str(serialusb_if.GetProperty('linux.device_file'))
ser = Serial(device, 9600, timeout=0.1)
ser.read(100)
ser.write('v')
ser.write('e')
ser.write('r')
ser.write('\x0D')
resp = ser.read(4)
if resp[0:-1] in VERSIONS:
self.device = device
self.device_path = i
return True
return False
def init_serial(self, baud=9600, extra_baud=9600):
self.serial = Serial(self.port, timeout = 1)
self.serial.setBaudrate(baud)
if self.extra_port:
self.extra_serial = Serial(self.extra_port, timeout = 1)
self.extra_serial.setBaudrate(extra_baud)
self.flush()
class Arduino:
def __init__(self, port, baud):
self.serial = Serial(port, baud)
time.sleep(2)
def write_ints(self, *ints):
self.serial.write(''.join(chr(i) for i in ints))
def run(port, max_height=223, max_width=123):
ser = Serial(port, 9600)
prev = time()
while True:
line = ser.readline().rstrip('\n\r')
data = line.split(',')
if len(data) != 3:
continue
for i in range(3):
try:
data[i] = calibration * float(data[i])
except ValueError:
continue
now = time()
rate = 1 / (now - prev)
ut = data[0]
ul = data[1]
ur = data[2]
width = 0
height = max_height - ut
if not (ul > 120 and ur > 120):
width = max_width - ul - ur
#print '{:5.2f} {:5.2f} {:5.2f} {:5.2f} {:4.2f}'.format(height, ul, ur, width, rate)
prev = now
class GPS:
def __init__(self, port_name, baud_rate, logger):
self.logger = logger
self.logger.write("Starting GPS Communications")
self.serial = Serial(port_name, baud_rate)
self.lat = 0
self.long = 0
def get_GPS(self):
while (self.lat == 0.0):
self.logger.write("Waiting for GPS")
time.sleep(1)
return (self.lat, self.long)
def read_data(self):
if self.serial.inWaiting() > 0:
data = self.serial.readline().rstrip()
if data[0:6] == "$GPRMC":
fields = data.split(',')
if fields[2] == 'A':
self.lat = int(fields[3][0:2]) + (float(fields[3][2:]) / 60.0) #ASSUMES TWO DIGIT LATITUDE
self.long = int(fields[5][0:3]) + (float(fields[5][3:]) / 60.0) #ASSUMES THREE DIGIT LONGITUDE
else:
self.lat = 0.0
self.long = 0.0
def close(self):
self.serial.close()
def main(argv):
loglevels = [logging.CRITICAL, logging.ERROR, logging.WARN, logging.INFO, logging.DEBUG]
parser = argparse.ArgumentParser(argv)
parser.add_argument('-v', '--verbosity', type=int, default=4,
help='set logging verbosity, 1=CRITICAL, 5=DEBUG')
parser.add_argument('tty',
help='Serial port device file name')
parser.add_argument('-b', '--baudrate', default=115200, type=int,
help='Serial port baudrate')
args = parser.parse_args()
# logging setup
logging.basicConfig(level=loglevels[args.verbosity-1])
# open serial port
try:
logging.debug("Open serial port %s, baud=%d", args.tty, args.baudrate)
port = Serial(args.tty, args.baudrate, dsrdtr=0, rtscts=0, timeout=0.3)
except IOError:
logging.critical("error opening serial port", file=sys.stderr)
sys.exit(2)
try:
app = rssi_plot()
app.plot_rssi(port)
except KeyboardInterrupt:
port.close()
sys.exit(2)
def __init__(self, port, baudrate, wait_ready = True, timeout = True):
# si le port n'est pas utilisé
if port not in ARDUINO_PORTS:
raise InvalidPort(port)
# si le baudrate n'existe pas
if baudrate not in Serial.BAUDRATES:
raise InvalidBaudRate(baudrate)
# on appel le constructeur parent
Serial.__init__(self, port, baudrate, timeout = timeout)
# connection start : temps de début de connexion
self.connection_start = time()
# on dort un petit moment
if not isinstance(wait_ready, bool):
time.sleep(wait_ready)
# temps qu'on n'a pas de réponse on attend
elif True:
while not self.read():
continue
# temps nécéssaire pour obtenir la première connexion
self.connection_first_answer = time() - self.connection_start
print(self.connection_first_answer)
class AcquisitionThread(Thread):
BAUDRATE = 57600
START_CHARACTER = b's'
PACKET_SIZE = 69
def __init__(self, acquisition_queue):
super(AcquisitionThread, self).__init__()
self.acquisition_queue = acquisition_queue
self.exit_flag = False
def run(self):
port_nb = serial_port()[0]
self.device = Serial(port_nb, baudrate=self.BAUDRATE, timeout=0.2)
while not self.exit_flag:
c = self.device.read(1)
if c == self.START_CHARACTER:
while self.device.inWaiting() < self.PACKET_SIZE:
pass
data = self.device.read(self.PACKET_SIZE)
rocket_data = RocketData(data)
# checksum_validated = rocket_data.validateCheckSum()
checksum_validated = True
if checksum_validated:
self.acquisition_queue.put(rocket_data)
self.device.close()
def stop(self):
self.exit_flag = True
def __init__(self, port, baudrate=115200, reset=False):
ConBase.__init__(self)
try:
self.serial = Serial(port, baudrate=baudrate, interCharTimeout=1)
if reset:
logging.info("Hard resetting device at port: %s" % port)
self.serial.setDTR(True)
time.sleep(0.25)
self.serial.setDTR(False)
self.serial.close()
self.serial = Serial(port, baudrate=baudrate, interCharTimeout=1)
while True:
time.sleep(2.0)
if not self.inWaiting():
break
self.serial.read(self.inWaiting())
except Exception as e:
logging.error(e)
raise ConError(e)
def __init__(self, gui=None):
if Printer.__single:
raise RuntimeError('A Printer already exists')
Printer.__single = self
if gui:
self.gui = gui
else:
self.gui = dddumbui.DumbGui()
Serial.__init__(self)
self.usbId = None
# Command sequence number [1..255]
self.lineNr = 1
# The last (max. 256) commands sent, for command re-send
self.lastCommands = {}
# Retry counter on rx and tx errors
self.rxErrors = 0
self.txErrors = 0
self.startTime = None
self.curDirBits = 0
def uart1(portName, q):
while not exitFlag:
queueLock.acquire()
if not workQueue.empty():
data = q.get()
ser = Serial(
data,
baudrate=9600,
bytesize=8,
parity='N',
stopbits=1,
timeout=None)
while True:
line = ser.readline(ser.inWaiting()).decode('utf-8')[:-2]
if line:
t = line.split(",")
line2 = float(t[5])
if line2 > 0:
print(portName, line2)
if line == '520':
subprocess.call(["xte", "key Up"])
elif line == '620':
subprocess.call(["xte", "key Down"])
elif line == '110':
break
ser.close()
#!/usr/bin/python
import os
try:
#os.remove('/home/pi/PiBits/MPU6050-Pi-Demo/acc_data.txt')
#os.remove('/home/pi/gps.txt')
pass
except:
pass
from serial import Serial
from pynmea import nmea
import time
#Starting serial connection
serialPort = Serial("/dev/ttyAMA0", 9600, timeout=1)
#Check if port failed to open
if (serialPort.isOpen() == False):
serialPort.open()
#Flush before receiving or sending any data
serialPort.flushInput()
serialPort.flushOutput()
#String as output
#serialPort.write('scaluza.com')
gpsData = ""
gpgga = nmea.GPGGA()
f1 = open('gps.txt', 'w+')
while True:
#Check if there is any byte waiting on serial port
if (serialPort.inWaiting() != 0):
def __init__(self, serport):
self.decoder_state = SniffleDecoderState()
self.ser = Serial(serport, 2000000)
self.ser.write(b'@@@@@@@@\r\n') # command sync
self.recv_cancelled = False
self.rate_limiter = RateLimiter()
# Script for testing the recieve functionality of the Programm
import time
from serial import Serial
from config.ConfigReader import get_config
serial_config = get_config("../resources/SerialConfig.json")
# setting up the serial connection on COM Port 6 for testing purpose
ser = Serial("COM6", serial_config['baudrate'], serial_config['bytesize'],
serial_config['parity'], serial_config['stopbits'],
serial_config['timeout'])
# sends a command via the serial connection
# main purpose are AT commands
def send_at_command(command):
ser.write(str.encode(command))
time.sleep(0.1)
# used to send 'String' messages via AT+SEND
def send_message(message):
send_at_command("AT+SEND=" + str(len(message)) + "\r\n")
time.sleep(0.1)
send_at_command(str(message) + "\r\n")
print("Ready to send data....")
def command_line():
import gym
import serial.tools.list_ports
from serial import Serial
def fformat(float):
return str("{:.2f}".format(float))
env = gym.make('MountainCar-v0')
print("Available serial ports:")
for i in serial.tools.list_ports.comports():
print(i)
ser = Serial('COM11', baudrate=115200) # open serial port
print("Selected port:")
print(ser.name) # check which port was really used
while True:
observation = env.reset()
for step in range(300):
# send observation to the device
obs_str = ';'.join(map(fformat, observation))
#For debug purposes
#print("-> " + obs_str)
obs_str = obs_str + "\n"
ser.write(obs_str.encode()) # write a string
#read action from the device
def on_reconnect_clicked(self):
self.serial.close()
self.serial = Serial(self.port)
self.board_control_frame.set_serial(self.serial)
class ConnectionFrame(Frame):
BOARD_VALUE_SEGMENT14 = 1
BOARD_VALUE_SEGMENT25 = 2
board_names = {
BOARD_VALUE_SEGMENT14: "14 segment board",
BOARD_VALUE_SEGMENT25: "25 segment board"
}
def __init__(self, master, cnf={}, **kw):
super().__init__(master, cnf, **kw)
self.connecting_frame = Frame(self)
self.connecting_frame.grid(row=1, column=1, padx=10, pady=10)
Label(self.connecting_frame, text="Connection", font=header_font).grid(row=1)
connecting_radiobutton_frame = Frame(self.connecting_frame)
connecting_radiobutton_frame.grid(row=2, pady=10)
self.board_var = IntVar()
self.board_var.set(self.BOARD_VALUE_SEGMENT14)
for i in self.board_names:
Radiobutton(connecting_radiobutton_frame, text=self.board_names[i], variable=self.board_var, value=i,
font=radiobutton_font).pack()
connecting_internal_frame = Frame(self.connecting_frame)
connecting_internal_frame.grid(row=3, pady=(10, 0))
self.listbox = Listbox(connecting_internal_frame, width=35, selectmode=SINGLE)
self.listbox.grid(row=1, column=1)
connecting_button_frame = Frame(connecting_internal_frame)
connecting_button_frame.grid(row=1, column=2, padx=(15, 0))
Button(connecting_button_frame, text="Connect", font=button_font, width=12,
command=self.on_connect_clicked).grid(row=1)
Button(connecting_button_frame, text="Search", font=button_font, width=12,
command=self.on_search_clicked).grid(row=2)
self.on_search_clicked()
self.connect_control_frame = Frame(self)
self.connect_control_frame.grid(row=1, column=1, padx=10, pady=10)
self.connect_control_frame.grid_remove()
self.connect_control_message = Message(self.connect_control_frame, font=text_font, width=200)
self.connect_control_message.grid(row=1, column=1)
connect_control_button_frame = Frame(self.connect_control_frame)
connect_control_button_frame.grid(row=1, column=2, padx=(10, 0))
Button(connect_control_button_frame, text="Reconnect", font=button_font, width=10,
command=self.on_reconnect_clicked).grid(row=1, column=1)
Button(connect_control_button_frame, text="Disconnect", font=button_font, width=10,
command=self.on_disconnect_clicked).grid(row=2, column=1)
def on_connect_clicked(self):
self.port = self.listbox.get(ACTIVE)
self.serial = Serial(self.port)
self.connect_control_message['text'] = "Connected to " + self.port + " as to " + self.board_names[
self.board_var.get()]
self.connecting_frame.grid_remove()
self.connect_control_frame.grid()
value = self.board_var.get()
if value is self.BOARD_VALUE_SEGMENT14:
self.board_control_frame = board_controller.Segment14Frame(self.serial, self)
elif value is self.BOARD_VALUE_SEGMENT25:
self.board_control_frame = board_controller.CircleSegmentsOnTransistors(self.serial, 5, 5, self)
self.board_control_frame.grid(row=2, column=1, padx=10, pady=10)
def on_search_clicked(self):
self.listbox.delete(0, END)
port_strings = subprocess.check_output(['python', '-m', 'serial.tools.list_ports']).decode(
'utf-8').strip().split()
for i in range(len(port_strings)):
self.listbox.insert(i, port_strings[i])
def on_reconnect_clicked(self):
self.serial.close()
self.serial = Serial(self.port)
self.board_control_frame.set_serial(self.serial)
def on_disconnect_clicked(self):
self.serial.close()
self.board_control_frame.destroy()
self.connect_control_frame.grid_remove()
self.connecting_frame.grid()
class ArduinoReader:
def __init__(self):
self.serial_port = Serial(port='/dev/ttyUSB0', baudrate=230400)
self.newArduino = False
self.threadsDieNow = False
def findNb1Faibles(self, x):
res = 0
temp = x
for i in range(0, 8):
if temp & 1 == 1:
res = res + 1
temp = temp >> 1
else:
return res
return res
def findNb1Forts(self, x):
res = 0
temp = x
for i in range(0, 8):
if temp & 128 != 0:
res = res + 1
temp = temp << 1
else:
return res
return res
def calcMasque(self):
res = 0
for i in range(0, self.offset):
res = res << 1 | 1
self.masque = res
def findBytes(self, x, y):
res = x & self.masque
res = res << (8 - self.offset)
res = res | (y >> self.offset)
return res
def concat(self, faible, fort):
return faible | (fort << 8)
def continuousStart(self):
"""CALL THIS to start running forever."""
self.t = threading.Thread(target=self.readUSB)
self.t.start()
def getArduino(self):
return self.arduino
def readUSB(self, forever=True):
res = np.arange(0, 64)
compteur = 0
begin = True
prevInInt = 0
prevByte = 0
while True:
if self.threadsDieNow: break
# reperer le premier caractere de debut et l'offset de decalage pour chaque octet
while begin:
if self.serial_port.inWaiting():
if prevInInt != 255:
inInt = int(binascii.hexlify(self.serial_port.read(1)),
16)
else:
prevInInt = 0
nb1faibles = self.findNb1Faibles(prevInInt)
nb1forts = self.findNb1Forts(inInt)
self.offset = nb1faibles
if self.offset + nb1forts >= 8:
begin = False
self.calcMasque()
prevInInt = inInt
if self.serial_port.inWaiting():
inInt = int(binascii.hexlify(self.serial_port.read(1)), 16)
curByte = self.findBytes(prevInInt, inInt)
if compteur < 128:
if compteur % 2 == 1:
res[compteur / 2] = self.concat(prevByte, curByte) / 40
compteur = compteur + 1
else:
compteur = 0
self.arduino = res
self.newArduino = True
begin = True
prevByte = curByte
prevInInt = inInt
if forever == False:
break
def __init__(self):
self.serial_port = Serial(port='/dev/ttyUSB0', baudrate=230400)
self.newArduino = False
self.threadsDieNow = False
#!/usr/bin/env python3
from serial import Serial
import bitarray
import time
ser = Serial('/dev/ttyUSB0', 115200)
for i in range(1, 100):
for a in range(0, 16):
ser.write(b'\xcc')
ser.write((1 << a).to_bytes(2, byteorder='big'))
#ser.write(b.to_bytes(1, byteorder='big'))
ser.write(b'\xff')
print("Count: {} ".format(a))
time.sleep(0.5)
for a in range(0, 16):
ser.write(b'\xcc')
ser.write(((2**15) >> a).to_bytes(2, byteorder='big'))
#ser.write(b.to_bytes(1, byteorder='big'))
ser.write(b'\xff')
print("Count: {} ".format(a))
time.sleep(0.5)
for a in range(0, 256):
for b in range(0, 256):
ser.write(b'\xcc')
ser.write(a.to_bytes(1, byteorder='big'))
ser.write(b.to_bytes(1, byteorder='big'))
ser.write(b'\xff')
def main():
""" The main function. """
parser = argparse.ArgumentParser(
description='Tool to bootload a power module.')
parser.add_argument('--address',
dest='address',
type=int,
help='the address of the power module to bootload')
parser.add_argument('--all',
dest='all',
action='store_true',
help='bootload all power modules')
parser.add_argument('--file',
dest='file',
help='the filename of the hex file to bootload')
parser.add_argument('--8',
dest='old',
action='store_true',
help='bootload for the 8-port power modules')
parser.add_argument('--version',
dest='version',
action='store_true',
help='display the version of the power module(s)')
parser.add_argument('--verbose',
dest='verbose',
action='store_true',
help='show the serial output')
args = parser.parse_args()
config = ConfigParser()
config.read(constants.get_config_file())
port = config.get('OpenMotics', 'power_serial')
power_serial = RS485(Serial(port, 115200))
power_communicator = PowerCommunicator(power_serial,
None,
time_keeper_period=0,
verbose=args.verbose)
power_communicator.start()
if args.address or args.all:
power_controller = PowerController(constants.get_power_database_file())
power_modules = power_controller.get_power_modules()
if args.all:
for module_id in power_modules:
module = power_modules[module_id]
addr = module['address']
if args.version:
print "E%d - Version: %s" % (
addr, version(addr, power_communicator))
if args.file:
if args.old and module['version'] == POWER_API_8_PORTS:
bootload_8(addr,
args.file,
power_communicator,
verbose=args.verbose)
elif not args.old and module[
'version'] == POWER_API_12_PORTS:
bootload_12(addr,
args.file,
power_communicator,
verbose=args.verbose)
else:
addr = args.address
modules = [
module for module in power_modules.keys()
if module['address'] == addr
]
if len(modules) != 1:
print 'ERROR: Could not determine energy module version. Aborting'
sys.exit(1)
if args.version:
print "E%d - Version: %s" % (addr,
version(addr, power_communicator))
if args.file:
if args.old and module['version'] == POWER_API_8_PORTS:
bootload_8(addr,
args.file,
power_communicator,
verbose=args.verbose)
elif not args.old and module['version'] == POWER_API_12_PORTS:
bootload_12(addr,
args.file,
power_communicator,
verbose=args.verbose)
else:
parser.print_help()
def __init__(self, device, timeout=5): # timeout in seconds
self.device = Serial(device)
self.read_timeout = timeout
self.is_open = False
class BTLEJackDevice(wireless.Device):
'''
This device allows to communicate with a BTLEJack Device in order to sniff Bluetooth Low Energy protocol.
The corresponding interfaces are : ``microbitX`` (e.g. "microbit0")
The following capabilities are actually supported :
+-----------------------------------+----------------+
| Capability | Available ? |
+===================================+================+
| SCANNING | yes |
+-----------------------------------+----------------+
| ADVERTISING | no |
+-----------------------------------+----------------+
| SNIFFING_ADVERTISEMENTS | yes |
+-----------------------------------+----------------+
| SNIFFING_NEW_CONNECTION | yes |
+-----------------------------------+----------------+
| SNIFFING_EXISTING_CONNECTION | yes |
+-----------------------------------+----------------+
| JAMMING_CONNECTIONS | yes |
+-----------------------------------+----------------+
| JAMMING_ADVERTISEMENTS | yes |
+-----------------------------------+----------------+
| HIJACKING_CONNECTIONS | yes |
+-----------------------------------+----------------+
| INITIATING_CONNECTION | no |
+-----------------------------------+----------------+
| RECEIVING_CONNECTION | no |
+-----------------------------------+----------------+
| COMMUNICATING_AS_MASTER | yes |
+-----------------------------------+----------------+
| COMMUNICATING_AS_SLAVE | no |
+-----------------------------------+----------------+
| HCI_MONITORING | no |
+-----------------------------------+----------------+
'''
sharedMethods = [
"getFirmwareVersion", "getDeviceIndex", "setCRCChecking", "setChannel",
"getChannel", "sniffNewConnections", "sniffExistingConnections",
"sniffAdvertisements", "jamAdvertisements",
"disableAdvertisementsJamming", "setSweepingMode", "setScan",
"setScanInterval", "getConnections", "switchConnection",
"getCurrentConnection", "isConnected", "isSynchronized",
"getCurrentHandle", "getAccessAddress", "getCrcInit", "getChannelMap",
"getHopInterval", "getHopIncrement", "setJamming", "setHijacking"
]
def setJamming(self, enable=True):
'''
This method allows to enable or disable the jamming mode.
:param enable: boolean indicating if the jamming mode must be enabled or disabled
:type enable: bool
:Example:
>>> device.setJamming(enable=True) # jamming mode enabled
>>> device.setJamming(enable=False) # jamming mode disabled
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
self.jamming = enable
def setHijacking(self, enable=True):
'''
This method allows to enable or disable the hijacking mode.
:param enable: boolean indicating if the hijacking mode must be enabled or disabled
:type enable: bool
:Example:
>>> device.setHijacking(enable=True) # hijacking mode enabled
>>> device.setHijacking(enable=False) # hijacking mode disabled
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
self.hijacking = enable
def getCurrentHandle(self):
'''
This method returns the connection Handle actually in use.
If no connection is established, its value is equal to -1.
:return: connection Handle
:rtype: int
.. warning::
This method always returns 1, it allows to provides the same API as the HCI Device.
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
return 1
def getConnections(self):
'''
This method returns a list of couple (connection handle / address) representing the connections actually established.
A connection is described by a dictionary containing an handle and an access address : ``{"handle":1, "address":"0x12345678"}``
:return: list of connections established
:rtype: list of dict
:Example:
>>> device.getConnections()
[{'handle':1, 'address':'0x12345678'}]
.. warning::
The connection handle is always 1, it allows to provides the same API as the HCI Device.
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
return [{
"address": "0x{:08x}".format(self.accessAddress),
"handle": 1
}]
def getCurrentConnection(self):
'''
This method returns the access address associated to the current connection. If no connection is established, it returns None.
:return: access address of the current connection
:rtype: str
:Example:
>>> device.getCurrentConnection()
'0x12345678'
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
return "0x{:08x}".format(self.accessAddress)
def switchConnection(self, address):
'''
This method is provided in order to provide the same API as an HCI Device, it actually has no effects.
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
io.fail("Switching connection not allowed with BTLEJack Device !")
def isConnected(self):
'''
This method returns a boolean indicating if a connection is actually established and hijacked.
:return: boolean indicating if a connection is established and hijacked
:rtype: bool
:Example:
>>> device.isConnected()
True
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
return self.hijacked
def isSynchronized(self):
'''
This method indicates if the sniffer is actually synchronized with a connection.
:return: boolean indicating if the sniffer is synchronized
:rtype: bool
:Example:
>>> device.isSynchronized()
True
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
return self.synchronized
@classmethod
def findMicrobits(cls, index=None):
'''
This class method allows to find a specific BTLEJack device, by providing the device's index.
If no index is provided, it returns a list of every devices found.
If no device has been found, None is returned.
:param index: device's index
:type index: int
:return: string indicating the device
:rtype: str
:Example:
>>> BTLEJackDevice.findMicrobits(0)
'/dev/ttyACM0'
>>> BTLEJackDevice.findMicrobits()
['/dev/ttyACM0','/dev/ttyACM1']
'''
microbitList = [
i[0] for i in comports()
if (isinstance(i, tuple) and "VID:PID=0d28:0204" in port[-1]) or (
i.vid == 0x0D28 and i.pid == 0x0204)
]
if index is None:
return microbitList
else:
try:
microbit = microbitList[index]
except IndexError:
return None
return microbit
return None
def __init__(self, interface):
super().__init__(interface=interface)
customPort = None
if "microbit" == interface:
self.index = 0
self.interface = "microbit0"
elif "microbit" == interface[:8]:
if ":" in interface:
fields = interface.split(":")
customPort = fields[1]
self.index = customPort
else:
self.index = int(interface.split("microbit")[1])
self.interface = interface
if not customPort:
self.microbit = BTLEJackDevice.findMicrobits(self.index)
else:
self.microbit = customPort
if self.microbit is not None:
try:
self.microbit = Serial(port=self.microbit,
baudrate=115200,
timeout=0)
self.ready = False
self._flush()
except SerialException:
io.fail("Serial communication not ready !")
self.ready = False
self.microbit = None
else:
io.fail("No btlejack device found !")
self.ready = False
def _enterListening(self):
self.isListening = True
def _exitListening(self):
self.isListening = False
def _isListening(self):
return self.isListening
def _cancelFollow(self): # TODO
pass
def setChannel(self, channel=37):
'''
This method changes the channel actually in use by the provided channel.
:param channel: new channel
:type channel: int
:Example:
>>> device.getChannel()
37
>>> device.setChannel(channel=38)
>>> device.getChannel()
38
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
self.channel = channel
def getChannel(self):
'''
This method returns the channel actually in use.
:return: channel in use
:rtype: int
:Example:
>>> device.getChannel()
37
>>> device.setChannel(channel=38)
>>> device.getChannel()
38
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
return self.channel
def _flush(self):
while self.microbit.in_waiting:
self.microbit.read()
def _flushCommandResponses(self):
while not self.commandResponses.empty():
self.commandResponses.get()
def _internalCommand(self, cmd, noResponse=False):
packet = BTLEJack_Hdr() / cmd
self._flushCommandResponses()
def getFunction():
if not self._isListening() or self.commandResponses.empty():
func = self._recv
else:
func = self.commandResponses.get
return func
self._send(packet)
if not noResponse:
getResponse = getFunction()
response = getResponse()
while response is None or response.packet_type == 4 or response.opcode != packet.opcode:
getResponse = getFunction()
response = getResponse()
return response
def _getFirmwareVersion(self):
pkt = self._internalCommand(BTLEJack_Version_Command())
return (pkt.major, pkt.minor)
def _reset(self):
self._internalCommand(BTLEJack_Reset_Command())
def getFirmwareVersion(self):
'''
This method returns the firmware version of the current BTLEJack device.
:return: firmware version as a tuple of (major, minor)
:rtype: tuple of (int,int)
:Example:
>>> device.getFirmwareVersion()
(3,14)
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
version = self._getFirmwareVersion()
return version
def getDeviceIndex(self):
'''
This method returns the index of the current BTLEJack device.
:return: device's index
:rtype: int
:Example:
>>> device.getDeviceIndex()
0
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
return self.index
def _send(self, packet):
self.lock.acquire()
self.microbit.write(raw(packet))
self.lock.release()
def send(self, packet):
command = None
if BTLE_DATA in packet:
command = BTLEJack_Hdr() / BTLEJack_Send_Packet_Command(
ble_payload=packet[BTLE_DATA:])
if self.isConnected(
) and CtrlPDU in command.ble_payload and command.ble_payload.optcode == 0x02:
self.hijacked = False
if command is not None:
self._send(raw(command))
# New Connection Sniffing methods
def sniffNewConnections(self, address="FF:FF:FF:FF:FF:FF", channel=None):
'''
This method starts the new connections sniffing mode.
:param address: selected address - if not provided, no filter is applied (format : "1A:2B:3C:4D:5E:6F")
:type address: str
:param channel: selected channel - if not provided, channel 37 is selected
:type channel: int
:Example:
>>> device.sniffNewConnections()
>>> device.sniffNewConnections(channel=38)
>>> device.sniffNewConnections(address="1A:2B:3C:4D:5E:6F")
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
self.synchronized = False
self.hijacked = False
self.sniffingMode = BLESniffingMode.NEW_CONNECTION
self.lastTarget = address
self._sniffConnectionRequests(address=address, channel=channel)
def _sniffConnectionRequests(self,
address='FF:FF:FF:FF:FF:FF',
channel=None):
if channel is not None and not self.sweepingMode:
self.setChannel(channel)
self._internalCommand(
BTLEJack_Sniff_Connection_Request_Command(
address=address,
channel=self.getChannel() if channel is None else channel))
# Existing Connection Sniffing methods
def sniffExistingConnections(self,
accessAddress=None,
crcInit=None,
channelMap=None):
'''
This method starts the existing connections sniffing mode.
:param accessAddress: selected Access Address - if not provided, the parameter is recovered
:type address: int
:param crcInit: selected CRCInit - if not provided, the parameter is recovered
:type crcInit: int
:param channelMap: selected Channel Map - if not provided, the parameter is recovered
:type channelMap: int
:Example:
>>> device.sniffExistingConnections()
>>> device.sniffExistingConnections(accessAddress=0xe5e296e9)
>>> device.sniffExistingConnections(accessAddress=0xe5e296e9, crcInit=0x0bd54a)
>>> device.sniffExistingConnections(accessAddress=0xe5e296e9, crcInit=0x0bd54a, channelMap=0x1fffffffff)
.. warning::
If no access address is provided, BTLEJack tries to get multiple candidate access addresses and select the most probable address.
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
self.hijacked = False
self.synchronized = False
self.sniffingMode = BLESniffingMode.EXISTING_CONNECTION
if accessAddress is None:
self._listAccessAddress()
else:
self._setAccessAddress(accessAddress)
if crcInit is None:
self._recoverFromAccessAddress(accessAddress)
else:
self._setCrcInit(crcInit)
if channelMap is None:
self._recoverFromCrcInit(accessAddress, crcInit)
else:
self._setChannelMap(channelMap)
self._recoverFromChannelMap(accessAddress, crcInit,
channelMap)
def _resetFilteringPolicy(self, policyType="blacklist"):
policy = 0x00 if policyType == "blacklist" else 0x01
self._internalCommand(
BTLEJack_Advertisements_Command() /
BTLEJack_Advertisements_Reset_Policy_Command(policy_type=policy))
def _addFilteringRule(self, pattern=b"", mask=None, position=None):
if position is None:
position = 0xFF
if mask is None:
mask = len(pattern) * b"\xFF"
self._internalCommand(BTLEJack_Advertisements_Command() /
BTLEJack_Advertisements_Add_Rule_Command() /
BTLEJack_Filtering_Rule(
data=pattern, mask=mask, position=position))
def sniffAdvertisements(self, address='FF:FF:FF:FF:FF:FF', channel=None):
'''
This method starts the advertisement sniffing mode.
:param address: selected address - if not provided, no filter is applied (format : "1A:2B:3C:4D:5E:6F")
:type address: str
:param channel: selected channel - if not provided, channel 37 is selected
:type channel: int
:Example:
>>> device.sniffAdvertisements()
>>> device.sniffAdvertisements(channel=38)
>>> device.sniffAdvertisements(address="1A:2B:3C:4D:5E:6F")
.. warning::
This method requires the custom Mirage Firmware in order to sniff advertisements.
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
if self.customMirageFirmware:
self.sniffingMode = BLESniffingMode.ADVERTISEMENT
self.synchronized = False
self.hijacked = False
if channel is not None and not self.sweepingMode:
self.setChannel(channel)
if address.upper() == "FF:FF:FF:FF:FF:FF":
self._resetFilteringPolicy("blacklist")
else:
self._resetFilteringPolicy("whitelist")
target = bytes.fromhex(address.replace(":", ""))[::-1]
self._addFilteringRule(pattern=target, position=2)
self._internalCommand(
BTLEJack_Advertisements_Command() /
BTLEJack_Advertisements_Disable_Sniff_Command())
self._internalCommand(
BTLEJack_Advertisements_Command() /
BTLEJack_Advertisements_Enable_Sniff_Command(
channel=self.getChannel() if channel is None else channel))
else:
io.fail(
"Sniffing advertisements is not supported by BTLEJack firmware,"
" a Custom Mirage Firmware is available.")
def jamAdvertisements(self, pattern=b"", offset=0, channel=37):
'''
This method reactively jams advertisements according to the specified pattern, offset and channel provided.
:param pattern: pattern contained in payload indicating that the packet must be jammed
:type pattern: bytes
:param offset: offset indicating the position of pattern in the payload
:type offset: int
:param channel: selected channel - if not provided, channel 37 is selected
:type channel: int
:Example:
>>> target = "1A:2B:3C:4D:5E:6F"
>>> pattern = bytes.fromhex(target.replace(":",""))[::-1]
>>> device.jamAdvertisements(pattern=pattern,offset=2,channel=39) # jam the advertisements transmitted by 1A:2B:3C:4D:5E:6F on channel 39
.. warning::
This method requires the custom Mirage Firmware in order to jam advertisements.
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
if self.customMirageFirmware:
self.synchronized = False
self.hijacked = False
self.jammingEnabled = True
if channel is not None:
self.setChannel(channel)
self._internalCommand(
BTLEJack_Advertisements_Command() /
BTLEJack_Advertisements_Enable_Jamming_Command(
offset=offset,
pattern=pattern,
channel=self.getChannel() if channel is None else channel))
else:
io.fail(
"Jamming advertisements is not supported by BTLEJack firmware,"
" a Custom Mirage Firmware is available.")
def _listAccessAddress(self):
io.info("Recovering access address ...")
self._internalCommand(BTLEJack_Scan_Connections_Command())
def _setAccessAddress(self, accessAddress=None):
self.accessAddress = accessAddress
def _setCrcInit(self, crcInit=None):
self.crcInit = crcInit
def _setChannelMap(self, channelMap=None):
self.channelMap = channelMap
def _setHopInterval(self, hopInterval=None):
self.hopInterval = hopInterval
def _getHopInterval(self):
return self.hopInterval
def _setHopIncrement(self, hopIncrement):
self.hopIncrement = hopIncrement
def _getHopIncrement(self):
return self.hopIncrement
def _getChannelMap(self):
return self.channelMap
def _getAccessAddress(self):
return self.accessAddress
def _getCrcInit(self):
return self.crcInit
def _updateCrcInit(self, crcInit=None):
io.success("CRCInit successfully recovered : " +
"0x{:06x}".format(crcInit))
self._setCrcInit(crcInit)
self._recoverFromCrcInit()
def _updateChannelMap(self, channelMap=None):
io.success("Channel Map successfully recovered : " +
"0x{:10x}".format(channelMap))
self._setChannelMap(channelMap)
self._recoverFromChannelMap()
def _updateHopInterval(self, hopInterval=None):
io.success("Hop Interval successfully recovered : " + str(hopInterval))
self._setHopInterval(hopInterval)
io.info("Recovering Hop Increment ...")
def _updateHopIncrement(self, hopIncrement=None):
io.success("Hop Increment successfully recovered : " +
str(hopIncrement))
self._setHopIncrement(hopIncrement)
io.info("All parameters recovered, following connection ...")
def _recoverFromAccessAddress(self, accessAddress):
aa = accessAddress if accessAddress is not None else self._getAccessAddress(
)
io.info("Recovering CRCInit ...")
self._reset()
pkt = self._internalCommand(
BTLEJack_Recover_Command() /
BTLEJack_Recover_Connection_AA_Command(access_address=aa))
def _recoverFromCrcInit(self, accessAddress=None, crcInit=None):
aa = accessAddress if accessAddress is not None else self._getAccessAddress(
)
crcInit = crcInit if crcInit is not None else self._getCrcInit()
io.info("Recovering ChannelMap ...")
self._reset()
pkt = self._internalCommand(BTLEJack_Recover_Command() /
BTLEJack_Recover_Channel_Map_Command(
access_address=aa, crc_init=crcInit))
io.progress(0, total=36, suffix="0/36 channels")
def _recoverFromChannelMap(self,
accessAddress=None,
crcInit=None,
channelMap=None):
aa = accessAddress if accessAddress is not None else self._getAccessAddress(
)
crcInit = crcInit if crcInit is not None else self._getCrcInit()
channelMap = channelMap if channelMap is not None else self._getChannelMap(
)
io.info("Recovering Hop Interval ...")
self._reset()
pkt = self._internalCommand(
BTLEJack_Recover_Command() /
BTLEJack_Recover_Hopping_Parameters_Command(
access_address=aa, crc_init=crcInit, channel_map=channelMap))
def _addCandidateAccessAddress(self,
accessAddress=None,
rssi=None,
channel=None):
io.info("Candidate access address found : " +
"0x{:08x}".format(accessAddress) + " (rssi = -" + str(rssi) +
"dBm / channel = " + str(channel) + ")")
if accessAddress not in self.candidateAccessAddresses:
self.candidateAccessAddresses[accessAddress] = {
"hits": 1,
"rssi": rssi,
"channels": set([channel])
}
else:
self.candidateAccessAddresses[accessAddress]["hits"] += 1
self.candidateAccessAddresses[accessAddress]["channels"].add(
channel)
if self.candidateAccessAddresses[accessAddress]["hits"] >= 5:
io.success("Access Address selected : " +
"0x{:08x}".format(accessAddress))
self._setAccessAddress(accessAddress)
self._recoverFromAccessAddress(accessAddress=accessAddress)
def _recv(self):
self.lock.acquire()
if self.microbit is not None and self.microbit.in_waiting:
self.receptionBuffer += self.microbit.read()
self.lock.release()
if len(self.receptionBuffer) > 0:
try:
start = self.receptionBuffer.index(0xBC)
self.receptionBuffer = self.receptionBuffer[start:]
except ValueError:
self.receptionBuffer = b""
if len(self.receptionBuffer) >= 4:
size = struct.unpack('<H', self.receptionBuffer[2:4])[0]
if len(self.receptionBuffer) >= size + 5:
#print(self.receptionBuffer[:size+5].hex())
pkt = BTLEJack_Hdr(self.receptionBuffer[:size + 5])
self.receptionBuffer = self.receptionBuffer[size + 5:]
return pkt
else:
receptionBuffer = b""
return None
def disableAdvertisementsJamming(self):
if self.jammingEnabled:
self._internalCommand(
BTLEJack_Advertisements_Command() /
BTLEJack_Advertisements_Disable_Jamming_Command())
def close(self):
self.lock.acquire()
self._stopSweepingThread()
self.microbit.close()
self.microbit = None
self.lock.release()
def isUp(self):
return self.microbit is not None
def setCRCChecking(self, enable=True):
'''
This method enables CRC Checking.
:param enable: boolean indicating if CRC Checking must be enabled
:type enable: bool
:Example:
>>> device.setCRCChecking(enable=True) # CRC Checking enabled
>>> device.setCRCChecking(enable=False) # CRC Checking disabled
.. warning::
BTLEJack calculates the CRC directly in the firmware, so this command is ignored. It is present in order to provide a similar API to Ubertooth.
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
self.crcEnabled = enable
def setAccessAddress(self, accessAddress):
'''
This method sets the access address to use.
:param accessAddress: new access address
:type accessAddress: int
:Example:
>>> device.setAccessAddress(0xe5e296e9)
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
self.accessAddress = accessAddress
def getAccessAddress(self):
'''
This method returns the access address actually in use.
:return: access address
:rtype: int
:Example:
>>> hex(device.getAccessAddress())
'0xe5e296e9'
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
return self.accessAddress
def getCrcInit(self):
'''
This method returns the CRCInit actually in use.
:return: CRCInit
:rtype: int
:Example:
>>> hex(device.getCrcInit())
'0x0bd54a'
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
return self.crcInit
def getChannelMap(self):
'''
This method returns the Channel Map actually in use.
:return: Channel Map
:rtype: int
:Example:
>>> hex(device.getChannelMap())
'0x1fffffffff'
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
return self.channelMap
def getHopInterval(self):
'''
This method returns the Hop Interval actually in use.
:return: Hop Interval
:rtype: int
:Example:
>>> device.getHopInterval()
36
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
return self.hopInterval
def getHopIncrement(self):
'''
This method returns the Hop Increment actually in use.
:return: Hop Increment
:rtype: int
:Example:
>>> device.getHopIncrement()
11
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
return self.hopIncrement
def restartSniffingMode(self):
'''
This method restarts the sniffing mode.
:Example:
>>> device.restartSniffingMode()
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
if self.sniffingMode == BLESniffingMode.NEW_CONNECTION:
self.sniffNewConnections()
else:
self.sniffExistingConnections()
def recv(self):
self._enterListening()
pkt = self._recv()
self._exitListening()
if pkt is not None:
if self.customMirageFirmware and BTLEJack_Advertisement_Packet_Notification in pkt:
timestamp = time.time()
ts_sec = int(timestamp)
ts_usec = int((timestamp - ts_sec) * 1000000)
if pkt.crc_ok == 0x01:
io.success("CRC OK !")
else:
io.fail("CRC not OK !")
if pkt.crc_ok != 0x01 and self.crcEnabled:
return None
return BTLE_PPI(btle_channel=pkt.channel,
btle_clkn_high=ts_sec,
btle_clk_100ns=ts_usec,
rssi_max=-pkt.rssi,
rssi_min=-pkt.rssi,
rssi_avg=-pkt.rssi,
rssi_count=1) / BTLE() / BTLE_ADV(
pkt.ble_payload)
if BTLEJack_Access_Address_Notification in pkt:
self._addCandidateAccessAddress(
accessAddress=pkt.access_address,
rssi=pkt.rssi,
channel=pkt.channel)
if BTLEJack_CRCInit_Notification in pkt:
self._updateCrcInit(crcInit=pkt.crc_init)
if BTLEJack_Channel_Map_Notification in pkt:
self._updateChannelMap(channelMap=pkt.channel_map)
if BTLEJack_Verbose_Response in pkt and b"c=" in pkt.message:
currentChannel = pkt.message.decode('ascii').split("c=")[1]
io.progress(int(currentChannel),
total=36,
suffix=str(currentChannel) + "/36 channels")
if BTLEJack_Verbose_Response in pkt and b"ADV_JAMMED" in pkt.message:
io.info("Advertisement jammed on channel #" +
str(self.getChannel()))
if BTLEJack_Verbose_Response in pkt:
io.info(pkt.message.decode('ascii'))
if BTLEJack_Hop_Interval_Notification in pkt:
self._updateHopInterval(pkt.hop_interval)
if BTLEJack_Hop_Increment_Notification in pkt:
self._updateHopIncrement(pkt.hop_increment)
if self.hijacking:
self._internalCommand(
BTLEJack_Enable_Hijacking_Command(enabled=0x01))
elif self.jamming:
self._internalCommand(
BTLEJack_Enable_Jamming_Command(enabled=0x01))
self.synchronized = True
if BTLEJack_Hijack_Status_Notification in pkt:
self.hijacked = (pkt.status == 0x00)
if BTLEJack_Nordic_Tap_Packet_Notification in pkt:
timestamp = time.time()
ts_sec = int(timestamp)
ts_usec = int((timestamp - ts_sec) * 1000000)
return BTLE_PPI(
btle_channel=pkt.channel,
btle_clkn_high=ts_sec,
btle_clk_100ns=ts_usec,
rssi_max=pkt.rssi,
rssi_min=pkt.rssi,
rssi_avg=pkt.rssi,
rssi_count=1) / BTLE(
access_addr=self.getAccessAddress()) / pkt.ble_payload
elif BTLEJack_Connection_Request_Notification in pkt:
self._setAccessAddress(
struct.unpack(">I", struct.pack("<I",
pkt.ble_payload.AA))[0])
self._setCrcInit(
struct.unpack(
">I", b"\x00" +
struct.pack('<I', pkt.ble_payload.crc_init)[:3])[0])
self._setChannelMap(pkt.ble_payload.chM)
self._setHopInterval(pkt.ble_payload.interval)
self._setHopIncrement(pkt.ble_payload.hop)
self.synchronized = True
timestamp = time.time()
ts_sec = int(timestamp)
ts_usec = int((timestamp - ts_sec) * 1000000)
return BTLE_PPI(btle_channel=self.channel,
btle_clkn_high=ts_sec,
btle_clk_100ns=ts_usec,
rssi_max=0,
rssi_min=0,
rssi_avg=0,
rssi_count=1) / BTLE() / BTLE_ADV(
RxAdd=pkt.RxAdd,
TxAdd=pkt.TxAdd,
RFU=pkt.RFU,
PDU_type=pkt.PDU_type) / pkt.ble_payload
elif BTLEJack_Connection_Lost_Notification in pkt or pkt.packet_type == 0x4 and pkt.notification_type == 0x9:
io.fail("Connection lost !")
self._reset()
self.restartSniffingMode()
self._setAccessAddress(None)
self._setCrcInit(None)
self._setChannelMap(None)
self._setHopInterval(None)
self._setHopIncrement(None)
self.hijacked = False
self.synchronized = False
else:
self.commandResponses.put(pkt)
else:
utils.wait(seconds=0.0001)
def setScanInterval(self, seconds=1):
'''
This method allows to provide the scan interval (in second).
:param seconds: number of seconds to wait between two channels
:type seconds: float
:Example:
>>> device.setScanInterval(seconds=1)
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
self.scanInterval = seconds
def _scanThread(self):
self.sniffAdvertisements(channel=37)
utils.wait(seconds=self.scanInterval)
self.sniffAdvertisements(channel=38)
utils.wait(seconds=self.scanInterval)
self.sniffAdvertisements(channel=39)
utils.wait(seconds=self.scanInterval)
def setScan(self, enable=True):
'''
This method enables or disables the scanning mode. It allows to change the channel according to the scan interval parameter.
:param enable: boolean indicating if the scanning mode must be enabled
:type enable: bool
:Example:
>>> device.setScan(enable=True) # scanning mode enabled
>>> device.setScan(enable=False) # scanning mode disabled
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
if enable:
self.sniffAdvertisements()
if self.scanThreadInstance is None:
self.scanThreadInstance = wireless.StoppableThread(
target=self._scanThread)
self.scanThreadInstance.start()
else:
self.scanThreadInstance.stop()
self.scanThreadInstance = None
def _sweepingThread(self):
for channel in self.sweepingSequence:
self.setChannel(channel=channel)
if self.sniffingMode is not None:
if self.sniffingMode == BLESniffingMode.ADVERTISEMENT:
self._internalCommand(
BTLEJack_Advertisements_Command() /
BTLEJack_Advertisements_Enable_Sniff_Command(
channel=channel),
noResponse=True)
elif self.sniffingMode == BLESniffingMode.NEW_CONNECTION and not self.synchronized:
self._sniffConnectionRequests(address=self.lastTarget,
channel=channel)
utils.wait(seconds=0.1)
def _startSweepingThread(self):
self._stopSweepingThread()
self.sweepingThreadInstance = wireless.StoppableThread(
target=self._sweepingThread)
self.sweepingThreadInstance.start()
def _stopSweepingThread(self):
if self.sweepingThreadInstance is not None:
self.sweepingThreadInstance.stop()
self.sweepingThreadInstance = None
def setSweepingMode(self, enable=True, sequence=[37, 38, 39]):
'''
This method allows to enable or disable the Sweeping mode. It allows to provide a subset of advertising channels to monitor sequentially.
:param enable: boolean indicating if the Sweeping mode is enabled.
:type enable: bool
:param sequence: sequence of channels to use
:type sequence: list of int
.. note::
This method is a **shared method** and can be called from the corresponding Emitters / Receivers.
'''
self.sweepingMode = enable
if enable:
self.sweepingSequence = sequence
self._startSweepingThread()
else:
self._stopSweepingThread()
def init(self):
if self.microbit is not None:
self._flush()
self.setCRCChecking(True)
self.scanThreadInstance = None
self.isListening = False
self.hijacking = False
self.jamming = False
self.customMirageFirmware = False
self.receptionBuffer = b""
self.lock = Lock()
self.commandResponses = Queue()
self.channel = 37
self.accessAddress = None
self.crcInit = None
self.channelMap = None
self.hopInterval = None
self.hopIncrement = None
self.sniffingMode = None
self.hijacked = False
self.synchronized = False
self.jammingEnabled = True
self.sweepingMode = False
self.sweepingSequence = []
self.sweepingThreadInstance = None
self.lastTarget = "FF:FF:FF:FF:FF:FF"
self.setScanInterval()
self.candidateAccessAddresses = {}
self.capabilities = [
"SNIFFING_EXISTING_CONNECTION", "SNIFFING_NEW_CONNECTION",
"HIJACKING_CONNECTIONS", "JAMMING_CONNECTIONS",
"COMMUNICATING_AS_MASTER"
]
try:
(major, minor) = self._getFirmwareVersion()
io.success("BTLEJack device " +
("#" + str(self.index) if isinstance(
self.index, int) else str(self.index)) +
" successfully instantiated (firmware version : " +
str(major) + "." + str(minor) + ")")
if major == 3 and minor == 14:
io.info(
"Custom Mirage Firmware used ! Advertisements sniffing and jamming will be supported."
)
self.capabilities += [
"SNIFFING_ADVERTISEMENTS", "SCANNING",
"JAMMING_ADVERTISEMENTS"
]
self.customMirageFirmware = True
self._reset()
self.ready = True
except:
self.microbit = None
self.ready = False
class SerialFrame(SerialFrameUI):
def __init__(self, parent=None):
super(SerialFrame, self).__init__(parent)
self.m_imgStat.SetBitmap(Img_inclosing.getBitmap())
self.Ser = Serial()
self.serialThread = SerialThread(self.Ser)
# create a pubsub receiver
pub.subscribe(self.on_txtMain_update, 'update')
def on_txtMain_update(self, msg):
self.m_txtMain.AppendText(msg.data)
def on_btnSend_clicked(self, event):
self.Ser.write(self.m_txtInput.GetValue())
def on_btnClear_clicked(self, event):
self.m_txtMain.Clear()
def on_chkHEXShow_changed(self, event):
s = self.m_txtMain.GetValue()
if self.m_chkHEXShow.IsChecked():
s = ''.join('%02X' % i for i in [ord(c) for c in s])
else:
s = ''.join([
chr(int(i, 16))
for i in [s[i * 2:i * 2 + 2] for i in range(0,
len(s) / 2)]
])
self.m_txtMain.Clear()
self.m_txtMain.SetValue(s)
def on_cmbBaud_changled(self, event):
self.Ser.setBaudrate(int(self.m_cmbBaud.GetValue()))
def on_btnOpen_clicked(self, event):
if not self.Ser.isOpen():
try:
self.Ser.timeout = 1
self.Ser.xonxoff = 0
self.Ser.port = self.m_cmbCOMX.GetValue()
self.Ser.parity = self.m_cmbChek.GetValue()[0]
self.Ser.baudrate = int(self.m_cmbBaud.GetValue())
self.Ser.bytesize = int(self.m_cmbData.GetValue())
self.Ser.stopbits = int(self.m_cmbStop.GetValue())
self.Ser.open()
except Exception as e:
print('COMM Open Fail!!', e)
else:
self.m_btnOpen.SetLabel(u'关闭串口')
self.m_imgStat.SetBitmap(Img_inopening.getBitmap())
else:
self.Ser.close()
while self.Ser.isOpen():
pass
self.m_btnOpen.SetLabel(u'打开串口')
self.m_imgStat.SetBitmap(Img_inclosing.getBitmap())
def on_btnExtn_clicked(self, event):
event.Skip()
def __init__(self, *args, **kwargs):
# NEW BEHAVIOR: if no parameters given, output is written
# to stdout, to be piped through 'lp -o raw' (old behavior
# was to use default port & baud rate).
baudrate = 19200
if len(args) == 0:
self.writeToStdout = True
if len(args) == 1:
# If only port is passed, use default baud rate.
args = [args[0], baudrate]
elif len(args) == 2:
# If both passed, use those values.
baudrate = args[1]
# Firmware is assumed version 2.68. Can override this
# with the 'firmware=X' argument, where X is the major
# version number * 100 + the minor version number (e.g.
# pass "firmware=264" for version 2.64.
self.firmwareVersion = kwargs.get('firmware', 268)
if self.writeToStdout is False:
# Calculate time to issue one byte to the printer.
# 11 bits (not 8) to accommodate idle, start and
# stop bits. Idle time might be unnecessary, but
# erring on side of caution here.
self.byteTime = 11.0 / float(baudrate)
Serial.__init__(self, *args, **kwargs)
# Remainder of this method was previously in begin()
# The printer can't start receiving data immediately
# upon power up -- it needs a moment to cold boot
# and initialize. Allow at least 1/2 sec of uptime
# before printer can receive data.
self.timeoutSet(0.5)
self.wake()
self.reset()
# Description of print settings from p. 23 of manual:
# ESC 7 n1 n2 n3 Setting Control Parameter Command
# Decimal: 27 55 n1 n2 n3
# max heating dots, heating time, heating interval
# n1 = 0-255 Max heat dots, Unit (8dots), Default: 7 (64 dots)
# n2 = 3-255 Heating time, Unit (10us), Default: 80 (800us)
# n3 = 0-255 Heating interval, Unit (10us), Default: 2 (20us)
# The more max heating dots, the more peak current
# will cost when printing, the faster printing speed.
# The max heating dots is 8*(n1+1). The more heating
# time, the more density, but the slower printing
# speed. If heating time is too short, blank page
# may occur. The more heating interval, the more
# clear, but the slower printing speed.
heatTime = kwargs.get('heattime', self.defaultHeatTime)
self.writeBytes(
27, # Esc
55, # 7 (print settings)
11, # Heat dots
heatTime, # Lib default
40) # Heat interval
# Description of print density from p. 23 of manual:
# DC2 # n Set printing density
# Decimal: 18 35 n
# D4..D0 of n is used to set the printing density.
# Density is 50% + 5% * n(D4-D0) printing density.
# D7..D5 of n is used to set the printing break time.
# Break time is n(D7-D5)*250us.
# (Unsure of default values -- not documented)
printDensity = 10 # 100%
printBreakTime = 2 # 500 uS
self.writeBytes(
18, # DC2
35, # Print density
(printBreakTime << 5) | printDensity)
self.dotPrintTime = 0.03
self.dotFeedTime = 0.0021
else:
self.reset() # Inits some vars
from serial import Serial
from time import *
ser = Serial("/dev/tty.usbserial-140", baudrate=115200) #or whatever
with open('main.hex', 'rb') as openfileobject:
for line in openfileobject:
print(line.strip())
ser.write(line.strip())
ser.write(b'\r')
sleep(0.01)
ser.write(b'0300R\r')
def __init__(self, *serial_device_parameters):
self.serial_device = Serial(*serial_device_parameters, timeout=.5)
init_serial(self.serial_device)
#!/usr/bin/env python
import sys, os, time
sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'lib_py'))
from serial import Serial
from dev import command_dev
s_port = command_dev
s_baud = 115200
ser = Serial(s_port, s_baud, timeout=5, writeTimeout=5)
#print s_port, s_baud
ser.write('R\n')
ser.flush()
print ser.readline()
class TFmini(object):
"""
TFMini - Micro LiDAR Module
https://www.sparkfun.com/products/14577
http://www.benewake.com/en/tfmini.html
"""
NOHEADER = 1
BADCHECKSUM = 2
TOO_MANY_TRIES = 3
DEC_MODE = 4
STD_MODE = 5
def __init__(self, port, mode=5, retry=25):
self.serial = Serial()
self.serial.port = port
self.serial.baudrate = 115200
self.serial.timeout = 0.005
self.serial.open()
self.retry = retry # how many times will I retry to find the packet header
self.mode = mode
self.strength = -1
if not self.serial.is_open:
raise Exception("ERROR: couldn't open port: {}".format(port))
self.setStdMode(self.mode)
def setStdMode(self, mode):
# do I need this?
if mode == self.STD_MODE:
cmd = [0x42, 0x57, 0x02, 0x00, 0x00, 0x00, 0x01,
0x06] # hex - packet
elif mode == self.DEC_MODE:
cmd = [0x42, 0x57, 0x02, 0x00, 0x00, 0x00, 0x04,
0x06] # dec - string
else:
raise Exception("ERROR: invalid mode {}".format(mode))
self.mode = mode
data = bytearray(cmd)
data = bytes(data)
self.serial.write(data)
time.sleep(0.1)
def __del__(self):
self.close()
def close(self):
self.serial.close()
def readString(self):
self.serial.flushInput()
tmp = []
d = ' '
while d != '\n':
d = self.serial.read(1)
tmp.append(d)
try:
tmp = tmp[:-2] # get rid of \r\n
ret = float(''.join(tmp))
except:
ret = None
return ret
def readPacket(self):
# it looks like it streams data, so no command to measure needed
self.serial.flushInput()
# find header
a, b = ' ', ' '
tmp = []
count = self.retry
while True:
tmp.append(a)
a = b
b = self.serial.read(1)
if len(a) > 0 and len(b) > 0:
if ord(a) == 0x59 and ord(b) == 0x59:
# print('found header')
break
if count == 0:
# print('nothing:', tmp)
# print('str', ''.join(tmp))
return None
count -= 1
raw = self.serial.read(7)
# build a packet (array) of ints
pkt = [ord(a), ord(b)] + list(map(ord, raw))
# print('pkt', pkt)
try:
ret = self.processPkt(pkt)
except Exception as e:
# print('bad')
print(e)
ret = None
return ret
def read(self):
"""
This is the main read() function. The others are automagically selected
based off the mode the sensor was set too.
STD Mode: return (dist, strength, quality)
DEC Mode: return range in meters
"""
if self.mode == self.STD_MODE:
ret = self.readPacket()
elif self.mode == self.DEC_MODE:
ret = self.readString()
else:
raise Exception('ERROR: read() invalid mode {}'.format(self.mode))
# weed out stupid returns ... strings can give crazy numbers
if ret > 12.0 or ret < 0.3:
ret = None
return ret
def processPkt(self, pkt):
"""
packet = [0x59, 0x59, distL, distH, strL, strH, reserved, integration time, checksum]
Note: the integration time always seems to be 0
"""
# turn string data into array of bytes
# pkt = list(map(ord, pkt))
if len(pkt) != 9:
raise Exception("ERROR: packet size {} != 9".format(len(pkt)))
# check header
if pkt[0] != 0x59 or pkt[1] != 0x59:
raise Exception("ERROR: bad header in packet")
# calculate checksum
cs = sum(pkt[:8])
cs &= 0xff
# print('cs', cs, pkt[8])
if pkt[8] != cs:
print('cs', cs, pkt[8])
raise Exception("ERROR: bad checksum in packet")
# print('L {} H {}'.format(pkt[2], pkt[3]))
dist = (pkt[2] + (pkt[3] << 8)) / 100
self.strength = pkt[4] + (pkt[5] << 8)
# q = pkt[7]
# print('ans',dist, st, q)
return dist
class Device(object):
def __init__(self, **kwargs):
self.steps_per_unit = STEPS_PER_INCH
self.pen_up_position = PEN_UP_POSITION
self.pen_up_speed = PEN_UP_SPEED
self.pen_up_delay = PEN_UP_DELAY
self.pen_down_position = PEN_DOWN_POSITION
self.pen_down_speed = PEN_DOWN_SPEED
self.pen_down_delay = PEN_DOWN_DELAY
self.acceleration = ACCELERATION
self.max_velocity = MAX_VELOCITY
self.corner_factor = CORNER_FACTOR
self.jog_acceleration = JOG_ACCELERATION
self.jog_max_velocity = JOG_MAX_VELOCITY
for k, v in kwargs.items():
setattr(self, k, v)
self.error = (0, 0) # accumulated step error
port = find_port()
if port is None:
raise Exception('cannot find axidraw device')
self.serial = Serial(port, timeout=1)
self.configure()
def configure(self):
servo_min = 7500
servo_max = 28000
pen_up_position = self.pen_up_position / 100
pen_up_position = int(
servo_min + (servo_max - servo_min) * pen_up_position)
pen_down_position = self.pen_down_position / 100
pen_down_position = int(
servo_min + (servo_max - servo_min) * pen_down_position)
self.command('SC', 4, pen_up_position)
self.command('SC', 5, pen_down_position)
self.command('SC', 11, int(self.pen_up_speed * 5))
self.command('SC', 12, int(self.pen_down_speed * 5))
def close(self):
self.serial.close()
def make_planner(self, jog=False):
a = self.acceleration
vmax = self.max_velocity
cf = self.corner_factor
if jog:
a = self.jog_acceleration
vmax = self.jog_max_velocity
return Planner(a, vmax, cf)
def readline(self):
return self.serial.readline().strip()
def command(self, *args):
line = ','.join(map(str, args))
self.serial.write(line + '\r')
return self.readline()
# higher level functions
def move(self, dx, dy):
self.run_path([(0, 0), (dx, dy)])
def goto(self, x, y, jog=True):
# TODO: jog if pen up
px, py = self.read_position()
self.run_path([(px, py), (x, y)], jog)
def home(self):
self.goto(0, 0, True)
# misc commands
def version(self):
return self.command('V')
# motor functions
def enable_motors(self):
m = MICROSTEPPING_MODE
return self.command('EM', m, m)
def disable_motors(self):
return self.command('EM', 0, 0)
def motor_status(self):
return self.command('QM')
def zero_position(self):
return self.command('CS')
def read_position(self):
response = self.command('QS')
self.readline()
a, b = map(int, response.split(','))
a /= self.steps_per_unit
b /= self.steps_per_unit
y = (a - b) / 2
x = y + b
return x, y
def stepper_move(self, duration, a, b):
return self.command('XM', duration, a, b)
def wait(self):
while '1' in self.motor_status():
time.sleep(0.01)
def run_plan(self, plan):
step_ms = TIMESLICE_MS
step_s = step_ms / 1000
t = 0
while t < plan.t:
i1 = plan.instant(t)
i2 = plan.instant(t + step_s)
d = i2.p.sub(i1.p)
ex, ey = self.error
ex, sx = modf(d.x * self.steps_per_unit + ex)
ey, sy = modf(d.y * self.steps_per_unit + ey)
self.error = ex, ey
self.stepper_move(step_ms, int(sx), int(sy))
t += step_s
# self.wait()
def run_path(self, path, jog=False):
planner = self.make_planner(jog)
plan = planner.plan(path)
self.run_plan(plan)
def run_drawing(self, drawing, progress=True):
print('number of paths : %d' % len(drawing.paths))
print('pen down length : %g' % drawing.down_length)
print('pen up length : %g' % drawing.up_length)
print('total length : %g' % drawing.length)
print('drawing bounds : %s' % str(drawing.bounds))
self.pen_up()
position = (0, 0)
bar = Bar(drawing.length, enabled=progress)
for path in drawing.paths:
jog = [position, path[0]]
self.run_path(jog, jog=True)
bar.increment(path_length(jog))
self.pen_down()
self.run_path(path)
self.pen_up()
position = path[-1]
bar.increment(path_length(path))
bar.done()
self.run_path([position, (0, 0)], jog=True)
def plan_drawing(self, drawing):
result = []
planner = self.make_planner()
for path in drawing.all_paths:
result.append(planner.plan(path))
return result
# pen functions
def pen_up(self):
delta = abs(self.pen_up_position - self.pen_down_position)
duration = int(1000 * delta / self.pen_up_speed)
delay = max(0, duration + self.pen_up_delay)
return self.command('SP', 1, delay)
def pen_down(self):
delta = abs(self.pen_up_position - self.pen_down_position)
duration = int(1000 * delta / self.pen_down_speed)
delay = max(0, duration + self.pen_down_delay)
return self.command('SP', 0, delay)
from serial import Serial
import sys
def sendcommand(s, cmd):
s.write(cmd)
s.write(b'\r')
lines = []
while True:
line = s.readline()
if line.startswith(b'ok:'):
break
if line.startswith(b'error:'):
raise RuntimeError(line.split(b':')[1].strip())
lines.append(line)
return lines
with Serial(sys.argv[1], timeout=10) as s:
print(sendcommand(s, b'ver'))
print(sendcommand(s, b'id'))
import cv2
import numpy as np
import video
from serial import Serial
import time
ser = Serial('/dev/ttyUSB0', baudrate=9600, timeout=1) # подключаемся к Arduino
edge = 35 # рамки условного центра изо6ражения
panAngle = 90 # начальное положение сервопривода 1
tiltAngle = 90 # начальное положение сервопривода 2
def ObjectPosition (x, y): # функция вывода в консоль координат центра цели
print ("[INFO] Object Center coordenates at X0 = {0} and Y0 = {1}".format(x, y))
def ServoPosition (x, y): # функция управления сервоприводами
global panAngle
global tiltAngle
if (x < width/2 - edge):
panAngle += 1
if panAngle > 170:
panAngle = 170
ser.write(bytearray([85, panAngle,180 - tiltAngle]))
if (x > width/2 + edge):
panAngle -= 1
class UBXStreamer:
"""
UBXStreamer class.
"""
def __init__(self, port, baudrate, timeout=5):
"""
Constructor.
"""
self._serial_object = None
self._serial_thread = None
self._ubxreader = None
self._connected = False
self._reading = False
self._port = port
self._baudrate = baudrate
self._timeout = timeout
def __del__(self):
"""
Destructor.
"""
self.stop_read_thread()
self.disconnect()
def connect(self):
"""
Open serial connection.
"""
try:
self._serial_object = Serial(self._port,
self._baudrate,
timeout=self._timeout)
self._ubxreader = UBXReader(BufferedReader(self._serial_object),
False)
self._connected = True
except (SerialException, SerialTimeoutException) as err:
print(f"Error connecting to serial port {err}")
def disconnect(self):
"""
Close serial connection.
"""
if self._connected and self._serial_object:
try:
self._serial_object.close()
except (SerialException, SerialTimeoutException) as err:
print(f"Error disconnecting from serial port {err}")
self._connected = False
def start_read_thread(self):
"""
Start the serial reader thread.
"""
if self._connected:
self._reading = True
self._serial_thread = Thread(target=self._read_thread, daemon=True)
self._serial_thread.start()
def stop_read_thread(self):
"""
Stop the serial reader thread.
"""
if self._serial_thread is not None:
self._reading = False
def send(self, data):
"""
Send data to serial connection.
"""
self._serial_object.write(data)
def flush(self):
"""
Flush input buffer
"""
self._serial_object.reset_input_buffer()
def waiting(self):
"""
Check if any messages remaining in the input buffer
"""
return self._serial_object.in_waiting
def _read_thread(self):
"""
THREADED PROCESS
Reads and parses UBX message data from stream
"""
while self._reading and self._serial_object:
if self._serial_object.in_waiting:
try:
(_, parsed_data) = self._ubxreader.read()
if parsed_data:
print(parsed_data)
except (
ube.UBXStreamError,
ube.UBXMessageError,
ube.UBXTypeError,
ube.UBXParseError,
) as err:
print(f"Something went wrong {err}")
continue
def poll_uart(self, layer=0):
"""
Poll the current BBR UART1/2 configuration
"""
position = 0
keys = ["CFG_UART1_BAUDRATE", "CFG_UART2_BAUDRATE"]
msg = UBXMessage.config_poll(layer, position, keys)
ubp.send(msg.serialize())
def set_uart(self, layers=1):
"""
Set the current BBR UART1/2 configuration
"""
transaction = 0
cfgData = [("CFG_UART1_BAUDRATE", 115200),
("CFG_UART2_BAUDRATE", 57600)]
msg = UBXMessage.config_set(layers, transaction, cfgData)
ubp.send(msg.serialize())
def unset_uart(self, layers=1):
"""
Unset (del) the current BBR UART1/2 configuration
"""
transaction = 0
keys = ["CFG_UART1_BAUDRATE", "CFG_UART2_BAUDRATE"]
msg = UBXMessage.config_del(layers, transaction, keys)
ubp.send(msg.serialize())
import time
from serialPort import serial_ports
from serial import Serial
s_port: str = serial_ports()
if s_port:
print(s_port + ' will be used')
else:
print('No serial port found')
exit()
s = Serial(s_port, 9600, timeout=1)
while True:
s.write(b'T')
res = s.readline()
if res:
try:
temp = float(res)
print(temp)
time.sleep(1)
except (KeyboardInterrupt, SystemExit):
raise
except:
raise
screen.blit(ftext, frect)
center_y += font.get_linesize()
def draw_ebar(start, time, duration, botleft, color):
effpercent = 100 - 100 * (time - start) / duration
effrect = pygame.Rect(0, 0, effpercent, 10)
effrect.bottomleft = botleft
pygame.draw.rect(screen, color, effrect)
ports = [p for p in list_ports.grep(sys.argv[1])]
if not ports:
raise IOError("Port " + sys.argv[1] + " not found!")
else:
serial = Serial(ports[0][0], 19200)
pygame.init()
info = pygame.display.Info()
size = w, h = info.current_w, info.current_h
screen = pygame.display.set_mode(size, pygame.FULLSCREEN)
pygame.display.set_caption("Space Battle")
srect = screen.get_rect()
pygame.mouse.set_visible(0)
ship = SpaceShip("resources/img/ship.png", [randint(0, w), randint(0, h)])
ship.rect = ship.rect.clamp(srect)
enemies = []
if endByte == PKG_END:
return data
else:
print('package error!')
return False
except:
print 'read error!'
return False
#---------------------------------------------------
#---------------------------------------------------
#MAIN
#---------------------------------------------------
#serial communication parameters
serialRobot = Serial() #new object
#Linux
#serialRobot.port = '/dev/ttyUSB0' #Port number or ID
#Windows
serialRobot.port = 'COM3' #Port number or ID
serialRobot.baud = 9600 #baud rate
#---------------------------------------------------
#opens the serial port
serialRobot.open()
#---------------------------------------------------
#decides which action should be sent to the robot
action = input('0: set position, 1: get position, 4: LED on, 5: LED off | ')
#----------------------------------------------------------------------------------
#ACTION 1: Set position of a servo
if (action == AX_SETPOSITION):
#inputs
class SniffleHW:
def __init__(self, serport):
self.decoder_state = SniffleDecoderState()
self.ser = Serial(serport, 2000000)
self.ser.write(b'@@@@@@@@\r\n') # command sync
self.recv_cancelled = False
self.rate_limiter = RateLimiter()
def _send_cmd(self, cmd_byte_list):
b0 = (len(cmd_byte_list) + 3) // 3
cmd = bytes([b0, *cmd_byte_list])
msg = b64encode(cmd) + b'\r\n'
self.rate_limiter.do_cmd()
self.ser.write(msg)
def cmd_chan_aa_phy(self, chan=37, aa=0x8E89BED6, phy=0, crci=0x555555):
if not (0 <= chan <= 39):
raise ValueError("Channel must be between 0 and 39")
if not (0 <= phy <= 2):
raise ValueError("PHY must be 0 (1M), 1 (2M), or 2 (coded)")
self._send_cmd([0x10, *list(pack("<BLBL", chan, aa, phy, crci))])
def cmd_pause_done(self, pause_when_done=False):
if pause_when_done:
self._send_cmd([0x11, 0x01])
else:
self._send_cmd([0x11, 0x00])
def cmd_rssi(self, rssi=-80):
self._send_cmd([0x12, rssi & 0xFF])
def cmd_mac(self, mac_byte_list=None, hop3=True):
if mac_byte_list is None:
self._send_cmd([0x13])
else:
if len(mac_byte_list) != 6:
raise ValueError("MAC must be 6 bytes!")
self._send_cmd([0x13, *mac_byte_list])
if hop3:
# hop with advertisements between 37/38/39
# unnecessary/detrimental with extended advertising
self._send_cmd([0x14])
def cmd_follow(self, enable=True):
if enable:
self._send_cmd([0x15, 0x01])
else:
self._send_cmd([0x15, 0x00])
def cmd_auxadv(self, enable=True):
if enable:
self._send_cmd([0x16, 0x01])
else:
self._send_cmd([0x16, 0x00])
def cmd_reset(self):
self._send_cmd([0x17])
def cmd_marker(self):
self._send_cmd([0x18])
# for master or slave modes
def cmd_transmit(self, llid, pdu):
if not (0 <= llid <= 3):
raise ValueError("Out of bounds LLID")
if len(pdu) > 255:
raise ValueError("Too long PDU")
self._send_cmd([0x19, llid, len(pdu), *pdu])
def cmd_connect(self, peerAddr, llData, is_random=True):
if len(peerAddr) != 6:
raise ValueError("Invalid peer address")
if len(llData) != 22:
raise ValueError("Invalid LLData")
self._send_cmd([0x1A, 1 if is_random else 0, *peerAddr, *llData])
def cmd_setaddr(self, addr, is_random=True):
if len(addr) != 6:
raise ValueError("Invalid MAC address")
self._send_cmd([0x1B, 1 if is_random else 0, *addr])
def cmd_advertise(self, advData, scanRspData):
if len(advData) > 31:
raise ValueError("advData too long!")
if len(scanRspData) > 31:
raise ValueError("scanRspData too long!")
paddedAdvData = [len(advData), *advData] + [0]*(31 - len(advData))
paddedScnData = [len(scanRspData), *scanRspData] + [0]*(31 - len(scanRspData))
self._send_cmd([0x1C, *paddedAdvData, *paddedScnData])
def cmd_adv_interval(self, intervalMs):
if not (20 < intervalMs < 0xFFFF):
raise ValueError("Advertising interval out of bounds")
self._send_cmd([0x1D, intervalMs & 0xFF, intervalMs >> 8])
def cmd_irk(self, irk=None, hop3=True):
if irk is None:
self._send_cmd([0x1E])
elif len(irk) != 16:
raise ValueError("Invalid IRK length!")
else:
self._send_cmd([0x1E, *irk])
if hop3:
self._send_cmd([0x14])
def recv_msg(self):
got_msg = False
while not got_msg:
pkt = self.ser.readline()
try:
data = b64decode(pkt.rstrip())
except BAError as e:
print(str(pkt, encoding='ascii').rstrip())
print("Ignoring message:", e, file=stderr)
continue
got_msg = True
if self.recv_cancelled:
self.recv_cancelled = False
return -1, None, b''
# msg type, msg body
return data[0], data[1:], pkt
def recv_and_decode(self):
mtype, mbody, pkt = self.recv_msg()
try:
if mtype == 0x10:
return PacketMessage(mbody, self.decoder_state)
elif mtype == 0x11:
return DebugMessage(mbody)
elif mtype == 0x12:
return MarkerMessage(mbody, self.decoder_state)
elif mtype == 0x13:
return StateMessage(mbody, self.decoder_state)
elif mtype == -1:
return None # receive cancelled
else:
raise SniffleHWPacketError("Unknown message type 0x%02X!" % mtype)
except BaseException as e:
print(str(pkt, encoding='ascii').rstrip())
print("Ignoring message:", e, file=stderr)
print_exc()
return None
def cancel_recv(self):
self.recv_cancelled = True
self.ser.cancel_read()
def mark_and_flush(self):
# use marker to zero time, flush every packet before marker
# also tolerate errors from incomplete lines in UART buffer
self.cmd_marker()
while True:
try:
msg = self.recv_and_decode()
except SniffleHWPacketError:
print("WARNING: invalid message during flush, ignoring...")
continue
if isinstance(msg, MarkerMessage):
break
def random_addr(self):
# generate a random static address, set it
addr = [randint(0, 255) for i in range(6)]
addr[5] |= 0xC0 # make it static
self.cmd_setaddr(bytes(addr))
# automatically generate sane LLData
def initiate_conn(self, peerAddr, is_random=True):
llData = []
# access address
llData.extend([randint(0, 255) for i in range(4)])
# initial CRC
llData.extend([randint(0, 255) for i in range(3)])
# WinSize, WinOffset, Interval, Latency, Timeout
llData.append(3)
llData.extend(pack("<H", randint(5, 15)))
llData.extend(pack("<H", 24))
llData.extend(pack("<H", 1))
llData.extend(pack("<H", 50))
# Channel Map
llData.extend([0xFF, 0xFF, 0xFF, 0xFF, 0x1F])
# Hop, SCA = 0
llData.append(randint(5, 16))
self.cmd_connect(peerAddr, bytes(llData), is_random)
# return the access address
return unpack("<L", bytes(llData[:4]))[0]
def sqImport(tId):
'''if tId == 0:
while 1:
rc = 0
while rc == 0:
rc = mqttc.loop()
print("rc: " + str(rc))'''
if tId == 1:
while 1:
global app
global MainWindow
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
if tId == 2:
#import pyautogui
from serial import Serial
port = 'COM53'
baudrate = 115200
ser = Serial(port, baudrate)
from pymouse import PyMouse
#pyautogui.PAUSE = 2.5
push = 1
counter = 0
m = PyMouse()
max_v = 13
centre = max_v / 2
threshold = max_v / 4
j = m.position()[0]
k = m.position()[1]
mainv = [0, 0, 0]
def C_value(this_value, centre):
reading = this_value * max_v / 1024
center = centre
distance = reading - center
if abs(distance) < threshold:
distance = 0
return distance
while 1:
try:
while True:
value = ser.readline().decode()
#chop(value)
#value2=int(value[4:7])
#button=int(value[8:9])
'''print(mainv[0])
print(mainv[1])
print(mainv[2])'''
x = int(value.split('-')[1])
y = int(value.split('-')[0])
push = int(value.split('-')[2])
#x_max = m.screen_size()[0]
#y_max = m.screen_size()[1]
x_new = int(C_value(x, centre))
y_new = int(C_value(y, centre))
#print(x_new,y_new,push)
m.move(j + x_new, k + y_new)
j = m.position()[0]
k = m.position()[1]
if push == 0:
counter = 1
if counter - push == 0:
m.click(j + x_new, k + y_new)
counter = 0
except:
print('Error')
class Stk500v2(ispBase.IspBase):
def __init__(self):
self.serial = None
self.seq = 1
self.lastAddr = -1
self.progressCallback = None
def connect(self, port='COM22', speed=115200):
if self.serial is not None:
self.close()
try:
self.serial = Serial(str(port),
speed,
timeout=1,
writeTimeout=10000)
except SerialException as e:
raise ispBase.IspError("Failed to open serial port")
except:
raise ispBase.IspError(
"Unexpected error while connecting to serial port:" + port +
":" + str(sys.exc_info()[0]))
self.seq = 1
#Reset the controller
for n in range(0, 2):
self.serial.setDTR(True)
time.sleep(0.1)
self.serial.setDTR(False)
time.sleep(0.1)
time.sleep(0.2)
self.serial.flushInput()
self.serial.flushOutput()
if self.sendMessage([
0x10, 0xc8, 0x64, 0x19, 0x20, 0x00, 0x53, 0x03, 0xac, 0x53,
0x00, 0x00
]) != [0x10, 0x00]:
self.close()
raise ispBase.IspError("Failed to enter programming mode")
self.sendMessage([0x06, 0x80, 0x00, 0x00, 0x00])
if self.sendMessage([0xEE])[1] == 0x00:
self._has_checksum = True
else:
self._has_checksum = False
self.serial.timeout = 5
def close(self):
if self.serial is not None:
self.serial.close()
self.serial = None
#Leave ISP does not reset the serial port, only resets the device, and returns the serial port after disconnecting it from the programming interface.
# This allows you to use the serial port without opening it again.
def leaveISP(self):
if self.serial is not None:
if self.sendMessage([0x11]) != [0x11, 0x00]:
raise ispBase.IspError("Failed to leave programming mode")
ret = self.serial
self.serial = None
return ret
return None
def isConnected(self):
return self.serial is not None
def hasChecksumFunction(self):
return self._has_checksum
def sendISP(self, data):
recv = self.sendMessage(
[0x1D, 4, 4, 0, data[0], data[1], data[2], data[3]])
return recv[2:6]
def writeFlash(self, flash_data):
#Set load addr to 0, in case we have more then 64k flash we need to enable the address extension
page_size = self.chip['pageSize'] * 2
flashSize = page_size * self.chip['pageCount']
print("Writing flash")
if flashSize > 0xFFFF:
self.sendMessage([0x06, 0x80, 0x00, 0x00, 0x00])
else:
self.sendMessage([0x06, 0x00, 0x00, 0x00, 0x00])
load_count = (len(flash_data) + page_size - 1) / page_size
for i in range(0, int(load_count)):
recv = self.sendMessage([
0x13, page_size >> 8, page_size
& 0xFF, 0xc1, 0x0a, 0x40, 0x4c, 0x20, 0x00, 0x00
] + flash_data[(i * page_size):(i * page_size + page_size)])
if self.progressCallback is not None:
if self._has_checksum:
self.progressCallback(i + 1, load_count)
else:
self.progressCallback(i + 1, load_count * 2)
def verifyFlash(self, flashData):
if self._has_checksum:
self.sendMessage([
0x06, 0x00, (len(flashData) >> 17) & 0xFF,
(len(flashData) >> 9) & 0xFF, (len(flashData) >> 1) & 0xFF
])
res = self.sendMessage([0xEE])
checksum_recv = res[2] | (res[3] << 8)
checksum = 0
for d in flashData:
checksum += d
checksum &= 0xFFFF
if hex(checksum) != hex(checksum_recv):
raise ispBase.IspError(
'Verify checksum mismatch: 0x%x != 0x%x' %
(checksum & 0xFFFF, checksum_recv))
else:
#Set load addr to 0, in case we have more then 64k flash we need to enable the address extension
flashSize = self.chip['pageSize'] * 2 * self.chip['pageCount']
if flashSize > 0xFFFF:
self.sendMessage([0x06, 0x80, 0x00, 0x00, 0x00])
else:
self.sendMessage([0x06, 0x00, 0x00, 0x00, 0x00])
loadCount = (len(flashData) + 0xFF) / 0x100
for i in range(0, int(loadCount)):
recv = self.sendMessage([0x14, 0x01, 0x00, 0x20])[2:0x102]
if self.progressCallback is not None:
self.progressCallback(loadCount + i + 1, loadCount * 2)
for j in range(0, 0x100):
if i * 0x100 + j < len(flashData) and flashData[
i * 0x100 + j] != recv[j]:
raise ispBase.IspError('Verify error at: 0x%x' %
(i * 0x100 + j))
def sendMessage(self, data):
message = struct.pack(">BBHB", 0x1B, self.seq, len(data), 0x0E)
for c in data:
message += struct.pack(">B", c)
checksum = 0
for c in message:
checksum ^= c
message += struct.pack(">B", checksum)
try:
self.serial.write(message)
self.serial.flush()
except SerialTimeoutException:
raise ispBase.IspError('Serial send timeout')
self.seq = (self.seq + 1) & 0xFF
return self.recvMessage()
def recvMessage(self):
state = 'Start'
checksum = 0
while True:
s = self.serial.read()
if len(s) < 1:
raise ispBase.IspError("Timeout")
b = struct.unpack(">B", s)[0]
checksum ^= b
#print(hex(b))
if state == 'Start':
if b == 0x1B:
state = 'GetSeq'
checksum = 0x1B
elif state == 'GetSeq':
state = 'MsgSize1'
elif state == 'MsgSize1':
msgSize = b << 8
state = 'MsgSize2'
elif state == 'MsgSize2':
msgSize |= b
state = 'Token'
elif state == 'Token':
if b != 0x0E:
state = 'Start'
else:
state = 'Data'
data = []
elif state == 'Data':
data.append(b)
if len(data) == msgSize:
state = 'Checksum'
elif state == 'Checksum':
if checksum != 0:
state = 'Start'
else:
return data
endV = vertex
minEnd = endDist
return startV, endV
if __name__ == "__main__":
yegGraph, location = load_edmonton_graph('edmonton-roads-2.0.1.txt')
cost = CostDistance(location)
with Serial("/dev/ttyACM0", baudrate = 9600, timeout = 1) as ser:
while True:
# infinite loop that echoes all messages from
# the arduino to the terminal
line = ser.readline()
line_string = line.decode("ASCII")
stripped = line_string.rstrip("\r\n")
print(stripped)
if not stripped:
#timeout and restart loop
continue
elif stripped[0] == 'R':
request = stripped.split()
print(request)
def __init__(self, name, port, baudrate, config):
ConnectorPrimitive.__init__(self, name)
self.port = port
self.baudrate = int(baudrate)
self.read_timeout = 0.01 # 10 milli sec
self.write_timeout = 5
self.config = config
self.target_id = self.config.get('target_id', None)
self.mcu = self.config.get('mcu', None)
self.polling_timeout = config.get('polling_timeout', 60)
self.forced_reset_timeout = config.get('forced_reset_timeout', 1)
self.skip_reset = config.get('skip_reset', False)
self.serial = None
# Assume the provided serial port is good. Don't attempt to use the
# target_id to re-discover the serial port, as the board may not be a
# fully valid DAPLink-compatable or Mbed Enabled board (it may be
# missing a mount point). Do not attempt to check if the serial port
# for given target_id changed. We will attempt to open the port and
# pass the already opened port object (not name) to the reset plugin.
serial_port = None
if self.port is not None:
# A serial port was provided.
# Don't pass in the target_id, so that no change in serial port via
# auto-discovery happens.
self.logger.prn_inf("using specified port '%s'" % (self.port))
serial_port = HostTestPluginBase().check_serial_port_ready(
self.port, target_id=None, timeout=self.polling_timeout)
else:
# No serial port was provided.
# Fallback to auto-discovery via target_id.
self.logger.prn_inf("getting serial port via mbedls)")
serial_port = HostTestPluginBase().check_serial_port_ready(
self.port,
target_id=self.target_id,
timeout=self.polling_timeout)
if serial_port is None:
raise ConnectorPrimitiveException("Serial port not ready!")
if serial_port != self.port:
# Serial port changed for given targetID
self.logger.prn_inf("serial port changed from '%s to '%s')" %
(self.port, serial_port))
self.port = serial_port
startTime = time.time()
self.logger.prn_inf(
"serial(port=%s, baudrate=%d, read_timeout=%s, write_timeout=%d)" %
(self.port, self.baudrate, self.read_timeout, self.write_timeout))
while time.time() - startTime < self.polling_timeout:
try:
# TIMEOUT: While creating Serial object timeout is delibrately passed as 0. Because blocking in Serial.read
# impacts thread and mutliprocess functioning in Python. Hence, instead in self.read() s delay (sleep()) is
# inserted to let serial buffer collect data and avoid spinning on non blocking read().
self.serial = Serial(self.port,
baudrate=self.baudrate,
timeout=0,
write_timeout=self.write_timeout)
except SerialException as e:
self.serial = None
self.LAST_ERROR = "connection lost, serial.Serial(%s, %d, %d, %d): %s" % (
self.port, self.baudrate, self.read_timeout,
self.write_timeout, str(e))
self.logger.prn_err(str(e))
self.logger.prn_err("Retry after 1 sec until %s seconds" %
self.polling_timeout)
else:
if not self.skip_reset:
self.reset_dev_via_serial(delay=self.forced_reset_timeout)
break
time.sleep(1)
def list_ports():
""" Lists serial port names
:raises EnvironmentError:
On unsupported or unknown platforms
:returns:
A list of the serial ports available on the system
"""
if sys.platform.startswith('win'):
ports = ['COM%s' % (i + 1) for i in range(256)]
elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):
# this excludes your current terminal "/dev/tty"
ports = glob.glob('/dev/tty[A-Za-z]*')
elif sys.platform.startswith('darwin'):
ports = glob.glob('/dev/tty.*')
else:
raise EnvironmentError('Unsupported platform')
result = []
for port in ports:
try:
s = Serial(port)
s.close()
result.append(port)
except (OSError, SerialException):
pass
return result
