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)