def __init__(self): self._tmr2 = Timer(2, freq=20000, mode=Timer.CENTER) #used for PWM for motor control self._ch1 = self._tmr2.channel(1, Timer.PWM, pin=Pin.board.X1, pulse_width=(self._tmr2.period() + 1) // 2) self._ch4 = self._tmr2.channel(4, Timer.PWM, pin=Pin.board.X4, pulse_width=(self._tmr2.period() + 1) // 2) self._us_tmr = Timer( 3, prescaler=83, period=0x3fffffff) #used to measure US sensor pulse duration self._pin_in1 = Pin(Pin.board.X3, Pin.OUT_PP) #motor control pins self._pin_in2 = Pin(Pin.board.X2, Pin.OUT_PP) self._pin_in3 = Pin(Pin.board.X5, Pin.OUT_PP) self._pin_in4 = Pin(Pin.board.X6, Pin.OUT_PP) self._pin_int7 = Pin(Pin.board.X7, Pin.IN) #encoder interrupt pins self._pin_int8 = Pin(Pin.board.X8, Pin.IN) self._pin_trigger = Pin(Pin.board.X11, Pin.OUT_PP) #US trig pin self._pin_echo = Pin(Pin.board.X12, Pin.IN) #US echo pin self._pin_beep = Pin(Pin.board.X19, Pin.OUT_PP) #beeper ctrl pin self._beeper = Beeper(self._pin_beep) self._left_motor = Motor(self._pin_in1, self._pin_in2, self._ch1) self._left_encoder = Encoder(self, self._pin_int7) self._right_motor = Motor(self._pin_in4, self._pin_in3, self._ch4) self._right_encoder = Encoder(self, self._pin_int8) self._us = UltraSonicSensor(self._pin_trigger, self._pin_echo, self._us_tmr)
def main(): # Configure timer2 as a microsecond counter. tim = Timer(config["timer"], prescaler=(machine.freq()[0] // 1000000) - 1, period=config["timer-period"]) tim2 = Timer(config["led-timer"], freq=config["led-freq"]) tim2.callback(lambda t: pyb.LED(config["led-id"]).toggle()) # Configure channel for timer IC. ch = tim.channel(1, Timer.IC, pin=config["pin-capture"], polarity=Timer.FALLING) # Slave mode disabled in order to configure mem32[config["timer-addr"] + TIM_SMCR] = 0 # Reset on rising edge (or falling in case of inverted detection). Ref: 25.4.3 of STM32F76xxx_reference_manual.pdf mem32[config["timer-addr"] + TIM_SMCR] = (mem32[config["timer-addr"] + TIM_SMCR] & 0xfffe0000) | 0x54 # Capture sensitive to rising edge. Ref: 25.4.9 of STM32F76xxx_reference_manual.pdf mem32[config["timer-addr"] + TIM_CCER] = 0b1011 print("capturing") capture(ch)
def __init__(self, pin, cfreq, asize, duty, verbose): if ESP32: self._rmt = RMT(0, pin=pin, clock_div=80, carrier_freq=cfreq, carrier_duty_percent=duty) # 1μs resolution elif RP2: # PIO-based RMT-like device self._rmt = RP2_RMT(pin_pulse=None, carrier=(pin, cfreq, duty)) # 1μs resolution else: # Pyboard if not IR._active_high: duty = 100 - duty tim = Timer(2, freq=cfreq) # Timer 2/pin produces 36/38/40KHz carrier self._ch = tim.channel(1, Timer.PWM, pin=pin) self._ch.pulse_width_percent(self._space) # Turn off IR LED # Pyboard: 0 <= pulse_width_percent <= 100 self._duty = duty self._tim = Timer(5) # Timer 5 controls carrier on/off times self._tcb = self._cb # Pre-allocate self._arr = array('H', 0 for _ in range(asize)) # on/off times (μs) self._mva = memoryview(self._arr) # Subclass interface self.verbose = verbose self.carrier = False # Notional carrier state while encoding biphase self.aptr = 0 # Index into array
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 __init__(self, X=True) : if X : self.pwmpin = Pin('X6', Pin.OUT_PP) self.pwmtim = Timer(2, freq=5000) self.pwm = self.pwmtim.channel(1, mode=Timer.PWM, pin=self.pwmpin) self.pwm.pulse_width(0) self.dir = Pin('X2', Pin.OUT_PP) self.dir.off() # O = forward, 1 = reverse self.sleep = Pin('X3', Pin.OUT_PP) self.sleep.value(0) # 0 = sleep, 1 = active self.enca = Pin('X4', Pin.IN, Pin.PULL_UP) self.encb = Pin('X5', Pin.IN, Pin.PULL_UP) else : self.pwmpin = Pin('Y1', Pin.OUT_PP) self.pwmtim = Timer(8, freq=5000) self.pwm = self.pwmtim.channel(1, mode=Timer.PWM, pin=self.pwmpin) self.pwm.pulse_width(0) self.dir = Pin('Y2', Pin.OUT_PP) self.dir.off() # O = forward, 1 = reverse self.sleep = Pin('Y3', Pin.OUT_PP) self.sleep.value(0) # 0 = sleep, 1 = active self.enca = Pin('Y4', Pin.IN, Pin.PULL_UP) self.encb = Pin('Y5', Pin.IN, Pin.PULL_UP) self.pwmscale = (self.pwmtim.period() + 1) // 10000 # scale factot for permyriad(10000 as it allows to get more distinct points and avoid divisions) power self.count_a = 0 # counter for impulses on the A output of the encoder self.target_a = 0 # target value for the A counter (for controlled rotation) self.count_b = 0 # counter for impulses on the B output of the encoder self.time_a = 0 # last time we got an impulse on the A output of the encoder self.time_b = 0 # last time we got an impulse on the B output of the encoder self.elapsed_a_b = 0 # time elapsed between an impulse on A and an impulse on B self.dirsensed = 0 # direction sensed through the phase of the A and B outputs self.rpm = 0 # current speed in rotations per second self.rpm_last_a = 0 # value of the A counter when we last computed the rpms self.cruise_rpm = 0 # target value for the rpms self.walking = False # Boolean that indicates if the robot is walking or stationary self.desiredDir = True# Boolean that indecates the desired direction of the motor for move function self._control = PID() # PID control for the rotation of the wheels self._control.setTunings(KP, KI, KD); self._control.setSampleTime(1); self._control.setOutputLimits(-10000, 10000) self._control_distance = PID() # PID control for the cascade of the distance self._control_distance.setTunings(KP_DISTANCE, KI_DISTANCE, KD_DISTANCE); self._control_distance.setSampleTime(1); self._control_distance.setOutputLimits(-MAXIMUM_VELOCITY, MAXIMUM_VELOCITY) ExtInt(self.enca, ExtInt.IRQ_RISING, Pin.PULL_UP, self.enca_handler) ExtInt(self.encb, ExtInt.IRQ_RISING, Pin.PULL_UP, self.encb_handler) if RomiMotor.rpmtimer is None : # create only one shared timer for all instances RomiMotor.rpmtimer = Timer(4) RomiMotor.rpmtimer.init(freq=100, callback=RomiMotor.class_rpm_handler) RomiMotor.rpm_handlers.append(self.rpm_handler) # register the handler for this instance
def main(): pwm_timer = Timer(MOTOR_TIMER, freq=PWM_FREQ) ch1 = motorController(PIN_CH1, pwm_timer, 1) ch2 = motorController(PIN_CH2, pwm_timer, 2) adc = ADC(PIN_ADC) main_loop = loop(adc, ch1, ch2) event_timer = Timer(EVENT_TIMER, freq=1000) event_timer.freq(10) event_timer.callback(lambda t: next(main_loop))
def move_motor1(right, left): #W16 has Timer2, Channel1 Apwm = Pin('W16') timerA = Timer(2, freq=1000) chA = timerA.channel(1, Timer.PWM, pin=Apwm) Ain1 = Pin('W22', Pin.OUT_PP) Ain2 = Pin('W24', Pin.OUT_PP) standBy = Pin('W29', Pin.OUT_PP) #W29 has Timer1, Channel3 Bpwm = Pin('Y12') timerB = Timer(1, freq=1000) chB = timerB.channel(3, Timer.PWM, pin=Bpwm) Bin1 = Pin('W30', Pin.OUT_PP) Bin2 = Pin('W32', Pin.OUT_PP) def clockwise(motor, speed): if motor == 'a': Ain1.high() Ain2.low() chA.pulse_width_percent(speed) elif motor == 'b': Bin1.high() Bin2.low() chB.pulse_width_percent(100 - speed) def stop(motor): if motor == 'a': Ain1.low() Ain2.low() chA.pulse_width_percent(0) elif motor == 'b': Bin1.low() Bin2.low() chB.pulse_width_percent(0) def main(): standBy.high() while (True): stop('a') stop('b') clockwise('a', 50) clockwise('b', 50) utime.sleep_ms(2500) break utime.sleep(1) main()
def __init__(self): #设定Pin self._rForward = Pin('B8') self._rBackward = Pin('B9') self._lForward = Pin('B14') self._lBackward = Pin('B15') #set right motor pwm self._rTim = Timer(4, freq=3000) self._rf_ch = self._rTim.channel(3, Timer.PWM, pin=self._rForward) self._rb_ch = self._rTim.channel(4, Timer.PWM, pin=self._rBackward) #set left motor pwm self._lTim = Timer(12, freq=3000) self._lf_ch = self._lTim.channel(1, Timer.PWM, pin=self._lForward) self._lb_ch = self._lTim.channel(2, Timer.PWM, pin=self._lBackward)
def __init__(self, dc1, dc2): self.m1 = Timer(12, freq=100000).channel(1, Timer.PWM, pin=Pin('Y7'), pulse_width=0) self.dc1 = dc1 self.f1 = Pin("Y5", pyb.Pin.OUT_PP) self.b1 = Pin("Y6", pyb.Pin.OUT_PP) self.m2 = Timer(12, freq=100000).channel(2, Timer.PWM, pin=Pin('Y8'), pulse_width=0) self.dc2 = dc2 self.f2 = Pin("X20", pyb.Pin.OUT_PP) self.b2 = Pin("X19", pyb.Pin.OUT_PP)
def __init__(self, use_20khz_pwm=False): self.dir_l = Pin(DIR_L, Pin.OUT) self.dir_r = Pin(DIR_R, Pin.OUT) self.pwm_l = Pin(PWM_L, Pin.OUT) self.pwm_r = Pin(PWM_R, Pin.OUT) self.tim_r = Timer(4, freq=1000 if not (use_20khz_pwm) else 20000) self.ch_r = self.tim_r.channel(2, Timer.PWM, pin=self.pwm_r) self.tim_l = Timer(14, freq=500 if not (use_20khz_pwm) else 20000) self.ch_l = self.tim_l.channel(1, Timer.PWM, pin=self.pwm_l) self.flipLeft = False self.flipRight = False initialized = True # This class is always initialised and doens't need to initialised before
def __init__( self, clk_pin="X1", dt_pin="X2", switch_pin="X4", pwm_pin="X3", timer=2, channel=3, ): """ Establish pin functions, create rotary control and initialise tick response. """ self.switch_pin = Pin(switch_pin, mode=Pin.IN, pull=Pin.PULL_UP) self.pwm_pin = Pin(pwm_pin) # X3 has TIM2, CH3 on PyBoard self.tim = Timer(timer, freq=1000) self.pwm_ch = self.tim.channel(channel, Timer.PWM, pin=self.pwm_pin) self.pwm_ch.pulse_width_percent(0) self.r = RotaryIRQ( clk_pin, dt_pin, max_val=MAX_SETTING, reverse=True, range_mode=RotaryIRQ.RANGE_BOUNDED, ) self.on_off_count = self.current = 0 # Always fade up at power on self.target = INITIAL_TARGET self.running = True self.incr = 1 self.r.set(value=self.target)
def motor_control(): # 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) A1.high() # motor in brake position A2.high() # Calibrate the neutral position for joysticks MID = adc_1.read() # read the ADC 1 value now to calibrate DEADZONE = 10 # middle position when not moving # Use joystick to control forward/backward and speed while True: # loop forever until CTRL-C speed = int(100*(adc_1.read()-MID)/MID) 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() # stop A2.low()
def __init__(self): # set up motor with PWM and timer control self.A1 = Pin('X3', Pin.OUT_PP) # A is right motor self.A2 = Pin('X4', Pin.OUT_PP) self.B1 = Pin('X7', Pin.OUT_PP) # B is left motor self.B2 = Pin('X8', Pin.OUT_PP) self.PWMA = Pin('X1') self.PWMB = Pin('X2') self.speed = 0 # +100 full speed forward, -100 full speed back self.turn = 0 # turn is +/-100; 0 = left/right same speed, # ... +50 = left at speed, right stop, +100 = right back full # Configure counter 2 to produce 1kHz clock signal self.tim = Timer(2, freq=1000) # Configure timer to provide PWM signal self.motorA = self.tim.channel(1, Timer.PWM, pin=self.PWMA) self.motorB = self.tim.channel(2, Timer.PWM, pin=self.PWMB) self.lsf = 0 # left motor speed factor +/- 1 self.rsf = 0 # right motor speed factor +/- 1 self.countA = 0 # speed pulse count for motorA self.countB = 0 # speed pulse count for motorB self.speedA = 0 # actual speed of motorA self.speedB = 0 # actual speed of motorB # Create external interrupts for motorA and motorB Hall Effect Senors self.motorA_int = pyb.ExtInt('Y4', pyb.ExtInt.IRQ_RISING, pyb.Pin.PULL_NONE, self.isr_motorA) self.motorB_int = pyb.ExtInt('Y6', pyb.ExtInt.IRQ_RISING, pyb.Pin.PULL_NONE, self.isr_motorB) self.speed_timer = pyb.Timer(8, freq=10) self.speed_timer.callback(self.isr_speed_timer)
def __init__(self): global __bz_pin, __bz_tim, __bz_ch if not (__bz_pin): # Initialize timer and channels if not yet done __bz_pin = Pin("S5") # Broche S5 avec timer 4 et Channel 3 __bz_tim = Timer(4, freq=3000) __bz_ch = __bz_tim.channel(3, Timer.PWM, pin=__bz_pin)
def start(self, speed, direction): """ method to start a motor Arguments: speed : speed of the motor 0-100 (as percentage of max) direction : CW or CCW, for clockwise or counterclockwise """ PWMpin = Pin(self.PWMpin) DIRpin = Pin(self.DIRpin, Pin.OUT_PP) # DIR1 and DIR2 have to be opposite to move, toggle to change direction if direction in ('cw','CW','clockwise'): DIRpin.high() elif direction in ('ccw','CCW','counterclockwise'): DIRpin.low() else: raise ValueError('Please enter CW or CCW for direction.') # Start the motor if 0 <= speed <= 100: # self.PWMpin = Pin('X4') tim = Timer(self.timer_id, freq=1000) ch = tim.channel(self.channel_id, Timer.PWM, pin=PWMpin) ch.pulse_width_percent(speed) # PWM.start(self.PWMpin, speed) else: raise ValueError("Please enter speed between 0 and 100") # set the status attributes self.isRunning = True self.currentDirection = direction self.currentSpeed = speed
def __init__(self, pin="X8", timer_id=1, channel_id=1, callback=None, platform=None): if not platform: platform = sys.platform self.platform = platform if platform == "esp8266": from machine import PWM, Pin self.buzzer_pin = PWM(Pin(pin, Pin.OUT), freq=1000) elif platform == "pyboard": import pyb from pyb import Pin, Timer self.pyb = pyb self.sound_pin = Pin(pin) self.timer = Timer(timer_id, freq=10000) self.channel = self.timer.channel(1, Timer.PWM, pin=self.sound_pin, pulse_width=0) self.callback = callback
def main(): ## 创建测试磁场对象,统一分配引脚 tiny = pyb.Pin('X1', pyb.Pin.OUT_PP) # 对应小电阻, 接CM1 big = pyb.Pin('X2', pyb.Pin.OUT_PP) # 对应大电阻, 接CM2 rw = resistSwitch(big_resist_pin=big, tiny_resist_pin=tiny) bufs = generate_bufs() record_sig = syncSignal(pyb.Pin('X3', pyb.Pin.OUT_PP)) # X3 对应光耦IN1 sync_sig = syncSignal(pyb.Pin('X4', pyb.Pin.OUT_PP)) # X4 对应光耦IN2 freqs = [10] ch = 1 # X5 标定磁场输出 repeat = 20 timer_num = 6 mctrl = magCtrl(bufs, freqs, ch, sync_sig, rw, repeat, timer_num) record_sig.falling_edge() # 发送启动记录的信号 led = ledCue() ## timer3,用于循环测试 tim3 = Timer(3) tim3.init(freq=0.1) tim3.callback(mctrl.next) while not mctrl.end_flg: if mctrl.new_block: led.next(mctrl.stimulus_typ) mctrl.new_block = False time.sleep_us(500000) # 每50ms record_sig.falling_edge() # 发送结束记录的信号 led.end()
def __init__(self): #Defines the pins which the infrared sensors are connected to self.IR1 = Pin('X9', Pin.IN) self.IR2 = Pin('X10', Pin.IN) #sets up the timer self.tim = Timer(2, freq=1000) #Defines the pins that motor A is connected to self.A1 = 'Y9' self.A2 = 'Y10' self.PWMA = 'X1' self.chanA = 1 self.motorA = Motor(self.A1, self.A2, self.PWMA, self.chanA) #Defines the pins which motor B is connected to self.B1 = 'Y11' self.B2 = 'Y12' self.PWMB = 'X2' self.chanB = 2 self.motorB = Motor(self.B1, self.B2, self.PWMB, self.chanB) #Initial speed of the robot self.speed = 50 #Initial state of the path self.pathBlocked = False #Defines the speed at which the robot rotate self.ROTATION_SPEED = 50 #The pin which is connected to the potentiometer self.pot = ADC(Pin('X8'))
def pwm(self, pin_name, duty_percent=0): """ Create or retreive a PwmPin object based on its pin_name. duty_percent can be used for initial duty_cycle initialization """ if pin_name in self.pins: # released pin ? if self.pins[pin_name].pin.mode() == Pin.IN: del (self.pins[pin_name]) # So pin will be recreated else: return self.pins[pin_name] # Create the needed ressources and associated PwmPin if not (pin_name in PWM_DEFS): raise PwmException("Pin %s not supported by pwm library" % pin_name) pwm_def = PWM_DEFS[pin_name] # create the pin _pin = Pin(pin_name) # retreive initialized timer if not (pwm_def[0] in self.timers): self.timers[pwm_def[0]] = Timer(pwm_def[0], freq=self.freq) _timer = self.timers[pwm_def[0]] # each of the PinPwm instance (PWM output) uses its own channel, so no need to check for existence _channel = _timer.channel(pwm_def[1], pwm_def[2], pin=_pin) # Timer, channel, pin _channel.pulse_width_percent(duty_percent) # register the PwmPin self.pins[pin_name] = PwmPin(_pin, _timer, _channel) return self.pins[pin_name]
def __init__(self, pin, timer=None, length=None, freq=None): timers = af_map['P' + pin.name()] if not timers: raise PwmError("Pin does not support PWM.") if not timer: timer = 'TIM' for af, name in timers: if name.startswith(timer): timer_af, timer_name = af, name timer_full, channel = timer_name.split('_') if channel.startswith('CH'): break else: raise PwmError("Pin does not support timer %s" % timer) if length: freq = 1000000 / length elif not freq: freq = 50 pin.init(Pin.OUT, alt=af) self.timer = Timer(int(timer_full[3:]), freq=freq) self.channel = self.timer.channel( int(channel[2:3]), Timer.PWM_INVERTED if channel.endswith('N') else Timer.PWM, pin=pin) self.length = 1000000 / self.timer.freq() self.duty(0)
def main(): # Configure the timer as a microsecond counter. tim = Timer(config["timer"], prescaler=(machine.freq()[0] // 1000000) - 1, period=config["timer-period"]) print(tim) # Configure channel for timer IC. ch = tim.channel(1, Timer.IC, pin=config["pin-capture"], polarity=Timer.FALLING) # Slave mode disabled in order to configure mem32[config["timer-addr"] + TIM_SMCR] = 0 # Reset on rising edge (or falling in case of inverted detection). Ref: 25.4.3 of STM32F76xxx_reference_manual.pdf mem32[config["timer-addr"] + TIM_SMCR] = (mem32[config["timer-addr"] + TIM_SMCR] & 0xfffe0000) | 0x54 # Capture sensitive to rising edge. Ref: 25.4.9 of STM32F76xxx_reference_manual.pdf mem32[config["timer-addr"] + TIM_CCER] = 0b1001 try: capture(ch, 50) finally: tim.deinit()
def start(self, speed, direction): PWM_py_pin = Pin(self.PWMpin) DIR_py_pin = Pin(self.DIRpin, Pin.OUT_PP) tim = Timer(self.timer_id, freq=1000) ch = tim.channel(self.channel_id, Timer.PWM, pin=PWM_py_pin) if direction in ('cw', 'CW', 'clockwise'): DIR_py_pin.high() elif direction in ('ccw', 'CCW', 'counterclockwise'): DIR_py_pin.low() else: raise ValueError('Please enter CW or CCW') if 0 <= speed <= 100: ch.pulse_width_percent(speed) else: raise ValueError("Please enter a speed between 0 and 100") self.isRunning = True self.currentDirection = direction self.currentSpeed = speed
def init_loop_timer(self, timer_number): self.rollover = 0 self.loop_timer_period = 0xffff self.loop_timer = Timer( timer_number, prescaler=10800, period=self.loop_timer_period) # timer fq = 10000Hz 1s = 10000 self.loop_timer.callback(self.loop_counter_rollover)
def __init__(self, timerId, pin): ''' Constructor. Initializes a input-capture timer @param timerId: Id-number of the timer @param pin: Pin where the capture will be performed ''' self._timerId = timerId self._timerAddr = InputCapture._addresses[timerId] self._pin = pin self._timer = Timer(self._timerId, prescaler=(freq()[0] // 1000000) - 1, period=0xffff) # Set the timer and channel into input mode self._channel = self._timer.channel(1, mode=Timer.IC, pin=self._pin, polarity=Timer.FALLING) mem32[self._timerAddr + TIM_SMCR] = 0 mem32[self._timerAddr + TIM_SMCR] = (mem32[self._timerAddr + TIM_SMCR] & 0xfffe0000) | 0x54 mem32[self._timerAddr + TIM_CCER] = 0b1001 self.reset()
def main(): ## 统一分配引脚 bc = BoardCtrl('X1', 'X2', 'X3', 'X4') bufs = generate_bufs() DAC_ch = 'X5' sync_sig = syncSignal('X6') # record_sig = syncSignal('X7') freqs = [13] repeat = 1 timer_num = 6 mctrl = magCtrl(bufs, freqs, DAC_ch, sync_sig, bc, repeat, timer_num) # record_sig.falling_edge() # 发送启动记录的信号 led = ledCue() ## timer3,用于循环测试 tim3 = Timer(3) tim3.init(freq=0.2) tim3.callback(mctrl.next) while not mctrl.end_flg: if mctrl.new_block: led.next(mctrl.stimulus_level) mctrl.new_block = False time.sleep_us(500000) # 每50ms # record_sig.falling_edge() # 发送结束记录的信号 led.end()
def runLedStartNoBlock(flag=True, tim_num=14, tim_freq=0.3, led_num=4): """ """ if flag: tim = Timer(tim_num, freq=tim_freq) tim.callback(lambda cb_fun: LED(led_num).toggle()) else: pass
def __init__(self): global __bz_pin, __bz_tim, __bz_ch if not (__bz_pin): # Initialize timer and channels if not yet done __bz_pin = Pin("Y11") # Broche Y2 avec timer 8 et Channel 2 __bz_tim = Timer(8, freq=3000) __bz_ch = __bz_tim.channel(2, Timer.PWM_INVERTED, pin=__bz_pin)
async def isr_test(): # Test trigger from hard ISR from pyb import Timer s = ''' Timer holds off cb for 5 secs cb should now run cb callback Done ''' printexp(s, 6) def cb(v): print('cb', v) d = Delay_ms(cb, ('callback', )) def timer_cb(_): d.trigger(200) tim = Timer(1, freq=10, callback=timer_cb) print('Timer holds off cb for 5 secs') await asyncio.sleep(5) tim.deinit() print('cb should now run') await asyncio.sleep(1) print('Done')
def __init__(self, cs=Pin.cpu.A4, trigger=Pin.cpu.C0, echo=Pin.cpu.C1, timer=Timer(2), avg_window=1): self.__io = MCP23S08(cs=cs) self.__trigger = Pin(trigger, Pin.OUT_PP) self.__echo = Pin(echo, Pin.IN, pull=Pin.PULL_DOWN) self.__timer = timer self.__counter = 0 self.__window_len = avg_window self.__window = [] self.__trigger.high() self.__io.set_direction(0, 0) self.__io.set_direction(1, 0) self.__io.set_direction(2, 0) self.__io.set_direction(3, 0) self.__io.set_gpio(0, 0) self.__io.set_gpio(1, 0) self.__io.set_gpio(2, 0) self.__io.set_gpio(3, 0) self.select_sensor(3)
def __init__(self, pin, fname, reps=5): self._pin = pin self._reps = reps with open(fname, 'r') as f: self._data = ujson.load(f) # Time to wait between nonblocking transmissions. A conservative value in ms. self._latency = (reps + 2) * max( (sum(x) for x in self._data.values())) // 1000 gc.collect() if ESP32: self._rmt = RMT(0, pin=pin, clock_div=80) # 1μs resolution elif RP2: # PIO-based RMT-like device self._rmt = RP2_RMT(pin_pulse=pin) # 1μs resolution # Array size: length of longest entry + 1 for STOP asize = max([len(x) for x in self._data.values()]) + 1 self._arr = array('H', (0 for _ in range(asize))) # on/off times (μs) else: # Pyboard self._tim = Timer(5) # Timer 5 controls carrier on/off times self._tcb = self._cb # Pre-allocate asize = reps * max([len(x) for x in self._data.values() ]) + 1 # Array size self._arr = array('H', (0 for _ in range(asize))) # on/off times (μs) self._aptr = 0 # Index into array