class NBIOT():
def __init__(self,uart_port,uart_baud):
self.nbiot = UART(uart_port,uart_baud)
def check_sim(self):
self.nbiot.write("AT+CIMI\r\n")
time.sleep(0.5)
info = self.nbiot.read()
try:
info = info.decode()
except (UnicodeError,AttributeError):
return -1
return info
def setup_tcp(self):
self.nbiot.write("AT+QIOPEN=1,0,\"TCP\",\"114.115.148.172\",8888,1234,1\r\n")
time.sleep(3)
info = self.nbiot.read()
try:
info = info.decode()
except (UnicodeError,AttributeError):
return -1
return info
def send(self,info):
len_info = len(info)
message = 'AT+QISEND=0,' + str(len_info) + ',' + info + '\r\n'
self.nbiot.write(message)
time.sleep(3)
info = self.nbiot.read()
try:
info = info.decode()
except (UnicodeError,AttributeError):
return -1
return info
class SONIC():
def __init__(self,uart_port,uart_baud):
self.sonic = UART(uart_port,uart_baud)
def clear(self):
if self.sonic.any():
data = self.sonic.read(100)
def read(self):
if self.sonic.any():
data = self.sonic.read(10)
try:
data = data.decode()
except UnicodeError:
return -1
data = data[0:len(data)-1]
return data
else:
return -1
def get_data(self):
self.clear()
time.sleep(2)
sonic_data = -1
while(sonic_data == -1):
sonic_data = self.read()
return sonic_data
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
class Sensor():
def __init__(self, num, value):
self.data1 = 0
self.data2 = 0
self.data3 = 0
self.data4 = 0
self.state = 0
self.uart = UART(num, value)
time.sleep(1)
def open_s(self):
data = [0x11, 0x02, 0x0b, 0x00, 0xe2]
for i in range(0, len(data)):
self.uart.writechar(data[i])
time.sleep(0.03)
while self.uart.any() == 0:
continue
self.uart.read()
def close_s(self):
data = [0x11, 0x03, 0x0c, 0x01, 0x1e, 0xc1]
for i in range(0, len(data)):
self.uart.writechar(data[i])
time.sleep(0.03)
while self.uart.any() == 0:
continue
self.uart.read()
def work_s(self):
data = [0x11, 0x01, 0x0b, 0xe3]
for i in range(0, len(data)):
self.uart.writechar(data[i])
time.sleep(0.03)
while self.uart.any() == 0:
continue
data_ = []
for i in range(0, 20):
a = self.uart.readchar()
if i >= 2:
data_.append(a)
self.data1 = data_[1] * 256**3 + data_[2] * 256**2 + data_[
3] * 256 + data_[4]
self.data2 = data_[5] * 256**3 + data_[6] * 256**2 + data_[
7] * 256 + data_[8]
self.data3 = data_[9] * 256 + data_[10]
self.data4 = data_[11] * 256 + data_[12]
def read_s(self):
if self.state == 3:
self.open_s()
self.state = 2
if self.state == 2:
self.work_s()
if self.state == 1:
self.close_s()
self.state = 0
return self.data1, self.data2, self.data3, self.data4
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 getcommand(port):
ser = UART(6, 115200)
while True:
try:
data = ser.read(1)
if str(data.decode('utf-8')) == 's':
move = ser.read(3)
move = move.decode('utf-8')
if str(move[2]) == 'e':
#ledMove[int(move[0])][int(move[1])]()
movements[int(move[0])][int(move[1])]()
except:
pass
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')
class Display():
def __init__(self, num, value):
self.uart = UART(num, value)
time.sleep(1)
def read_disp(self):
str = 'a'
if self.uart.any() != 0:
str = self.uart.read()
if str == b'begin':
return 3
elif str == b'end':
return 1
else:
return 0
def write_disp(self, strr, num):
a = 'main.' + strr + '.val=' + str(num)
self.uart.write(a)
self.uart.writechar(0xff)
self.uart.writechar(0xff)
self.uart.writechar(0xff)
time.sleep(0.03)
def write_d(self, n0, n1, n2, n3, n4, n5):
self.write_disp('n0', n0)
self.write_disp('n1', n1)
self.write_disp('n2', n2)
self.write_disp('n3', n3)
self.write_disp('n4', n4)
self.write_disp('n5', n5)
class JYMCU(object):
"""JY-MCU Bluetooth serial device driver. This is simply a light UART wrapper
with addition AT command methods to customize the device."""
def __init__(self, uart, baudrate):
""" uart = uart #1-6, baudrate must match what is set on the JY-MCU.
Needs to be a #1-C. """
self._uart = UART(uart, baudrate)
def __del__(self):
self._uart.deinit()
def any(self):
return self._uart.any()
def write(self, astring):
return self._uart.write(astring)
def writechar(self, achar):
self._uart.writechar(achar)
def read(self, num=None):
return self._uart.read(num)
def readline(self):
return self._uart.readline()
def readchar(self):
return self._uart.readchar()
def readall(self):
return self._uart.readall()
def readinto(self, buf, count=None):
return self._uart.readinto(buf, count)
def _cmd(self, cmd):
""" Send AT command, wait a bit then return result string. """
self._uart.write("AT+" + cmd)
udelay(500)
return self.readline()
def baudrate(self, rate):
""" Set the baud rate. Needs to be #1-C. """
return self._cmd("BAUD" + str(rate))
def name(self, name):
""" Set the name to show up on the connecting device. """
return self._cmd("NAME" + name)
def pin(self, pin):
""" Set the given 4 digit numeric pin. """
return self._cmd("PIN" + str(pin))
def version(self):
return self._cmd("VERSION")
def setrepl(self):
repl_uart(self._uart)
class AS7265x:
def __init__(self,uart_channel,buadrate):
self.uart = UART(uart_channel,buadrate)
self.DataBuffer[]
def __Version():
self.uart.write("ATVERSW\r\n")
SensorResponse = self.uart.read()
print(SensorResponse)
def __SystemHardware():
class GY39:
def __init__(self,uart):
self.uart = UART(uart, 9600)
def read(self):
self.uart.read()
time.sleep_ms(10)
hc=self.uart.read()
# hex_array = []
# for i in list(hc):
# hex_array.append('%02X'%i)
# print(hex_array,hex_array[0])
l=(hc[4]<<24)|(hc[5]<<16)|(hc[6]<<8)|hc[9]
t=((hc[13]<<8)|hc[14])/100
p=((hc[15]<<24)|(hc[16]<<16)|(hc[17]<<8)|hc[18])/100
h=((hc[19]<<8)|hc[20])/100
H=((hc[21]<<8)|hc[22])
return l,t,p,h,H
class SONIC():
def __init__(self, uart_port, uart_baud):
self.sonic = UART(uart_port, uart_baud)
def clear(self):
if self.sonic.any():
data = self.sonic.read(100)
def read(self):
if self.sonic.any():
data = self.sonic.read(10)
try:
data = data.decode()
except UnicodeError:
return -1
data = data[0:len(data) - 1]
return data
else:
return -1
class Scan():
def __init__(self):
self.scan = UART(3, 9600, read_buf_len=100)
def count(self):
return self.scan.any()
def receive(self):
time.sleep_ms(100)
count = self.count()
data = self.scan.read(count).decode()
return {'code': data}
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 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 main():
## X1,X2路PWM波分别作为激励和采样保持开关信号,非晶丝串联150ohm电阻
## 激励电流25-30mA
tim = Timer(2, freq=500000) #500Khz
ch1 = tim.channel(1, Timer.PWM, pin=pyb.Pin('X1', pyb.Pin.OUT_PP))
ch2 = tim.channel(2, Timer.PWM, pin=pyb.Pin('X2', pyb.Pin.OUT_PP))
ch1.pulse_width_percent(20)
ch2.pulse_width_percent(30)
## 2路光耦，Y1 启动与关闭，Y2同步
ext_sts1 = extState()
ext_sts2 = extState()
ExtInt(pyb.Pin('Y1'), ExtInt.IRQ_FALLING, Pin.PULL_NONE, ext_sts1.callback)
ExtInt(pyb.Pin('Y2'), ExtInt.IRQ_FALLING, Pin.PULL_NONE, ext_sts2.callback)
## 创建文件
file_name = new_file()
data_file = open(file_name, 'w')
## uart1, Tx -> X9 Rx -> X10
uart = UART(1, 57600)
while not ext_sts1.new_event: # 等待启动信号,要求采集客户端先启动
buf = uart.read(128)
ext_sts1.clear()
pyb.LED(1).on()
pyb.LED(2).on()
while not ext_sts1.new_event: # 等待结束信号
if ext_sts2.new_event: # 写同步信号
ext_sts2.clear()
data_file.write('\n-- new block ---\n')
pyb.LED(2).toggle()
buf = uart.read(128)
data_file.write(buf)
data_file.close()
pyb.LED(1).off()
pyb.LED(2).off()
class NBIOT():
def __init__(self,uart_port,uart_baud):
self.nbiot = UART(uart_port,uart_baud,read_buf_len = 256)
def read(self):
info = self.nbiot.read()
try:
info = info.decode()
except (UnicodeError,AttributeError):
return -1
return info
def readline(self):
info = self.nbiot.readline()
try:
info = info.decode()
except (UnicodeError,AttributeError):
return -1
return info
def check_sim(self):
self.nbiot.write("AT+CIMI\r\n")
time.sleep(3)
rebound = self.readline()
iccid = self.readline()
neglect = self.readline()
state = self.readline()
return str(iccid),str(state)
def check_csq(self):
self.nbiot.write("AT+CESQ\r\n")
time.sleep(3)
rebound = self.readline()
cesq = self.readline()
neglect = self.readline()
state = self.readline()
return int(cesq[7:9]),str(state)
def create_socket(self):
self.nbiot.write("AT+QIOPEN=1,0,\"TCP\",\"115.236.36.53\",506,1234,1\r\n")
time.sleep(5)
info = self.read()
return info
def close_socket(self):
self.nbiot.write("AT+QICLOSE=0\r\n")
time.sleep(5)
info = self.read()
return info
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
class Lcd():
def __init__(self):
self.lcd = UART(1, 9600)
def send_real(self, v, c, t):
if self.lcd.any():
self.lcd.read(self.lcd.any())
v = v.split('.')[0]
c = c.split('.')[0]
t = t.split('.')[0]
self.lcd.write('main.v.val=%s' % v)
self.lcd.writechar(255)
self.lcd.writechar(255)
self.lcd.writechar(255)
self.lcd.write('main.c.val=%s' % c)
self.lcd.writechar(255)
self.lcd.writechar(255)
self.lcd.writechar(255)
self.lcd.write('main.t.val=%s' % t)
self.lcd.writechar(255)
self.lcd.writechar(255)
self.lcd.writechar(255)
def send_stand(self, vv, cc):
if self.lcd.any():
self.lcd.read(self.lcd.any())
vv = vv.split('.')[0]
cc = cc.split('.')[0]
self.lcd.write('main.vv.val=%s' % vv)
self.lcd.writechar(255)
self.lcd.writechar(255)
self.lcd.writechar(255)
self.lcd.write('main.cc.val=%s' % cc)
self.lcd.writechar(255)
self.lcd.writechar(255)
self.lcd.writechar(255)
class FIG:
def __init__(self, uart):
self.uart = UART(uart, 57600)
self.sendcmd(link)
self.sendcmd(readflash)
self.sendcmd(readmould)
self.sendcmd(readindex)
self.sendcmd(readindex1)
delay(500)
def sendcmd(self, cmd):
self.uart.write(head)
self.uart.write(cmd)
def searchfig(self):
hc = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.uart.read()
self.sendcmd(cmd_search)
hc = self.uart.read()
while hc[11] != 0xa:
self.sendcmd(cmd_search)
hc = self.uart.read()
self.sendcmd(cmd_upload)
def savefig(self, addr):
print('请按手指')
self.searchfig()
self.sendcmd(cmd_gen1)
print('请再按手指')
self.searchfig()
self.sendcmd(cmd_gen2)
self.sendcmd(cmd_reg)
add = cmd_save + bytearray([addr, 0, addr + 0xe])
self.sendcmd(add)
print('存入成功')
def disfig(self):
print('请按手指')
self.searchfig()
print('识别中')
self.uart.read()
delay(20)
self.sendcmd(cmd_gen1)
self.sendcmd(cmd_dis)
delay(10)
hc = self.uart.read()
delay(10)
if hc[9] == 9:
return 0
else:
return hc[11]
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()
class Network():
def __init__(self):
self.network = UART(6, 115200, read_buf_len=200)
def count(self):
return self.network.any()
def receive(self):
time.sleep_ms(100)
count = self.count()
data = self.network.read(count).decode()
data = data.strip()
return eval(data)
def send(self, data):
ss = json.dumps(data)
self.network.write(ss)
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 JYMCU(object):
"""JY-MCU Bluetooth serial device driver. This is simply a light UART wrapper
with addition AT command methods to customize the device."""
def __init__( self, uart, baudrate ):
""" uart = uart #1-6, baudrate must match what is set on the JY-MCU.
Needs to be a #1-C. """
self._uart = UART(uart, baudrate)
def __del__( self ) : self._uart.deinit()
def any( self ) : return self._uart.any()
def write( self, astring ) : return self._uart.write(astring)
def writechar( self, achar ) : self._uart.writechar(achar)
def read( self, num = None ) : return self._uart.read(num)
def readline( self ) : return self._uart.readline()
def readchar( self ) : return self._uart.readchar()
def readall( self ) : return self._uart.readall()
def readinto( self, buf, count = None ) : return self._uart.readinto(buf, count)
def _cmd( self, cmd ) :
""" Send AT command, wait a bit then return result string. """
self._uart.write("AT+" + cmd)
udelay(500)
return self.readline()
def baudrate( self, rate ) :
""" Set the baud rate. Needs to be #1-C. """
return self._cmd("BAUD" + str(rate))
def name( self, name ) :
""" Set the name to show up on the connecting device. """
return self._cmd("NAME" + name)
def pin( self, pin ) :
""" Set the given 4 digit numeric pin. """
return self._cmd("PIN" + str(pin))
def version( self ) : return self._cmd("VERSION")
def setrepl( self ) : repl_uart(self._uart)
class NBIOT():
def __init__(self,uart_port,uart_baud):
self.nbiot = UART(uart_port,uart_baud,read_buf_len = 256)
def read(self):
info = self.nbiot.read()
try:
info = info.decode()
except (UnicodeError,AttributeError):
return -1
return info
def readline(self):
info = self.nbiot.readline()
try:
info = info.decode()
except (UnicodeError,AttributeError):
return -1
return info
def check_sim(self):
self.nbiot.write("AT+CIMI\r\n")
time.sleep(3)
rebound = self.readline()
iccid = self.readline()
neglect = self.readline()
state = self.readline()
return str(iccid),str(state)
def check_csq(self):
self.nbiot.write("AT+CESQ\r\n")
time.sleep(3)
rebound = self.readline()
cesq = self.readline()
neglect = self.readline()
state = self.readline()
return int(cesq[7:9]),str(state)
class NBIOT():
def __init__(self, uart_port, uart_baud):
self.modbus = MODBUS()
self.nbiot = UART(uart_port, uart_baud, read_buf_len=256)
def read(self):
info = self.nbiot.read()
try:
info = info.decode()
except (UnicodeError, AttributeError):
return -1
return info
def readline(self):
info = self.nbiot.readline()
try:
info = info.decode()
except (UnicodeError, AttributeError):
return -1
return info
def check_sim(self):
self.nbiot.write("AT+CIMI\r\n")
time.sleep(3)
rebound = self.readline()
neglect = self.readline()
neglect = self.readline()
iccid = self.readline()
neglect = self.readline()
info = self.readline()
return str(iccid), str(info)
def create_socket(self):
self.nbiot.write(
"AT+QIOPEN=1,0,\"TCP\",\"115.236.36.53\",506,1234,1\r\n")
time.sleep(5)
info = self.read()
return info
def close_socket(self):
self.nbiot.write("AT+QICLOSE=0\r\n")
time.sleep(5)
info = self.read()
return info
def tcp_send(self, load_info):
cell_info = load_info[0]
sonic_info = load_info[1]
operator_info = load_info[2]
info = self.modbus.getpack(cell_info, sonic_info, operator_info)
len_info = len(info)
message = 'AT+QISEND=0,' + str(len_info) + ',' + info + '\r\n'
self.nbiot.write(message)
time.sleep(10)
rebound = self.readline()
state = self.readline()
neglect = self.readline()
send_state = self.readline()
neglect = self.readline()
return str(state), str(send_state)
def tcp_receive(self, time_delay=30):
time.sleep(time_delay)
neglect = self.readline()
info = self.readline()
info = info[0:len(info) - 1]
return info
def tcp_process(self, info):
self.close_socket()
time.sleep(3)
self.close_socket()
print("MINIC THE SENDING")
while (1):
self.modbus.iccid, get_state = self.check_sim()
if (get_state.find('OK') != -1):
print("CHECK SIM OK")
break
while (1):
get_state = str(self.create_socket())
if (get_state.find('OK') != -1):
if (get_state.find('QIOPEN') != -1):
print("OPEN TCP OK")
break
while (1):
state, send_state = self.tcp_send(info)
if (state.find('OK') != -1 and send_state.find('SEND OK') != -1):
print("SENDING OK")
break
print("TIME DELAY FOR RX")
rx_message = self.tcp_receive()
print("TASK COMPLETE")
while (1):
get_state = str(self.close_socket())
if (get_state.find('OK') != -1):
print("CLOSE TCP OK")
break
return rx_message
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:
message = '1'
go_check = 0
start = pyb.millis() # Used for RPS calculation
speed_pulse_width = 20
while(True):
# STOP CODE (measures distance to stop by counting rotations of wheel using Hall Effect interrupt)
# We have a better stop code using "blobs" (SEE VIKRAM'S CODE FOR CHECKOFF 2!!!)
if(counter > 440):
inA.high()
inB.high()
# BLUETOOTH CONTROL
if uart.any():
print("UART")
cmd = (str)(bytes.decode(uart.read()))
print(cmd)
if cmd == "g": #go
counter = 0
inA.high()
inB.low()
go_check = 1
cmd = "x"
elif cmd == "q": #hard brake
inA.high()
inB.high()
go_check = 0
import json
#GU620模块初始化
N1 = Pin('Y6', Pin.OUT_PP)#定义通信系统启动引脚
N1.low()
pyb.delay(2000)
N1.high()
pyb.delay(10000)#拉高拉低引脚，启动通信系统
u2 = UART(4,115200,timeout = 50)#定义串口4，设置 波特率为115200
#初始化 HTTP 应用
u2.write('AT+HTTPINIT\r\n')
getURLCMD = 'AT+HTTPPARA=1,"http://old.tpyboard.com/v702/httptest.php?t=123456"\r\n'
#getURLCMD = 'AT+HTTPPARA=1,"https://www.baidu.com"\r\n'
while True:
if u2.any() > 0:
dataRead = u2.read()
print('_dataRead:',dataRead)
print('-'*30)
if dataRead.find(b'OK') > -1:
#AT命令执行成功
#判断是执行的哪一步操作
if dataRead.find(b'AT+HTTPINIT') > -1:
#初始化HTTP成功
#设置 HTTP 参数值 设置url
u2.write(getURLCMD)
elif dataRead.find(b'AT+HTTPPARA=1') > -1:
#HTTP参数设置成功
#发起GET请求获取数据
u2.write('AT+HTTPACTION=0\r\n')
elif dataRead.find(b'AT+HTTPREAD\r\n\r\n+HTTPREAD') > -1:
#返回可用的数据信息，进行解析 获取到数据长度
print(uart)
uart = UART(pins=('GP12', 'GP13'))
print(uart)
uart = UART(pins=(None, 'GP17'))
print(uart)
uart = UART(baudrate=57600, pins=('GP16', 'GP17'))
print(uart)
# 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')
print(uart0.read(2) == b'23')
print(uart0.read() == b'')
uart0.write(b'123')
buf = bytearray(3)
print(uart1.readinto(buf, 1) == 1)
print(buf)
print(uart1.readinto(buf) == 2)
print(buf)
# try initializing without the id
uart0 = UART(baudrate=1000000, pins=uart_pins[0][0])
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()
# test we can correctly create by id or name
for bus in (-1, 0, 1, 2, 3, 4, 5, 6, 7, "XA", "XB", "YA", "YB", "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))
print(uart.read(100))
# 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))
print(uart.read(100))
adc.read() # read value, 0 - 4095
'''
1.10 DAC
'''
from pyb import Pin, DAC
dac = DAC(Pin('X5'))
dac.write(120) # output between 0 and 255
'''
1.11 UART
'''
from pyb import UART
uart1 = UART(1, 9600)
uart1.write('hello')
uart1.read(5) # read up to 5 bytes
'''
1.12 SPI Bus
'''
from pyb import SPI
spi1 = SPI(1, SPI.MASTER, baudrate=200000, polarity=1, phase=0)
spi1.send('hello')
spi1.recv(5) # receive 5 bytes on the bus
spi1.sedn_recv('hello') # send a receive 5 byrtes
'''
1.13 I2C Bus
'''
from pyb import I2C
i2c1 = I2C(1, I2C.MASTER, baudrate=100000)
class HA7S:
""" Class for 1-wire master using HA7S.
Contains drivers for:
DS18B20 temp sensor
Display controller PIC for LCD
DS2423 Counter (2 channels 32 bits counters)
"""
def __init__(self, uart_port):
self.ROW_LENGTH = 20 # LCD 4 rows x 20 chars
self.uart = UART(uart_port, 9600)
def scan_for_devices(self):
""" Find all 1-Wire rom_codes on the bus """
strt = micros()
rom_codes = [] # Prepare list with Units found on the bus
r = "" # Return string
r = self.tx_rx('S', 17) # Search for first device
if len(r) > 1:
rom_codes.append(r[:-1]) # Add to list (Skip final <cr>)
##print("Första enhet: ", rom_codes)
while True:
# delay(100)
r = self.tx_rx('s', 17) # Search next rom_codes todo: ger timeout sista gången
if len(r) > 1:
rom_codes.append(r[:-1]) # Add to list (Skip final <cr>)
else:
break
# print("Enheter: ", rom_codes)
##print("Scan for devices: ", elapsed_micros(strt) / 1e6, 's')
return rom_codes
def read_ds18b20_temp(self, rom):
""" Setup and read temp data from DS18b20 """
# Todo: check negative temps works
retries = 3
while retries:
""" Initiate Temperature Conversion by selecting and sending 0x44-command """
resp = self.tx_rx(b'A' + rom + '\r', 17) # Adressing
dummy = self.tx_rx('W0144\r', 3) # Write block of data '44' Trigg measurement
resp1 = self.tx_rx('M\r', 17) # Reset AND reselect (enl HA7S doc)
if resp1 == resp:
delay(750) # Give DS18B20 time to measure
# The temperature result is stored in the scratchpad memory
data = self.tx_rx(b'W0ABEFFFFFFFFFFFFFFFFFF\r', 21) # Write to scratchpad and READ result
dummy = self.tx_rx('R', 1) # Reset
m = self.hex_byte_to_int(data[4:6])
l = self.hex_byte_to_int(data[2:4])
t = (m << 8) | (l & 0xff)
if m < 8:
t *= 0.0625 # Convert to Temp [°C]; Plus
else:
# temp given as 2's compl 16 bit int
t = (t - 65536) * 0.0625 # Convert to Temp [°C]; Minus
print("Rom, retur temperatur: ", rom, data, t, '°C')
return t
else:
retries -= 1
print("Retries: resp, resp1: ", retries, resp, resp1)
if retries < 1:
break
def read_ds2423_counters(self, rom):
""" Read counter values for the two counters (A & B) conncted to external pins """
resp = self.tx_rx(b'A' + rom + '\r', 17) # Adressing
""" Write/read block: A5 01C0/01E0(CounterA/B) [MSByte sent last] + 'FF'*42 (timeslots during which slave
returns 32 bytes scratchpad data + 4(cntA/cntB) + 4(zeroBytes) + 2 CRC bytes """
# Todo: check if respons = written; repeat otherwise
# We set adr so we only read LAST byte of page 14. We also get counter(4 B) + zerobytes(4 B) and CRC(2 B)
dataA = self.tx_rx('W0EA5DF01' + 'FF' * 11 + '\r', 29) # Read mem & Counter + TA1/TA2 (adr = 0x11C0)
dummy = self.tx_rx('M\r', 17) # Reset AND reselect (enl HA7S doc)
# We set adr so we only read LAST byte of page 15. We also get counter(4 B) + zerobytes(4 B) and CRC(2 B)
dataB = self.tx_rx('W0EA5FF01' + 'FF' * 11 + '\r', 29) # Read mem & Counter + TA1/TA2 (adr = 0x11C0)
dummy = self.tx_rx('R\r', 1) # Reset and red data (b'BE66014B467FFF0A102D\r')
''' Convert 32 bits hexadecimal ascii-string (LSByte first) to integer '''
cntA = self.lsb_first_hex_ascii_to_int32(dataA[8:16])
cntB = self.lsb_first_hex_ascii_to_int32(dataB[8:16])
print("ReadCnt: ", cntA, cntB, dataA, dataB)
return (cntA, cntB)
def write_ds2423_scratchpad(self, rom, s, target_adr):
""" Write to Scratchpad (max 32 bytes)
target_adr [0..0x1FF] as integer
Not implemented: readback of CRC after end of write. This works ONLY if data
written extends to end of page """
self.tx_rx(b'A' + rom + '\r', 17) # Adressing
""" Write to scratach: 'OF' [TA1/TA2] (Byte reversed) + data string as hex ascii
HA7S can only write 32 bytes in a chunk. """
# Todo: check if respons = written; repeat otherwise
# Check string length AND that it fits on page (check target_adr + s_len)
s_len = len(s)
if target_adr < 0x200 and s_len <= 32 and (target_adr % 0x20) + s_len <= 32:
swap_adr = self.int8_to_2hex_string(target_adr & 0xFF) + self.int8_to_2hex_string(target_adr >> 8)
if s_len > 29:
''' Send first 16 bytes only, as first part '''
resp1 = self.tx_rx('W130F' + swap_adr + self.bin2hex(s[:16]) + '\r', 7 + 32) # First 16 bytes of data
''' Adjust parameters for next write '''
nr_bytes_hex = self.int8_to_2hex_string(s_len - 16)
s = s[16:]
s_len -= 16
# Send rest of string as second part
resp2 = self.tx_rx('W' + nr_bytes_hex + self.bin2hex(s) + '\r', 1 + (s_len * 2)) # Only string now
resp = resp1[:6] + ':' + resp1[6:-1] + '/' + resp2
else:
nr_bytes_hex = self.int8_to_2hex_string(3 + s_len)
resp = self.tx_rx('W' + nr_bytes_hex + '0F' + swap_adr + self.bin2hex(s) + '\r', 7 + (s_len * 2))
dummy = self.tx_rx('R\r', 1) # Reset and stop
print("write_ds2423_scratchpad: Reponse", resp)
else:
print("write_ds2423_scratchpad: String will not fit!; Target_adr or length of string to big!")
def read_and_copy_ds2423_scratchpad(self, rom):
""" Read Scratchpad and copy to SRAM
First TA1/TA2 and 'Ending offset E/S' is fetched from scratchpad contents and then
the offset inside scratchpad is set to 5 lsbits of TA1, and data is fetched from there until 'Ending offset'.
'Ending offset' is the offset for the last chr written to scratchpad
Finally a copy of (updated part of) scratchpad is written to SRAM """
# Todo: check if respons = written; repeat otherwise
self.tx_rx(b'A' + rom + '\r', 17) # Adressing
auth = self.tx_rx('W04AA' + ('FF' * 3) + '\r', 9) # Read 'AA' + TA1/TA2 + Status(E/S)
target_adr = (self.hex_byte_to_int(auth[4:6]) << 8) + self.hex_byte_to_int(auth[2:4]) # MSB and LSB Swapped
status = self.hex_byte_to_int(auth[6:8])
print(" read_and_copy_ds2423_scratchpad: auth, targetAdress, Status(E/S) 'Ending offset': ",
auth, hex(target_adr), hex(status & 0x1F))
''' Continue reading timeslots until end of written part of scratchpad '''
nr_bytes = (status & 0x1F) - (target_adr & 0x1F) + 1 # 1+Ending offset-Start offset = # bytes written/to read
nr_bytes_hex = self.int8_to_2hex_string(nr_bytes)
data = self.tx_rx('W' + nr_bytes_hex + ('FF' * nr_bytes) + '\r', (2 * nr_bytes) + 1) # Read rest of chars
dummy = self.tx_rx('M\r', 17) # Reset and adress again
""" Write Copy scratchpad command: copy scratchpad to memory –– Authenticate with previous TA1/TA2 + E/S """
a = list(auth[2:-1])
s = ''
for b in a:
s += chr(b)
##print("auth: ", a, chr(b), s)
resp = self.tx_rx('W045A' + s + '\r', 9) # Copy Scratch: '5A' + TA1/TA2 + Status(E/S)
dummy = self.tx_rx('R\r', 1) # Reset and stop
print(" read_and_copy_ds2423_scratchpad: Repons: ", resp[:-1], ':', data, nr_bytes)
return data
def read_ds2423_mem(self, rom, page):
""" Read Memory page (32 bytes)
page = page-number as integer [0..15]; the whole page is read.
If reading includes the last byte in a page, DS2423 also sends counter value(4 bytes) + 12 bytes more
Reading can continue into next page, BUT HA7S can only read 32 bytes in a chunk. """
# Todo: check if respons = written; repeat otherwise
page_adr = self.int16_to_4hex_string((page % 16) * 0x20)
page_swap = page_adr[2:] + page_adr[:2] # Swap MSB and LSB
resp = self.tx_rx(b'A' + rom + '\r', 17) # Adressing
""" Write/read block: A5 01C0/01E0(CounterA/B) [or ANY PAGE (= adr)] + 'FF'*42 (timeslots during which slave
returns 32 ramData + 4(cntA/cntB) + 2(0) + 2 CRC bytes; All data as hex ascii (Byte reversed) """
data1 = self.tx_rx('W13F0' + page_swap + 'FF' * 16 + '\r', 39) # Read mem + TA1/TA2 (adr = 0x01E0)
''' We can continue sending timeslots for reading data until we send Reset '''
data2 = self.tx_rx('W10' + 'FF' * 16 + '\r', 33) # Continue fetching ram data
dummy = self.tx_rx('R\r', 1) # Reset and stop reading
##print("Repons: ", resp, data1, data2)
d = data1[6:-1] + data2[:-1] # Skip respons, cmd, TA1, TA2 and '\r'
s = self.hex_bytes_to_str(d)
return (d, s)
def lcd_init(self, rom, use_custom_chars=True):
""" Init LCD with custom chr generator """
if use_custom_chars:
# Load Character generator into user area of CG-RAM
# chr0 = [0b10001, 0b01111]
chr0 = [0b01010, 0b00000, 0b00100, 0b01010, 0b11111, 0b10001, 0b10001, 0b00000, # 'Ä' {'ä' finns i #225}
0b01010, 0b00000, 0b01110, 0b10001, 0b10001, 0b10001, 0b01110, 0b00000, # 'Ö' {'ö' finns i #239}
0b00100, 0b01010, 0b00100, 0b01110, 0b10001, 0b11111, 0b10001, 0b00000, # 'Å'
0b00100, 0b01010, 0b00100, 0b01110, 0b10001, 0b10001, 0b01111, 0b00000, # 'å'
0b01100, 0b10010, 0b10010, 0b01100, 0b00000, 0b00000, 0b00000, 0b00000, # '°'
0b00000, 0b00000, 0b01111, 0b10001, 0b10001, 0b01111, 0b00001, 0b01110, # 'g'
0b01010, 0b00000, 0b01110, 0b00001, 0b01110, 0b10001, 0b01111, 0b00000, # 'ä' finns i #225
0b00000, 0b01010, 0b00000, 0b01110, 0b10001, 0b10001, 0b01110, 0b00000] # 'ö' finns i #239
''' First adress PIC via HA7Scommand "A" '''
dummy = self.tx_rx(b'A' + rom + b'\r', 17) # Adressing
dummy = self.tx_rx('W021040\r', 5) # Write 0x40 directly to LCD register: Set start adr = 0 in CG-RAM
delay(1)
dummy = self.tx_rx('M\r', 17) # Reset AND reselect
for c in chr0: # Send chr0 to LCD CG-RAM (max 8 chrs á 8 bytes)
dummy = self.tx_rx('W0212' + self.bin2hex(chr(c)) + '\r', 5) # Write font (chr0) to LCD CG-RAM
delay(1)
dummy = self.tx_rx('M\r', 17) # Reset AND reselect
# Switch back to pointing to DDRAM (NOT CGRAM), else will clobber CGRAM !!
# self.hal_write_command(0x80 | 0) # Set start adr = 0
dummy = self.tx_rx('W021080\r', 5) # Write 0x40 directly to LCD register memory: Point to CDDRAM
delay(1)
dummy = self.tx_rx('R\r', 17) # Reset
def print_on_lcd(self, rom, msg, row_nr, col=0, clear_LCD=False, use_custom_chars=False):
""" Send text message to scratchpad memory in PIC with HA7S Write/Read block cmd
then copy from scratchpad to LCD
N.B. swedish char åäöÅÄÖ and other non US-ASCII charas are sent as UTF-8 (2 chars)
entries in user_char with chr >127, does not work? """
user_char = {'Ä': chr(0), 'Ö': chr(1), 'Å': chr(2), 'å': chr(3), # Custom chr in CGRAM
'°': chr(4), 'g': chr(5), # Custom chr in CGRAM
'ä': chr(225), 'ö': chr(239), 'p': chr(240), # Already available in CGROM
'∑': chr(246), 'Ω': chr(244), 'µ': chr(228)} # todo: investigeate if works if > 127
# Row nr to LCD memory adr for start of row [0–3] [Valid for 4 rows x 20 chars LCD ONLY]
lcd_row_adr = {0: 0x00, 1: 0x40, 2: 0x14, 3: 0x54}
''' First adress LCD kontroller via HA7Scommand "A" '''
dummy = self.tx_rx(b'A' + rom + b'\r', 17) # Adressing
if clear_LCD:
''' Clear display first '''
delay(1)
dummy = self.tx_rx('W0149\r', 3) # Write block '49' 1 byte: Clear LCD
delay(3)
dummy = self.tx_rx('M\r', 17) # Reset AND reselect
line_adr = self.bin2hex(chr(lcd_row_adr[row_nr] + col)) # LCD memory adr to use on LCD for chosen row
''' Convert msg to string of hex bytes
Truncate msg if msg longer than fits on row (20 chars)'''
if use_custom_chars:
s = ''
for char in msg: # Exchange some chars
if char in user_char: # character should be changed?
s += user_char[char] # change char if so
else:
s += char
msg = s
msg_len = len(msg)
if msg_len > (self.ROW_LENGTH - col):
msg_len = self.ROW_LENGTH - col
msg_hex = self.bin2hex(msg[:self.ROW_LENGTH - col]) # Truncate
else:
msg_hex = self.bin2hex(msg) # Convert to hex string (no '0x' before each byte)
''' Can only transfer max 16 chars to scratchpad LCD memory per transfer: First tfr 16 chrs + 2nd tfr for rest '''
if msg_len > 16:
len_hex = self.bin2hex(chr(16 + 2)) # Limit to 16 + 2 bytes first transmission
dummy = self.tx_rx('W' + len_hex + '4E' + line_adr + msg_hex[:16 * 2] + '\r', 37) # Write first 16 chars to
# scratchpad
delay(1)
dummy = self.tx_rx('M\r', 17) # Reset AND reselect
dummy = self.tx_rx('W0148\r', 3) # Copy Scratchpad to LCD
''' Adjust parameters for next part of msg to write to LCD memory '''
msg_len -= 16
msg_hex = msg_hex[16 * 2:] # keep unsent part only
line_adr = self.bin2hex(chr(lcd_row_adr[row_nr] + col + 16)) # LCD memory adr to use on LCD for 17:th
# char
dummy = self.tx_rx('M\r', 17) # Reset AND reselect (enl HA7S doc)
len_hex = self.bin2hex(chr(msg_len + 2)) # Len = BYTE count for remaining data
dummy = self.tx_rx('W' + len_hex + '4E' + line_adr + msg_hex + '\r', len(msg_hex) + 5) # Write to scratchpad
delay(1)
resp1 = self.tx_rx('M\r', 17) # Reset AND reselect
dummy = self.tx_rx('W0148\r', 3) # Copy Scratchpad to LCD
delay(2)
''' Turn LCD back-light ON '''
dummy = self.tx_rx('M\r', 17) # Reset AND reselect
dummy = self.tx_rx('W0108\r', 3) # Write block '08' 1 byte: LCD backlight on
dummy = self.tx_rx('R', 1) # Reset
def tx_rx(self, tx, nr_chars):
""" Send command to and receive respons from SA7S"""
''' rx = uart.readall() # Receive respons TAKES 1.0 sec ALWAYS (after uart.any) TimeOut!!!! '''
i = 0
rx = ''
# todo: do check if respons == same as sent: repeat otherwise
self.uart.write(tx) # Send to unit
# print("uart.write: i, tx: ", i, tx[:-1])
while True: # Typiskt 2–3 (search: 4) varv i loopen
i += 1
if self.uart.any(): # returns True if any characters wait
dbg.high()
strt = micros()
rx = b''
j = 0
while True: # Typically 10–20 (search: 12; M, R & W0144: 1) loops
j += 1
rxb = self.uart.read(nr_chars) # uart.readln och uart.readall ger båda timeout (1s default)
rx = rx + rxb
if (len(rx) >= nr_chars) or (rxb == b'\r'): # End of search returns \r
break
dbg.low()
##print("uart.read: i, j, tx, rx, ∆time ", i, j, tx[:-1], rx, len(rx), elapsed_micros(strt) / 1e6, 's')
delay(84)
break
else:
delay(10)
return rx
def hex_bytes_to_str(self, s):
""" Convert bytes (2 ascii hex char each) to string of ascii chars """
def hex_char_to_int(c):
##print("c:", hex(c), chr(c))
if c >= 65:
c -= 55 # 'A' = 10
else:
c -= 48 # '0' = 0
return c
r = ''
s = str.upper(s) # Raise to upper case
for i in range(0, len(s), 2):
m = hex_char_to_int(s[i])
l = hex_char_to_int(s[i + 1])
t = (m << 4) + (l & 0xf)
r += chr(t)
##print("Byte: r", r)
return r
def hex_byte_to_int(self, s):
""" Convert byte (2 ascii hex char) to int """
def hex_char_to_int(c):
##print("c:", hex(c), chr(c))
if c >= 65:
c -= 55 # 'A' = 10
else:
c -= 48 # '0' = 0
return c
r = []
s = str.upper(s) # Raise to upper case
for i in range(0, len(s), 2):
m = hex_char_to_int(s[i])
l = hex_char_to_int(s[i + 1])
t = (m << 4) + (l & 0xf)
r.append(t)
##print("Byte: m l t r", m, l, t, r)
return r[0]
def lsb_first_hex_ascii_to_int32(self, s):
""" Convert 32 bits hexadecimal ascii-string (LSByte first) to 32 bit integer """
cnt = (self.hex_byte_to_int(s[6:8]) << 24) + (self.hex_byte_to_int(s[4:6]) << 16) + \
(self.hex_byte_to_int(s[2:4]) << 8) + self.hex_byte_to_int(s[0:2])
return cnt
def bin2hex(self, s): # Works for i 0–127; NOT 128+
""" Convert integer to hex string with full width w/o '0x'-prefix """
return binascii.hexlify(s).decode("utf-8")
def int4_to_1hex_string(self, i4):
""" Convert integer to hex string with full width w/o '0x'-prefix """
return ''.join('{:01X}'.format(i4))
def int8_to_2hex_string(self, i8):
""" Convert integer to hex string with full width w/o '0x'-prefix """
return ''.join('{:02X}'.format(i8))
def int16_to_4hex_string(self, i16):
""" Convert integer to hex string with full width w/o '0x'-prefix """
return ''.join('{:04X}'.format(i16))
def int32_to_8hex_string(self, i32):
""" Convert integer to hex string with full width w/o '0x'-prefix """
return ''.join('{:08X}'.format(i32))
