class UltraSonicMeter(object):
def __init__(self):
self.tmp = self.time = 0
self.cnt = 0
self.fr = 0
self.trig = Pin('X12', Pin.OUT_PP, Pin.PULL_NONE)
echoR = Pin('X1', Pin.IN, Pin.PULL_NONE)
echoF = Pin('X2', Pin.IN, Pin.PULL_NONE)
self.micros = pyb.Timer(5, prescaler=83, period=0x3fffffff)
self.timer = Timer(2, freq=1000)
self.timer.period(3600)
self.timer.prescaler(1375)
self.timer.callback(lambda e: self.run_trig())
extR = ExtInt(echoR, ExtInt.IRQ_RISING, Pin.PULL_NONE, self.start_count)
extF = ExtInt(echoF, ExtInt.IRQ_FALLING, Pin.PULL_NONE, self.read_dist)
def run_trig(self):
self.trig.high()
pyb.udelay(1)
self.trig.low()
def start_count(self, line):
self.micros.counter(0)
self.time = self.micros.counter()
self.timer.counter(0)
def read_dist(self, line):
end = self.micros.counter()
micros = end-self.time
distP1 = micros//5
distP2 = micros//6
distP3 = (distP1-distP2)//10*2
dist = distP2+distP3
if dist != 0:
self.cnt += 1
self.fr += dist
if self.cnt == 15:
tmp = self.tmp
dist = self.fr//self.cnt
if tmp != dist:
print(dist, 'mm')
self.tmp = dist
self.cnt = 0
self.fr = 0
# check basic functionality of the timer class
import pyb
from pyb import Timer
tim = Timer(4)
tim = Timer(4, prescaler=100, period=200)
print(tim.prescaler())
print(tim.period())
tim.prescaler(300)
print(tim.prescaler())
tim.period(400)
print(tim.period())
# Setting and printing frequency
tim = Timer(2, freq=100)
print(tim.freq())
tim.freq(0.001)
print("{:.3f}".format(tim.freq()))
max_ticks = value
avg_ticks = value
std_dev_ticks = 0
else:
min_ticks = min(min_ticks, value)
max_ticks = max(max_ticks, value)
avg_ticks_new = avg_ticks + ((value - avg_ticks) / (n + 1))
std_dev_ticks = (((n - 1) * std_dev_ticks) +
((value - avg_ticks_new) *
(value - avg_ticks))) / n
avg_ticks = avg_ticks_new
n += 1
else:
logger.debug("Timeout, not counting")
tout = False
logger.info("Calculating statistical values.")
std_dev_ticks = math.sqrt(std_dev_ticks)
min_real = real(min_ticks, timer.prescaler(), pyb.freq()[2] * 2) # commands/s
max_real = real(max_ticks, timer.prescaler(), pyb.freq()[2] * 2) # commands/s
avg_real = real(avg_ticks, timer.prescaler(), pyb.freq()[2] * 2) # commands/s
std_dev_real = real(std_dev_ticks, timer.prescaler(),
pyb.freq()[2] * 2) # commands/s
logger.info(
"Minimum: {} commands/tick, Maximum: {} commands/tick, Mean: {} commands/tick, Standard deviation: {} commands/tick"
.format(min_ticks, max_ticks, avg_ticks, std_dev_ticks))
logger.info(
"Minimum: {} commands/s, Maximum: {} commands/s, Mean: {} commands/s, Standard deviation: {} commands/s"
.format(min_real, max_real, avg_real, std_dev_real))
def __init__(self, tim_num, channel, frequency, pin):
self.tim = Timer(tim_num, freq=frequency)
self.pin = Pin(pin)
self.channel = channel
self.scale = Timer.source_freq(self.tim)/(Timer.prescaler(self.tim)+1)
if (n == 0):
min_ticks = value
max_ticks = value
avg_ticks = value
std_dev_ticks = 0
else:
min_ticks = min(min_ticks, value)
max_ticks = max(max_ticks, value)
avg_ticks_new = avg_ticks + ((value - avg_ticks) / (n + 1))
std_dev_ticks = (((n - 1) * std_dev_ticks) +
((value - avg_ticks_new) *
(value - avg_ticks))) / n
avg_ticks = avg_ticks_new
n += 1
tout = False
logger.info("Calculating statistical values.")
std_dev_ticks = math.sqrt(std_dev_ticks)
min_real = real(min_ticks, timer.prescaler(), pyb.freq()[2] * 2) * 1000 # ms
max_real = real(max_ticks, timer.prescaler(), pyb.freq()[2] * 2) * 1000 # ms
avg_real = real(avg_ticks, timer.prescaler(), pyb.freq()[2] * 2) * 1000 # ms
std_dev_real = real(std_dev_ticks, timer.prescaler(),
pyb.freq()[2] * 2) * 1000 # ms
logger.info(
"Minimum: {} ticks, Maximum: {} ticks, Mean: {} ticks, Standard deviation: {} ticks"
.format(min_ticks, max_ticks, avg_ticks, std_dev_ticks))
logger.info(
"Minimum: {} ms, Maximum: {} ms, Mean: {} ms, Standard deviation: {} ms".
format(min_real, max_real, avg_real, std_dev_real))
# check basic functionality of the timer class import pyb from pyb import Timer tim = Timer(4) tim = Timer(4, prescaler=100, period=200) print(tim.prescaler()) print(tim.period()) tim.prescaler(300) print(tim.prescaler()) tim.period(400) print(tim.period())
from pyb import UART
sensor.reset() # Reset and initialize the sensor.
sensor.set_pixformat(
sensor.GRAYSCALE) # Set pixel format to RGB565 (or GRAYSCALE)
sensor.set_framesize(sensor.QQVGA) # Set frame size to QQVGA (160x120)
sensor.skip_frames(time=2000) # Wait for settings take effect.
sensor.set_auto_gain(False) # must be turned off for color tracking
sensor.set_auto_whitebal(False) # must be turned off for color tracking
clock = time.clock() # Create a clock object to track the FPS.
uart = UART(1, 115200, timeout_char=1000)
tim1 = Timer(4, freq=300) # Servo Frequency in Hz
tim2 = Timer(2, freq=300) # Motor Frequency in Hz
initialPulseWidth = (15 / 10000) * (tim1.source_freq() /
(tim1.prescaler() + 1)) #servo
initialPulseWidth2 = (0 / 10000) * (tim2.source_freq() /
(tim2.prescaler() + 1)) #motor
ch1 = tim1.channel(1,
Timer.PWM,
pin=Pin("P7"),
pulse_width=int(initialPulseWidth)) #servo
ch2 = tim2.channel(4,
Timer.PWM,
pin=Pin("P5"),
pulse_width=int(initialPulseWidth2)) #motor
inA = Pin('P1', Pin.OUT_PP, Pin.PULL_NONE) #set inA to output
inB = Pin('P2', Pin.OUT_PP, Pin.PULL_NONE) #set inB to output
enA = Pin('P3', Pin.OUT_PP, Pin.PULL_NONE) #set enA to output
enB = Pin('P4', Pin.OUT_PP, Pin.PULL_NONE) #set enB to output
#Setup UART
uart = UART(3, 115200, timeout_char=1000)
#Send Ok command to Bluetooth
uart.write('AT\r\n')
print(uart.readline())
#Initialize PWM & Motor Duty Cycle
pwm = 1400
motor = 0
mil = 1000000
# Timer Setup for Servo
tim = Timer(2, freq=300) # Frequency in Hz
t1prescaler = tim.source_freq() / (tim.prescaler() + 1)
div = int(t1prescaler * (pwm / mil))
ch1 = tim.channel(1, Timer.PWM, pin=Pin("P6"), pulse_width=div)
# Timer Setup for Motor
tim2 = Timer(4, freq=1000) # Frequency in Hz
t2prescaler = tim2.source_freq() / (tim2.prescaler() + 1)
div2 = int(t2prescaler * (motor / mil))
ch2 = tim2.channel(1, Timer.PWM, pin=Pin("P7"), pulse_width=div2)
Forward = False
Reverse = False
BrakeVCC = False
BrakeGND = False
class tv:
def __init__(self,hres=64,progressive=False,lines=None,linetime=64,buf=None):
if lines == None:
lines = 262 if progressive else 525
self.lines = lines
if buf == None:
if progressive:
self.buf = bytearray(262*hres)
else:
self.buf = bytearray(525*hres)
else:
self.buf = buf
self.hres = hres
self.line_time = linetime
self.progressive = progressive
self.sync_level = 0
self.blanking_level = 56
self.black_level = 58
self.white_level = 73
self.phase = 0
self.buffer_dac = True
self.reinit()
def redac(self):
self.dac = DAC(Pin('X5'),buffering=self.buffer_dac)
self.bmv = memoryview(self.buf)[:len(self)]
self.dac_tim = Timer(6, freq=int(self.hres*1000000/self.line_time))
self.dac.write_timed(self.bmv,self.dac_tim,mode=DAC.CIRCULAR)
self.frame_tim = Timer(5, prescaler=self.dac_tim.prescaler(),period=self.dac_tim.period()*len(self))
self.frame_tim.counter(self.phase)
def reinit(self):
self.calc_porch_magic_numbers()
self.init()
def set_progressive(self,prog=True):
self.progressive = prog
self.calc_porch_magic_numbers()
self.init()
def __len__(self):
return self.hres*self.lines
def calc_porch_magic_numbers(self):
br = self.hres/self.line_time
w = round(4.7*br)
t = int(10.9*br+0.9)#round mostly up
s = round(1.5*br)
self.h_blank = [s,s+w,t]
self.v_blank_e = [6,12,18]
self.v_blank_o = [6,12,19]
hsl = round(18*br)
hsh = round(58*br)
self.h_safe = [hsl-t,hsh-t]
self.v_safe = [32*(2-self.progressive),208*(2-self.progressive)]
def init(self):
self.carrier = Pin('X1')
self.tim = Timer(2, prescaler=1,period=1)
self.ch = self.tim.channel(1, Timer.PWM, pin=self.carrier)
self.ch.pulse_width(1)
self.redac()
self.be = self.bmv
if not self.progressive:
self.bo = self.be[len(self)//2:]
self.fb = framebuf.FrameBuffer(self.buf,self.hres,self.lines,framebuf.GS8)
self.fbe_mv = self.be[self.hres*21+self.h_blank[2]:]
if not self.progressive:
self.fbo_mv = self.bo[self.hres*43//2+self.h_blank[2]:]
h = self.y_dim()//(2-self.progressive)
self.fbe = framebuf.FrameBuffer(self.fbe_mv,self.hres-self.h_blank[2],h,framebuf.GS8,self.hres)
if not self.progressive:
self.fbo = framebuf.FrameBuffer(self.fbo_mv,self.hres-self.h_blank[2],h,framebuf.GS8,self.hres)
self.clear()
def set_pixel(self,x,y,v):
if self.progressive:
self.fbe.pixel(x,y,int(v*(self.white_level-self.black_level)+self.black_level))
else:
[self.fbe,self.fbo][y&1].pixel(x,y//2,int(v*(self.white_level-self.black_level)+self.black_level))
def get_pixel(self,x,y):
if self.progressive:
return (self.fbe_mv[x+y*self.hres]-self.black_level)/(self.white_level-self.black_level)
else:
return ([self.fbe_mv,self.fbo_mv][y&1][x+(y//2)*self.hres]-self.black_level)/(self.white_level-self.black_level)
def set_carrier(self,pre=1,per=1,w=1):
self.tim.init(prescaler=pre,period=per)
self.ch.pulse_width(w)
def clear(self):
self.fb.fill(self.black_level)
self.syncs()
def syncs(self):
self.fb.fill_rect(0,0,self.h_blank[2],self.lines,self.blanking_level)
self.fb.fill_rect(self.h_blank[0],0,self.h_blank[1]-self.h_blank[0],self.lines,self.sync_level)
for y in range(self.v_blank_e[2]):
inv = self.v_blank_e[0] <= y < self.v_blank_e[1]
for x in range(self.hres//2):
val = self.blanking_level
if (self.h_blank[0] <= x < self.h_blank[1]) ^ inv:
val = self.sync_level
self.buf[y*self.hres//2+x] = val
if not self.progressive:
for y in range(self.v_blank_o[2]):
inv = self.v_blank_o[0] <= y < self.v_blank_o[1]
for x in range(self.hres//2):
val = self.blanking_level
if (self.h_blank[0] <= x < self.h_blank[1]) ^ inv:
val = self.sync_level
self.bo[y*self.hres//2+x] = val
def x_dim(self):
return self.hres-self.h_blank[2]
def y_dim(self):
return self.lines-(21 if self.progressive else 43)
def mandelbrot(self,imax=8,p=0,s=2,julia=False,il=0,x0=None,y0=None,x1=None,y1=None,asm=True,julia_seed=0):
x0 = self.h_safe[0] if x0 == None else x0
x1 = self.h_safe[1] if x1 == None else x1
y0 = self.v_safe[0] if y0 == None else y0
y1 = self.v_safe[1] if y1 == None else y1
for x in range(x0,x1):
for y in range(y0,y1):
c = (((x-x0)/(x1-x0-1)-.5)*2 + ((y-y0)/(y1-y0-1)-.5)*2j)*s+p
z = c
if julia:
c = julia_seed
if asm:
i = a_mandelbrot(z,c,imax)
else:
for i in range(imax):
if z.real*z.real+z.imag*z.imag > 4:
break
z = z*z+c
else:
self.set_pixel(x,y,il)
continue
if i == -1:
self.set_pixel(x,y,il)
else:
self.set_pixel(x,y,i/imax)
def demo(self,x0=None,y0=None,x1=None,y1=None):
x0 = self.h_safe[0] if x0 == None else x0
x1 = self.h_safe[1] if x1 == None else x1
w = x1-x0
y0 = self.v_safe[0] if y0 == None else y0
y1 = self.v_safe[1] if y1 == None else y1
h = y1-y0
mx = x0
my = y0
import pyb
import time
acc = pyb.Accel()
btn = pyb.Switch()
p = self.get_pixel(int(mx),int(my))
pos = 0
zoom = 2
it = 16
julia = False
jp = 0
self.mandelbrot(it,pos,zoom,julia,0,x0,y0,x1,y1,julia_seed=jp)
def paddles(c):
x = int(mx-.125*w)
xw = w//4
y = int(my-.125*h)
yw = h//4
y_0 = y0
y_1 = y1
if not self.progressive:
y //= 2
yw //= 2
y_0 //= 2
y_1 //= 2
self.fbe.hline(x,y_0,xw,c)
self.fbe.vline(x0,y,yw,c)
self.fbe.hline(x,y_1,xw,c)
self.fbe.vline(x1,y,yw,c)
if not self.progressive:
self.fbo.hline(x,y_0,xw,c)
self.fbo.vline(x0,y,yw,c)
self.fbo.hline(x,y_1,xw,c)
self.fbo.vline(x1,y,yw,c)
while 1:
paddles(self.black_level)
mx = min(x1-2,max(x0,mx*.98+(-acc.x()/24+.5)*w*.02))
my = min(y1-2,max(y0,my*.98+(acc.y()/24+.5)*h*.02))
paddles(self.white_level)
p = self.get_pixel(int(mx),int(my))
self.set_pixel(int(mx),int(my),(p+.5)%1)
pyb.delay(10)
self.set_pixel(int(mx),int(my),p)
if btn():
st = time.ticks_ms()
nit = it*2
while btn():
if time.ticks_diff(time.ticks_ms(),st) > 1000:
if acc.z()>0:
nit = it*2
else:
nit = "Julia"
self.fbe.fill_rect(x0,y0,w,10,self.black_level)
if not self.progressive:
self.fbo.fill_rect(x0,y0,w,10,self.black_level)
self.fbe.text(str(nit),x0+1,y0+1,self.white_level)
if not self.progressive:
self.fbo.text(str(nit),x0+1,y0+1,self.white_level)
cp = (((mx-x0)/w-.5)*2+2j*((my-y0)/h-.5))*zoom
if time.ticks_diff(time.ticks_ms(),st) > 1000:
if nit == "Julia":
julia ^= 1
jp = pos + cp
pos = 0
zoom = 2
it = 16
else:
it = nit
else:
pos += cp
zoom *= .25
self.mandelbrot(it,pos,zoom,julia,0,x0,y0,x1,y1,julia_seed=jp)
