def _idle_thread(self):
if self.gc_enable and (self.last_gc == 0 or after(self.last_gc) > GCTIME):
gc.collect()
self.last_gc = ticks_us()
if self.heartbeat is not None and (self.last_heartbeat == 0 or after(self.last_heartbeat) > HBTIME):
self.heartbeat.toggle()
self.last_heartbeat = ticks_us()
async def loop(self) :
if self._verbose :
logging.info("TaskBase: loop starting.")
while self.isRunning() :
if not self.disabled :
try :
self.num_calls += 1
start_ticks_us = utime.ticks_us()
result = self.perform()
self.ticks_us += utime.ticks_diff(utime.ticks_us(), start_ticks_us)
if not result:
return
self.last_retry_ms = None
except Exception as e :
if not self.last_retry_ms :
self.last_retry_ms = 500
else :
self.last_retry_ms = min(self.sleep_ms, self.last_retry_ms * 2)
self.num_failures += 1
logging.info("An error occurred performing {}: {}".format(self, e))
sys.print_exception(e)
await uasyncio.sleep_ms(self.sleep_ms if not self.last_retry_ms else self.last_retry_ms)
else :
await uasyncio.sleep_ms(914)
self.state = TaskBase.STOPPED
if self._verbose :
logging.info("TaskBase: loop terminated.")
return
def __init__(self, kp, ki, kd, dt, max_out, min_out, start_time = None):
''' Initializing
Arguments:
kp = proportional gain, float > 0
kd = derivative gain, float >= 0
ki = integral gain, float >=-
dt = sample time (ms)
max_out = the maximum output of the controller
min_out = the minimum output of the controller
'''
print('Creating PID controller...')
self.kp = kp
self.kd = kd / dt
self.ki = ki * dt
self.dt = dt
self.max_output = max_out
self.min_output = min_out
if start_time is None:
self.current_time = utime.ticks_us()
self.previous_time = self.current_time
else:
self.current_time = 0.0
self.previous_time = 0.0
self.last_Error = 0.0
self.last_state = 0.0
self.integral_term = 0.0
self.output = 0.0
def _udp_thread(self):
"""
UDP thread, reads data from the server and handles it.
"""
while not self.udp_stop:
try:
data, src = self.sock.recvfrom(1024)
_token = data[1:3]
_type = data[3]
if _type == PUSH_ACK:
self._log("Push ack")
elif _type == PULL_ACK:
self._log("Pull ack")
elif _type == PULL_RESP:
self.dwnb += 1
ack_error = TX_ERR_NONE
tx_pk = ujson.loads(data[4:])
tmst = tx_pk["txpk"]["tmst"]
t_us = tmst - utime.ticks_us() - 12500
if t_us < 0:
t_us += 0xFFFFFFFF
if t_us < 20000000:
self.uplink_alarm = Timer.Alarm(
handler=lambda x: self._send_down_link(
ubinascii.a2b_base64(tx_pk["txpk"]["data"]),
tx_pk["txpk"]["tmst"] - 50, tx_pk["txpk"]["datr"],
int(tx_pk["txpk"]["freq"] * 1000000)
),
us=t_us
)
else:
ack_error = TX_ERR_TOO_LATE
self._log('Downlink timestamp error!, t_us: {}', t_us)
self._ack_pull_rsp(_token, ack_error)
self._log("Pull rsp")
except usocket.timeout:
pass
except OSError as ex:
if ex.errno != errno.EAGAIN:
self._log('UDP recv OSError Exception: {}', ex)
except Exception as ex:
self._log('UDP recv Exception: {}', ex)
# wait before trying to receive again
utime.sleep_ms(UDP_THREAD_CYCLE_MS)
# we are to close the socket
self.sock.close()
self.udp_stop = False
self._log('UDP thread stopped')
def test(spi=3, cs='PB0'):
print("SPI flash")
cs = Pin(cs, Pin.OUT)
spi = SPI(spi, baudrate=42000000, polarity=0, phase=0)
flash = SPIFlash(spi, cs)
print("Getting chip ID...")
flash.wait()
id_ = flash.getid()
print("ID:", ubinascii.hexlify(id_))
print("Reading block (32b) from address 0...")
buf = bytearray(32)
flash.read_block(0, buf)
print(ubinascii.hexlify(buf))
addr = 12 * 600 + 8
print("Reading block (32b) from address {}...".format(addr))
flash.read_block(addr, buf)
print(ubinascii.hexlify(buf))
addr = 524288
print("Erasing 4k block at address {}...".format(addr))
t1 = ticks_us()
flash.erase(addr, '4k')
# flash.erase(addr, '32k')
# flash.erase(addr, '64k')
# flash.erase_chip()
t = ticks_diff(ticks_us(), t1)
print("erase {} us".format(t))
print("Writing blocks (256b) at address {}...".format(addr))
buf = bytearray(range(256))
t1 = ticks_us()
flash.write_block(addr, buf)
t = ticks_diff(ticks_us(), t1)
mbs = len(buf) * 8. / t
print("write({}) {} us, {} mbs".format(len(buf), t, mbs))
print("Verifying write...")
v = bytearray(256)
flash.read_block(addr, v)
if (v == buf):
print("write/read ok")
else:
print("write/read FAILed")
print("Timing 32k read from address 0...")
gc.collect()
buf = bytearray(32 * 1024)
t1 = ticks_us()
flash.read_block(0, buf)
t = ticks_diff(ticks_us(), t1)
mbs = len(buf) * 8. / t
print("read({}) {} us, {} mbs".format(len(buf), t, mbs))
def compute_output(self, desired_state, current_state, current_time = None, previous_time = None):
if current_time is None:
# print('Current Time is None')
self.current_time = utime.ticks_us()
else:
self.current_time = current_time
if previous_time is not None:
self.previous_time = previous_time
# print('Current State: {}\t Desired State: {}'.format(current_state, desired_state))
# print('Current Time: {}\t Previous Time: {}'.format(self.current_time, self.previous_time))
if utime.ticks_diff(self.current_time, self.previous_time) >= self.dt:
self.error = desired_state - current_state
#
# Correct for heading 'wrap around' to find shortest turn
# if self.error > 180:
# self.error -= 360
# elif self.error < -180:
# self.error += 360
self.integral_term += self.ki * self.error
self.state_change = current_state - self.last_state
self.last_state = current_state
# print('Error: {:}\t Error_dot: {:.4f}'.format(self.error, self.state_change))
self.output = self.kp * self.error + self.integral_term - self.kd * self.state_change
# limit the output to within the range of possible values
if self.output > self.max_output:
self.output = self.max_output
# print('Limiting PID ouput to maximum')
elif self.output < self.min_output:
# print('Limiting PID output to minimum')
self.output = self.min_output
self.previous_time = self.current_time
# print('PID output: {:}\n'.format(self.output))
# print('{},{}\n'.format(current_state, self.output))
return self.output
def __call__(self, ts):
if self.expect_ts:
if ts is None:
raise ValueError('Timestamp expected but not supplied.')
else:
if is_micropython:
ts = time.ticks_us()
else:
raise RuntimeError('Not MicroPython: provide timestamps and a timediff function')
# ts is now valid
if self.start_time is None: # 1st call: self.start_time is invalid
self.start_time = ts
return 0.0001 # 100μs notional delay. 1st reading is invalid in any case
dt = self.timediff(ts, self.start_time)
self.start_time = ts
return dt
def _send_down_link(self, data, tmst, datarate, frequency):
"""
Transmits a downlink message over LoRa.
"""
self.lora.init(
mode=LoRa.LORA,
frequency=frequency,
bandwidth=self._dr_to_bw(datarate),
sf=self._dr_to_sf(datarate),
preamble=8,
coding_rate=LoRa.CODING_4_5,
tx_iq=True
)
while utime.ticks_us() < tmst:
pass
self.lora_sock.send(data)
self._log(
'Sent downlink packet scheduled on {:.3f}, at {:.1f} Mhz using {}: {}',
tmst / 1000000,
self._freq_to_float(frequency),
datarate,
data
)
def cbl(pinin):
global max_latency
dt = utime.ticks_diff(utime.ticks_us(), t)
max_latency = max(max_latency, dt)
print('Latency {:6d}μs {:6d}μs max'.format(dt, max_latency))
def microsWhen(timediff): # Expected value of counter in a given no. of uS
if timediff >= MAXTIME:
raise TimerException()
return (ticks_us() + timediff) & TIMERPERIOD
def microsUntil(tim): # uS from now until a specified time (used in Delay class)
return ((tim - ticks_us()) & TIMERPERIOD)
def _cb_right():
self.tright[self.iright & 15] = ticks_us()
self.iright += 1
def ping(host, count=4, timeout=5000, interval=10, quiet=False, size=64):
import utime
import uselect
import uctypes
import usocket
import ustruct
import urandom
# prepare packet
assert size >= 16, "pkt size too small"
pkt = b'Q' * size
pkt_desc = {
"type": uctypes.UINT8 | 0,
"code": uctypes.UINT8 | 1,
"checksum": uctypes.UINT16 | 2,
"id": uctypes.UINT16 | 4,
"seq": uctypes.INT16 | 6,
"timestamp": uctypes.UINT64 | 8,
} # packet header descriptor
h = uctypes.struct(uctypes.addressof(pkt), pkt_desc, uctypes.BIG_ENDIAN)
h.type = 8 # ICMP_ECHO_REQUEST
h.code = 0
h.checksum = 0
h.id = urandom.getrandbits(16)
h.seq = 1
# init socket
sock = usocket.socket(usocket.AF_INET, usocket.SOCK_RAW, 1)
sock.setblocking(0)
sock.settimeout(timeout / 1000)
addr = usocket.getaddrinfo(host, 1)[0][-1][0] # ip address
sock.connect((addr, 1))
not quiet and print("PING %s (%s): %u data bytes" % (host, addr, len(pkt)))
seqs = list(range(1, count + 1)) # [1,2,...,count]
c = 1
t = 0
n_trans = 0
n_recv = 0
finish = False
while t < timeout:
if t == interval and c <= count:
# send packet
h.checksum = 0
h.seq = c
h.timestamp = utime.ticks_us()
h.checksum = checksum(pkt)
if sock.send(pkt) == size:
n_trans += 1
t = 0 # reset timeout
else:
seqs.remove(c)
c += 1
# recv packet
while 1:
socks, _, _ = uselect.select([sock], [], [], 0)
if socks:
resp = socks[0].recv(4096)
resp_mv = memoryview(resp)
h2 = uctypes.struct(uctypes.addressof(resp_mv[20:]), pkt_desc,
uctypes.BIG_ENDIAN)
# TODO: validate checksum (optional)
seq = h2.seq
if h2.type == 0 and h2.id == h.id and (
seq in seqs): # 0: ICMP_ECHO_REPLY
t_elasped = (utime.ticks_us() - h2.timestamp) / 1000
ttl = ustruct.unpack('!B', resp_mv[8:9])[0] # time-to-live
n_recv += 1
not quiet and print(
"%u bytes from %s: icmp_seq=%u, ttl=%u, time=%f ms" %
(len(resp), addr, seq, ttl, t_elasped))
seqs.remove(seq)
if len(seqs) == 0:
finish = True
break
else:
break
if finish:
break
utime.sleep_ms(1)
t += 1
# close
sock.close()
ret = (n_trans, n_recv)
not quiet and print("%u packets transmitted, %u packets received" %
(n_trans, n_recv))
return (n_trans, n_recv)
def after(trigtime): # If current time is after the specified value return
res = ((ticks_us() - trigtime) & TIMERPERIOD) # the no. of uS after. Otherwise return zero
if res >= MAXTIME:
res = 0
return res
def pulse(delay: int):
while True:
# normalize sin from interval -1:1 to 0:1
yield 0.5 + 0.5 * math.sin(utime.ticks_us() / delay)
def new_func(*args, **kwargs):
t = utime.ticks_us()
result = f(*args, **kwargs)
delta = utime.ticks_diff(t, utime.ticks_us())
print('Function {} Time = {:6.3f}ms'.format(myname, delta/1000))
return result
def microsWhen(timediff): # Expected value of counter in a given no. of uS
if timediff >= MAXTIME:
raise TimerException()
return (ticks_us() + timediff) & TIMERPERIOD
def __init__(self,
run_motor,
name='NoName',
priority=0,
period=None,
profile=False,
trace=False):
""" Initializes a task object, saving copies of constructor parameters
and preparing an empty dictionary for states.
@param run_fun The function which implements the task's code. It must
be a generator which yields the current state
@param name The name of the task, by default 'NoName.' This should
@b really be overridden with a more descriptive name by the user
@param priority The priority of the task, a positive integer with
higher numbers meaning higher priority (default 0)
@param period The time in milliseconds between runs of the task if
it's run by a timer or @c None if the task is not run by a timer.
The time can be given in a @c float or @c int; it will be
converted to microseconds for internal use by the scheduler
@param profile Set to @c True to enable run-time profiling
@param trace Set to @c True to generate a list of transitions between
states. @b Note: This slows things down and allocates memory. """
# The function which is run to implement this task's code. Since it
# is a generator, we "run" it here, which doesn't actually run it but
# gets it going as a generator which is ready to yield values
#self._run_gen = run_fun ()
self._run_gen = run_motor()
## The name of the task, hopefully a short and descriptive string.
self.name = name
## The task's priority, an integer with higher numbers meaning higher
# priority.
self.priority = int(priority)
## The period, in microseconds, between runs of the task's @c run()
# method. If the period is @c None, the @c run() method won't be run
# on a time basis but will instead be run by the scheduler as soon
# as feasible after code such as an interrupt handler calls the
# @c go() method.
if period != None:
self.period = int(period * 1000)
self._next_run = utime.ticks_us() + self.period
else:
self.period = period
self._next_run = None
# Flag which causes the task to be profiled, in which the execution
# time of the @c run() method is measured and basic statistics kept.
self._prof = profile
self.reset_profile()
# The previous state in which the task last ran. It is used to watch
# for and track state transitions.
self._prev_state = 0
# If transition tracing has been enabled, create an empty list in
# which to store transition (time, to-state) stamps
self._trace = trace
self._tr_data = []
self._prev_time = utime.ticks_us()
## Flag which is set true when the task is ready to be run by the
# scheduler
self.go_flag = False
except OSError as e:
restart_and_reconnect()
# Now that the client is connected lets get some info to send
adc = ADC(Pin(32))
adc.width(ADC.WIDTH_12BIT)
adc.atten(ADC.ATTN_11DB)
#---------------data part---------------#
message_interval = 50 #in miliseconds
sample_freq = 8000 #Hz
ticks_max = ticks_add(0, -1)
print("Time intil clock resets: ", ticks_max / 1e6 / 60, " minutes")
#---------------------------------------#
start_beggining = ticks_us() #saves the start of the measurement
data = []
def publish(*args):
global data
global start_beggining
data.append(ticks_diff(ticks_us(), start_beggining))
client.publish(topic_pub, ujson.dumps(data))
data = [ticks_us()] #initiates a new data packet
start_beggining = ticks_us() #saves the new measurement beggining
tim = Timer(-1)
# LED Control Example
#
# This example shows how to control your OpenMV Cam's built-in LEDs. Use your
# smart phone's camera to see the IR LEDs.
import time, utime, math, pyb
from pyb import Pin, ExtInt
from pyb import LED
red_led = LED(1)
old = utime.ticks_us()
#old2 = utime.ticks_us()
#new = utime.ticks_ms()
#i = 0
diff = 1
sum = 0
count = 0
def callback(e):
print(e)
#global diff, old #, count
#diff = utime.ticks_diff(old, utime.ticks_us())
#if (diff > 13):
#print(diff)
#old = utime.ticks_us()
##count += 1
##red_led.on()
##utime.sleep_us(10)
def get_ms(self):
state = machine.disable_irq()
t = self.t_ms
acquired = self.acquired
machine.enable_irq(state)
return t + utime.ticks_diff(utime.ticks_us(), acquired) // 1000
def microsUntil(tim): # uS from now until a specified time (used in Delay class)
return ((tim - ticks_us()) & TIMERPERIOD)
async def read_coro():
imu.mag_trigger()
await asyncio.sleep_ms(20) # Plenty of time for mag to be ready
f.write(ujson.dumps([imu.accel.xyz, imu.gyro.xyz, imu.mag_nonblocking.xyz, time.ticks_us()]))
f.write('\n')
return imu.accel.xyz, imu.gyro.xyz, imu.mag_nonblocking.xyz
import sys gc.collect() print (gc.mem_free()) import network import utime from utime import sleep_ms,ticks_ms, ticks_us, ticks_diff from machine import Pin, SPI, PWM, ADC from math import sqrt import ssd1306 from random import getrandbits, seed # configure oled display SPI SSD1306 hspi = SPI(1, baudrate=8000000, polarity=0, phase=0) #DC, RES, CS display = ssd1306.SSD1306_SPI(128, 64, hspi, Pin(2), Pin(16), Pin(0)) seed(ticks_us()) #---buttons btnU = const (1 << 1) btnL = const (1 << 2) btnR = const (1 << 3) btnD = const (1 << 4) btnA = const (1 << 5) btnB = const (1 << 6) Btns = 0 lastBtns = 0 pinBtn = Pin(5, Pin.OUT) pinPaddle = Pin(4, Pin.OUT)
def main():
"""Initialize display."""
if sys.platform == 'esp8266':
print('1.4 inch TFT screen test on ESP8266')
SPI_CS = 16
SPI_DC = 15
spi = SPI(1)
elif sys.platform == 'esp32':
print('1.4 inch TFT screen test on ESP32')
sck = Pin(18)
miso = Pin(19)
mosi = Pin(23)
SPI_CS = 26
SPI_DC = 5
# Baud rate of 14500000 seems about the max
spi = SPI(2, baudrate=32000000, sck=sck, mosi=mosi, miso=miso)
display = Display(spi, SPI_CS, SPI_DC)
# spi = SPI(2, baudrate=14500000, sck=Pin(18), mosi=Pin(23))
# Draw background image
display.draw_image('images/Arkanoid_Border128x118.raw', 0, 10, 128, 118)
# Initialize ADC on VP pin 36
adc = ADC(Pin(36))
# Set attenuation 0-3.3V
adc.atten(ADC.ATTN_11DB)
# Seed random numbers
seed(ticks_us())
# Generate bricks
MAX_LEVEL = const(9)
level = 1
bricks = load_level(level, display)
# Initialize paddle
paddle = Paddle(display)
# Initialize score
score = Score(display)
# Initialize balls
balls = []
# Add first ball
balls.append(Ball(59, 111, -2, -1, display, frozen=True))
# Initialize lives
lives = []
for i in range(1, 3):
lives.append(Life(i, display))
# Initialize power-ups
powerups = []
try:
while True:
timer = ticks_us()
# Set paddle position to ADC spinner (scale 6 - 98)
paddle.h_position((4096 - adc.read()) // 44 + 5)
# Handle balls
score_points = 0
for ball in balls:
# Position
ball.set_position(paddle.x, paddle.y, paddle.x2, paddle.center)
# Check for collision with bricks if not frozen
if not ball.frozen:
prior_collision = False
ball_x = ball.x
ball_y = ball.y
ball_x2 = ball.x2
ball_y2 = ball.y2
ball_center_x = ball.x + ((ball.x2 + 1 - ball.x) // 2)
ball_center_y = ball.y + ((ball.y2 + 1 - ball.y) // 2)
# Check for hits
for brick in bricks:
if (ball_x2 >= brick.x and ball_x <= brick.x2
and ball_y2 >= brick.y and ball_y <= brick.y2):
# Hit
if not prior_collision:
ball.x_speed, ball.y_speed = brick.bounce(
ball.x, ball.y, ball.x2, ball.y2,
ball.x_speed, ball.y_speed, ball_center_x,
ball_center_y)
prior_collision = True
score_points += 1
brick.clear()
bricks.remove(brick)
# Generate random power-ups
if score_points > 0 and randint(1, 20) == 7:
powerups.append(Powerup(ball.x, 64, display))
# Check for missed
if ball.y2 > display.height - 3:
ball.clear_previous()
balls.remove(ball)
if not balls:
# Clear powerups
powerups.clear()
# Lose life if last ball on screen
if len(lives) == 0:
score.game_over()
else:
# Subtract Life
lives.pop().clear()
# Add ball
balls.append(
Ball(59, 112, 2, -3, display, frozen=True))
else:
# Draw ball
ball.draw()
# Update score if changed
if score_points:
score.increment(score_points)
# Handle power-ups
for powerup in powerups:
powerup.set_position(paddle.x, paddle.y, paddle.x2,
paddle.center)
powerup.draw()
if powerup.collected:
# Power-up collected
powerup.clear()
# Add ball
balls.append(
Ball(powerup.x, 112, 2, -1, display, frozen=False))
powerups.remove(powerup)
elif powerup.y2 > display.height - 3:
# Power-up missed
powerup.clear()
powerups.remove(powerup)
# Check for level completion
if not bricks:
for ball in balls:
ball.clear()
balls.clear()
for powerup in powerups:
powerup.clear()
powerups.clear()
level += 1
if level > MAX_LEVEL:
level = 1
bricks = load_level(level, display)
balls.append(Ball(59, 111, -2, -1, display, frozen=True))
# Attempt to set framerate to 30 FPS
timer_dif = 33333 - ticks_diff(ticks_us(), timer)
if timer_dif > 0:
sleep_us(timer_dif)
except KeyboardInterrupt:
display.cleanup()
def y_callback(self, line):
self.forward = self.pin_x.value() ^ self.pin_y.value() ^ self.reverse ^ 1
self._pos += 1 if self.forward else -1
self.tprev = self.tlast
self.tlast = utime.ticks_us()
async def show(self):
while True:
print('show: state={}'.format(self.state))
if self.state == self.ENTER_PIN1:
self.pin1[self.round] = await ux_enter_pin(
title='Security Code',
heading='{} Security Code'.format('Old' if self.round ==
0 else 'New'))
if self.pin1[self.round] != None and len(
self.pin1[self.round]) >= MIN_PIN_PART_LEN:
if self.round == 1:
self.goto(self.SHOW_ANTI_PHISHING_WORDS)
else:
self.goto(self.ENTER_PIN2)
elif self.state == self.SHOW_ANTI_PHISHING_WORDS:
start = utime.ticks_us()
words = pincodes.PinAttempt.anti_phishing_words(
self.pin1[self.round].encode())
end = utime.ticks_us()
result = await ux_show_word_list('Security Words',
words,
heading1='Remember these',
heading2='Security Words:',
left_btn='BACK',
right_btn='OK')
if result == 'x':
self.pin1[self.round] = None
self.goto(self.ENTER_PIN1)
else:
self.goto(self.ENTER_PIN2)
elif self.state == self.ENTER_PIN2:
self.pin2[self.round] = await ux_enter_pin(
title='Login PIN',
heading='{} Login PIN'.format('Old' if self.round ==
0 else 'New'))
if self.pin2[self.round] != None and len(
self.pin2[self.round]) >= MIN_PIN_PART_LEN:
if self.round == 0:
self.round = 1
self.goto(self.ENTER_PIN1)
else:
self.goto(self.CHANGE_PIN)
elif self.state == self.CHANGE_PIN:
try:
print('pin1={} pin2={}'.format(self.pin1, self.pin2))
args = {}
args['old_pin'] = (self.pin1[0] + self.pin2[0]).encode()
args['new_pin'] = (self.pin1[1] + self.pin2[1]).encode()
print('pa.change: args={}'.format(args))
pa.change(**args)
self.goto(self.CHANGE_SUCCESS)
except Exception as err:
print('err={}'.format(err))
self.goto(self.CHANGE_FAILED)
elif self.state == self.CHANGE_FAILED:
result = await ux_show_story(
'Unable to change PIN. The old PIN you entered was incorrect.',
title='PIN Error',
right_btn='RETRY')
if result == 'y':
self.pin1 = [None, None]
self.pin2 = [None, None]
self.round = 0
self.goto(self.ENTER_PIN1)
else:
return
elif self.state == self.CHANGE_SUCCESS:
dis.fullscreen('PIN changed')
utime.sleep(1)
return
else:
while True:
print('ERROR: Should never hit this else case!')
from uasyncio import sleep_ms
await sleep_ms(1000)
def timeout_ns(nanoseconds):
start = utime.ticks_us()
while True:
yield ((utime.ticks_us() - start) * 1000) >= nanoseconds
from machine import Pin
import utime
ir_pin = Pin(21, Pin.IN)
prev_value = 1
data = []
while True:
ir_value = ir_pin.value()
if ir_value == 0 and prev_value == 1:
zero_start = utime.ticks_us()
one_timed = utime.ticks_diff(utime.ticks_us(),one_start)
#print(data)
if one_timed < 50000:
data.append((1, one_timed))
if ir_value == 1 and prev_value == 0:
one_start = utime.ticks_us()
zero_timed = utime.ticks_diff(utime.ticks_us(),zero_start)
if zero_timed < 50000:
data.append((0, zero_timed))
if one_timed > 100000 and len(data)>5:
print(data, "\n", "Last one timed was", one_timed, "\n")
data = []
one_timed = utime.ticks_diff(utime.ticks_us(),one_start)
prev_value = ir_value
#sw = pyb.Switch()
# Choose test to run
Calibrate = True
Timing = True
def getmag(): # Return (x, y, z) tuple (blocking read)
return imu.mag.xyz
if Calibrate:
print("Calibrating. Press switch when done.")
fuse.calibrate(getmag, sw, lambda : pyb.delay(100))
print(fuse.magbias)
if Timing:
mag = imu.mag.xyz # Don't include blocking read in time
accel = imu.accel.xyz # or i2c
gyro = imu.gyro.xyz
start = time.ticks_us() # Measure computation time only
fuse.update(accel, gyro, mag) # 1.97mS on Pyboard
t = time.ticks_diff(time.ticks_us(), start)
print("Update time (uS):", t)
count = 0
while True:
fuse.update(imu.accel.xyz, imu.gyro.xyz, imu.mag.xyz) # Note blocking mag read
if count % 50 == 0:
print("Heading, Pitch, Roll: {:7.3f} {:7.3f} {:7.3f}".format(fuse.heading, fuse.pitch, fuse.roll))
time.sleep_ms(20)
count += 1
def _cb_left():
self.tleft[self.ileft & 15] = ticks_us()
self.ileft += 1
leds(2,5)
else:
leds(2,0)
init()
cur_num_tx = 0
ur=""
wait_start()
tp = 1 #test_period s
t_tick = int(tp * 1000000)
rt=0.5
send_tick = int(t_tick/rt)
t_l = ut.ticks_us()
cidx=0
lc = 1
while True:
rxc = 0
txc = 0
t_s = ut.ticks_us()
lu = len(uids)
#broadcast device exist every test period
txp(0,2,lu)#compass.heading()
mt()
show_id()
leds_br()
def y_callback(self, line):
self.forward = self.pin_x.value() ^ self.pin_y.value() ^ 1
self._pos += 1 if self.forward else -1
self.tprev = self.tlast
self.tlast = utime.ticks_us()
def read_IMU_data():
global ax, ay, az, angx, angy, angz, buff, index, good_data, new_chunk, serial
# timeout = 0.0001
# time_now = time.clock()
# while ((time.clock() - time_now) < timeout and not good_data):
timeout = ut.ticks_add(ut.ticks_us(), 800)
while (ut.ticks_diff(timeout, ut.ticks_us())) > 0 and (not good_data):
# while (not good_data):
if serial.any():
read_char = serial.read(1)
#print(read_char)
else:
return
if not new_chunk:
# We are waiting for header byte
if read_char == b'\x55':
new_chunk = True
buff[index] = ord(read_char)
# print(buff[index])
index += 1
continue
else:
buff[index] = ord(read_char)
# print(ord(read_char))
index += 1
if index >= 11:
# reset & set OK to process flag
index = 0
new_chunk = False
checksum = sum(buff[0:10])
if checksum.to_bytes(2, 'big')[1] == buff[10]:
# Good data
good_data = True
if good_data == True:
good_data = False
if buff[1] == b'\x50':
# Time, not implemented
pass
elif buff[1] == 81:
g = 9.81
conv = 16.0 / 32768.0
accel = struct.unpack("<hhh", buff[2:8])
ax, ay, az = [a * conv for a in accel]
# print('Acceleration', "ax: ", "{0:.2f}".format(ax), "ay: ", "{0:.2f}".format(ay), "az: ", "{0:.2f}".format(az))
# temp = struct.unpack("<h", buff[8:10])
# temp = temp[0] / 100.0
# print("Temp: ", temp)
elif buff[1] == 82:
conv = 2000.0 / 32768.0
angles = struct.unpack("<hhh", buff[2:8])
angvx, angvy, angvz = [a * conv for a in angles]
# print("Ang V", "angVx: ", "{0:.2f}".format(angvx), "angVy: ", "{0:.2f}".format(angvy), "angVz: ", "{0:.2f}".format(angvz))
elif buff[1] == 83:
conv = 180.0 / 32768.0
angles = struct.unpack("<hhh", buff[2:8])
angx, angy, angz = [a * conv for a in angles]
# print("Angles", "angx: ", "{0:.2f}".format(angx), "angy: ", "{0:.2f}".format(angy), "angz: ", "{0:.2f}".format(angz))
elif buff[1] == 84:
conv = 1
mag = struct.unpack("<hhh", buff[2:8])
magx, magy, magz = [a * conv for a in mag]
# print("Magnetic", "magx: ", "{0:.2f}".format(magx), "magy: ", "{0:.2f}".format(magy), "magz: ", "{0:.2f}".format(magz))
return True
else:
return False
def bi_transfer(self):
cur_num_tx = 0
self.wait_start()
test_cnt = 0
while True:
self.rx_cnt = 0
self.rx_new_cnt = 0
self.tx_cnt = 0
self.tx_new_cnt = 0
self.ack_cnt = 0
test_period = 1 #s
test_tick = int(test_period * 1000000)
test_cnt += 1
time_s = utime.ticks_us()
time_l = time_s
#broadcast device exist every test period
self.tx(0, str(0))
# rate target hz
rate_target = random.randint(1, 100)
send_tick = int(test_tick / rate_target)
while True: # start current measurement
time_now = utime.ticks_us()
time_use = utime.ticks_diff(time_now, time_s)
if test_tick - time_use < 0: # 10s
self.used_ids = self.used_ids_next
self.show_id()
self.used_ids_next = []
break
time_last = utime.ticks_diff(time_now, time_l)
if send_tick - time_last < 0: # should send
time_l = time_now
if self.ack_received:
cur_num_tx = cur_num_tx + 1
self.ack_received = False
if len(self.used_ids) > 0:
index = random.randint(0, len(self.used_ids) - 1)
did = self.used_ids[index]
self.tx(did, cur_num_tx)
self.tx_new_cnt += 1
incoming = radio.receive()
if incoming:
self.rx_cnt += 1
items = incoming.split(":")
if len(items) == 3:
sid, did, value = items
sid = int(sid)
did = int(did)
if not sid in self.used_ids:
self.used_ids.append(sid)
self.show_id()
if not sid in self.used_ids_next:
self.used_ids_next.append(sid)
if sid == self.sid: # sid collision
self.sid = self.get_new_id(self.used_ids)
self.show_id()
if did == self.sid:
if value == self.ack:
self.ack_received = True
self.ack_cnt += 1
else:
self.rx_new_cnt += 1
self.tx(sid, self.ack)
#radio.send ("%i:%i:%s"%(self.sid,sid,self.ack))
self.pixel_debug(0, self.rx_cnt)
if button_b.was_pressed(): # test sid collision
if len(self.used_ids) > 0:
self.sid = self.used_ids[0]
else:
self.sid = random.randint(1, 20)
break
tx_rate = float(self.tx_new_cnt) / test_period
rx_rate = float(self.rx_new_cnt) / test_period
str_output = "(%.1f,%.1f,%i)" % (tx_rate, rx_rate,
self.tx_new_cnt - self.ack_cnt)
print(str_output)
def new_func(*args, **kwargs):
t = utime.ticks_us()
result = f(*args, **kwargs)
delta = utime.ticks_diff(utime.ticks_us(), t)
print('Function {} Time = {:6.3f}ms'.format(myname, delta / 1000))
return result
def after(trigtime): # If current time is after the specified value return
res = ((ticks_us() - trigtime) & TIMERPERIOD) # the no. of uS after. Otherwise return zero
if res >= MAXTIME:
res = 0
return res
def pulse(delay: int) -> float:
# normalize sin from interval -1:1 to 0:1
return 0.5 + 0.5 * math.sin(utime.ticks_us() / delay)
def toggle(_):
global t
pinout.value(not pinout.value())
t = utime.ticks_us()
def _idle_thread(self): # Runs once then in roundrobin or when there's nothing else to do
if self.gc_enable and (self.last_gc == 0 or after(self.last_gc) > GCTIME):
gc.collect()
self.last_gc = ticks_us()
def handle(self, task: Task) -> None:
deadline = utime.ticks_add(utime.ticks_us(), self.delay_us)
schedule(task, deadline, deadline)
print('Battery Voltage=' + '{:.2f}'.format(voltage) + 'V')
# Ping a node
tof = nm3.send_ping(170)
distance = tof*SOUND_SPEED
print('Time of Flight to ' '{:03d}'.format(addr) + ' = ' + '{:.4f}'.format(tof) + 's' + ' distance = ' + '{:.4f}'.format(distance) + 'm')
# Need a pause between transmissions for the modem to finish the last one
utime.sleep(1.0)
# Configure I/O pin "Y3" as an external interrupt connected to RxS pin of Nanomodem
# Rising Edge on RxS pin indicate start of incoming packet on Nanomodem.
extint = pyb.ExtInt('Y3', pyb.ExtInt.IRQ_RISING, pyb.Pin.PULL_DOWN, rxs_callback)
# Global Variable
previous_arrival_tick = utime.ticks_us()
# Receiving unicast and broadcast messages
while True:
# print("Arrival Flag: ", arrival_bflag)
# Poll the serial port for bytes if interrupt happen
if arrival_bflag:
# Set flag to False for next interrupt to set it True
arrival_bflag = False
# Poll UART for data
nm3.poll_receiver()
# Periodically process any bytes received
nm3.process_incoming_buffer()
def GUIInputbox(obj):
if obj.Status == 0:
x = obj.X
y = obj.Y
width = obj.Width
color = 0xcccccc
elif obj.Status == 1:
x = obj.X
y = obj.Y
width = obj.Width
color = 0x33ccff
else:
lcd.fill(0x000000)
x = 10
y = 35
width = 300
color = 0x33ccff
lcd.font(lcd.FONT_Ubuntu)
lcd.print(obj.Label, x, y, color)
lcd.font(lcd.FONT_Default)
lcd.line(x, y + 40, x + width, y + 40, color)
cw = 10
ch = 16
s = obj.TextValue
mx = int(width / cw)
st = s[-mx:]
stl = len(st)
xp = len(s) - stl
for i in range(stl):
lcd.print(st[i], x + i * cw, y + 20, 0xffffff)
if obj.Status == 2:
kc = 0
caps = 0
cs = 0
cp = len(s[xp:]) if len(s[xp:]) < mx else mx
while True:
k, kc, caps = GUIKeyboard(kc, caps)
if k != '':
if len(k) == 1:
lcd.line(x + cp * cw, y + 20 - 4, x + cp * cw, y + 20 + ch,
0x000000)
s = s[0:xp + cp] + str(k) + s[xp + cp:]
k = 'right'
if k == 'backspace':
if cp > 0:
s = s[0:xp + cp - 1] + s[xp + cp:]
k = 'left'
if k == 'esc':
lcd.clear()
obj.Status = 1
break
if k == 'enter':
lcd.clear()
obj.Status = 1
obj.TextValue = s
if obj.Function != None:
obj.Function(obj)
break
if k == 'left':
lcd.line(x + cp * cw, y + 20 - 4, x + cp * cw, y + 20 + ch,
0x000000)
if cp - 1 > 0:
cp = cp - 1
else:
xp = xp - 1 if xp - 1 >= 0 else xp
if k == 'right':
lcd.line(x + cp * cw, y + 20 - 4, x + cp * cw, y + 20 + ch,
0x000000)
if cp + 1 <= len(s[xp:xp + mx]):
cp = cp + 1
else:
xp = xp + 1 if xp + 1 + cp <= len(s) else xp
for i in range(mx):
lcd.print('W', x + i * cw, y + 20, 0x000000)
st = s[xp:xp + mx]
stl = len(st)
for i in range(stl):
lcd.print(st[i], x + i * cw, y + 20, 0xffffff)
else:
if time.ticks_us() - obj.Time >= 500000:
obj.Time = time.ticks_us()
if cs == 0:
lcd.line(x + cp * cw, y + 20 - 4, x + cp * cw,
y + 20 + ch, 0xffffff)
cs = 1
else:
lcd.line(x + cp * cw, y + 20 - 4, x + cp * cw,
y + 20 + ch, 0x000000)
cs = 0
return obj
def rxs_callback(line):
global current_arrival_tick, arrival_bflag
current_arrival_tick = utime.ticks_us()
arrival_bflag = True
tft.draw_hline(x, y, 50, GREEN)
tft.draw_vline(x, y, 50, GREEN)
tft.draw_hline(x, y + 50, 50, GREEN)
tft.draw_vline(x + 50, y, 50, GREEN)
tft.draw_line(x, y, x + 50, y + 50, GREEN)
tft.draw_line(x, y + 50, x + 50, y, GREEN)
# Render a glyph and measure performance.
xstart = 100
y = 80
tft.draw_str('Measure render speed of Python font:', xstart, y, GREEN, BLACK)
y += 20
mv, rows, cols = font10.get_ch('A')
nchars = 30
x = xstart
t = ticks_us()
for _ in range(nchars):
tft.draw_glyph(mv, x, y, rows, cols, GREEN, BLACK)
x += cols
y += rows
x = xstart
dt = ticks_diff(ticks_us(), t) / (nchars * 1000)
tft.draw_str('Time per char: {:4.1f}ms'.format(dt), xstart, y, GREEN, BLACK)
# Verify glyph doesn't exceed bounding box
x, y = 400, 10
tft.fill_rectangle(x, y, x + 40, y + 40, GREEN)
x = 388
tft.draw_glyph(mv, x, y, rows, cols, BLACK, YELLOW)
# Test pixel draw
from machine import UART import machine import os from network import WLAN from network import Bluetooth from network import LTE from pytrack import Pytrack import network import utime import pycom start = utime.ticks_us() uart = UART(0, baudrate=115200) os.dupterm(uart) # switch stuff off ... # WLAN off wlan = WLAN() #wlan.init(mode=WLAN.STA) wlan.deinit() # Bluetooth off #bt = Bluetooth() #bt.deinit() # LTE off #lte = LTE() #lte.disconnect() #lte.deinit() # switch off FTP and telnet servers server = network.Server() server.deinit() # done switching stuff off
import utime
try:
utime.sleep_ms
except AttributeError:
print("SKIP")
raise SystemExit
utime.sleep_ms(1)
utime.sleep_us(1)
print(utime.ticks_diff(utime.ticks_ms(), utime.ticks_ms()) <= 1)
print(utime.ticks_diff(utime.ticks_us(), utime.ticks_us()) <= 500)
def new_func(*args, **kwargs):
t = utime.ticks_us()
result = f(*args, **kwargs)
delta = utime.ticks_diff(utime.ticks_us(), t) # Argument order new, old
print('Function {} Time = {:6.3f}ms'.format(myname, delta/1000))
return result
