def __init__(self, serial=None): """Creates an AyabCommunication object, with an optional serial-like object.""" logging.basicConfig(level=logging.DEBUG) self.__logger = logging.getLogger(type(self).__name__) self.__ser = serial self.__driver = sliplib.Driver() self.__rxMsgList = list()
def receive(self, length):
"""Reads in data from a serial port (length bytes), decodes SLIP packets
A function which reads from the serial port and then uses the SlipLib
module to decode the SLIP protocol packets. Each message received
is added to a receive buffer in SlipLib which is then returned.
Args:
length (int): Length to receive with serialPort.read(length)
Returns:
bytes: An iterator of the receive buffer
"""
# Create a sliplib Driver
slipDriver = sliplib.Driver()
# Receive data from serial port
ret = self._serialPort.read(length)
# Decode data from slip format, stores msgs in sliplib.Driver.messages
try:
temp = slipDriver.receive(ret)
except sliplib.slip.ProtocolError as error:
print("SLIP decode error...")
print(error)
# Return empty list,
# TODO: Unit test this!
return []
return iter(temp)
def send(self, msg):
"""Encodes data to slip protocol and then sends over serial port
Uses the SlipLib module to convert the message data into SLIP format.
The message is then sent over the serial port opened with the instance
of the Faraday class used when invoking send().
Args:
msg (bytes): Bytes format message to send over serial port.
Returns:
int: Number of bytes transmitted over the serial port.
"""
# Create a sliplib Driver
slipDriver = sliplib.Driver()
# Package data in slip format
# TODO: Unit test this!
slipData = slipDriver.send(msg)
# Send data over serial port
res = self._serialPort.write(slipData)
# Return number of bytes transmitted over serial port
return res
def protocol_begin():
if use_serial:
global ser, driver
ser = serial.Serial(args.serial_port, args.serial_baud, timeout=10) # Establish the connection on a specific port
driver = sliplib.Driver()
else:
global osc_client
osc_client = udp_client.SimpleUDPClient(args.osc_ip, args.osc_port)
def __init__(self):
super().__init__()
self._transport = None # type: serial.aio.SerialTransport
self._seq = 0
self._drv = sliplib.Driver()
self.logger = logger
self._msg_handlers = {
CommandId.DEVICE_STATE: self.handle_dev_state,
CommandId.DEVICE_STATE_CHANGED: self.handle_dev_state_changed,
# 0x1c: self.ignore_message,
CommandId.APS_DATA_INDICATION: self.handle_incoming_data,
CommandId.READ_PARAMETER: self.handle_get_parameter_response
}
self._requests = {} # type: typing.Dict[int, asyncio.Future]
def init():
global slip_driver
logger.info("Starting up EPP...")
try:
#init everything heretup here
gpio.init()
slip_driver = sliplib.Driver()
#raise
logger.info("Everything inited...")
except:
logger.error("Error while initing...")
def test_serialParamaterizedSynchReceive(test_input):
"""
Tests a synchronous faradayio receive command with data. This should read
in data, convert it to slip format, libraryand return the original message
"""
# Create class object necessary for test
serialInstance = faraday.SerialTestClass()
slip = sliplib.Driver()
faradayRadio = faraday.Faraday(serialInstance.serialPort)
# Create slip message to test against
slipMsg = slip.send(test_input)
# Use serial to send raw transmission with slip protocol
res = serialInstance.serialPort.write(slipMsg)
# Receive data from Faraday which yields each item it parses from slip
for item in faradayRadio.receive(res):
# Should be only one item
assert item == test_input
def __init__(self, sock):
self.sock = sock
timeout = self.sock.gettimeout()
if not timeout:
self.sock.settimeout(0.1)
self.driver = sliplib.Driver()
self.message_q = queue.Queue()
self.packet_q = queue.Queue()
self.running = True
self.connection_closed = threading.Event()
self.recv_thread = threading.Thread(target=self.receive_data)
self.send_thread = threading.Thread(target=self.send_data)
self.recv_thread.start()
self.send_thread.start()
self.connection_closed.wait()
self.running = False
self.recv_thread.join(0.5)
self.send_thread.join(0.5)
def hard_reset(self):
os.system('gpio write 0 0; sleep 2; gpio write 0 1')
self._drv = sliplib.Driver()
import serial
import sliplib
"""
END = 0300,
ESC = 0333,
ESC_END = 0334,
ESC_ESC = 0335
"""
# Global settings of for the serial port
com_port = "COM3"
baudrate = 9600
#SLIP-Decoder
decoder = sliplib.Driver()
connection = serial.Serial(com_port, baudrate, timeout=0)
connection.flush()
#get the data from the serial-port
def data_in(expected_length):
bytes_to_read = connection.inWaiting()
if bytes_to_read >= expected_length:
byte_package = connection.read(expected_length)
return byte_package
else:
return False
'''
Created on 24 aug. 2016
@author: Ruud
'''
import socket
import sys
import sliplib
if __name__ == '__main__':
host, port = sys.argv[1:3]
sock = socket.create_connection((host, port))
driver = sliplib.Driver()
while True:
message = input('Message>')
if not message:
break
message = bytes(message, 'utf-8')
driver.send(message)
data = driver.packets
sock.sendall(data)
rcvd = sock.recv(1024)
driver.receive(rcvd)
messages = driver.messages
print(messages)
