Python Pin.IRQ_FALLING属性代码示例

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def __init__(self, name, pin,
                 rising=False, falling=False,
                 pullup=True, on_change=None, report_change=True):
        if pullup:
            pin.init(Pin.IN, Pin.PULL_UP)
        else:
            pin.init(Pin.IN, Pin.OPEN_DRAIN)
        if rising and falling:
            trigger = Pin.IRQ_RISING | Pin.IRQ_FALLING
        elif not rising and falling:
            trigger = Pin.IRQ_FALLING
        else:  # also if both all false
            trigger = Pin.IRQ_RISING
        pin.irq(trigger=trigger, handler=self._cb)
        self.counter = 0
        self.report_counter = 0
        self.triggered = False
        Device.__init__(self, name, pin, on_change=on_change,
                        report_change=report_change)
        self.getters[""] = self.value 

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def __init__(self,button_idx, callback=None):
        # 按键字典
        # 数据结构： (GPIO编号，按键抬起的电平， 按键按下的电平)
        button_list = [(39, False, True)]

        if button_idx < 0 or button_idx >= len(button_list):
            print("ERROR: Wrong Button Index")
            print("Valid Button Index: {} - {}".format(0, len(button_list)-1))
            return None

        gpio_id, self.BUTTON_RELEASE, self.BUTTON_PRESS, = button_list[button_idx]
        # 按键
        self.pin = Pin(gpio_id, Pin.IN)
        # 回调函数
        self.callback = callback
        # 设置外部中断
        if self.BUTTON_PRESS == True:
            self.pin.irq(trigger=Pin.IRQ_RISING, handler=self.irq_handler)
        else:
            self.pin.irq(trigger=Pin.IRQ_FALLING, handler=self.irq_handler)
        
        # 标志位 当前是否可以相应按键中断
        self.flag = True 

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def __init__(self, pin, callback, extended, *args):  # Optional args for callback
        self._ev_start = Event()
        self._callback = callback
        self._extended = extended
        self._addr = 0
        self.block_time = 80 if extended else 73  # Allow for some tx tolerance (?)
        self._args = args
        self._times = array('i',  (0 for _ in range(_EDGECOUNT + 1)))  # +1 for overrun
        if platform == 'pyboard':
            ExtInt(pin, ExtInt.IRQ_RISING_FALLING, Pin.PULL_NONE, self._cb_pin)
        else:  # PR5962 ESP8266 hard IRQ's not supported
            pin.irq(handler = self._cb_pin, trigger = (Pin.IRQ_FALLING | Pin.IRQ_RISING))
        #elif ESP32:
            #pin.irq(handler = self._cb_pin, trigger = (Pin.IRQ_FALLING | Pin.IRQ_RISING))
        #else:
            #pin.irq(handler = self._cb_pin, trigger = (Pin.IRQ_FALLING | Pin.IRQ_RISING), hard = True)
        self._edge = 0
        self._ev_start.clear()
        loop = asyncio.get_event_loop()
        loop.create_task(self._run()) 

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def set_callbacks(self, callback=None):
        mode = Pin.IRQ_RISING | Pin.IRQ_FALLING
        self.irq_clk = self.pin_clk.irq(trigger=mode, handler=callback)
        self.irq_dt = self.pin_dt.irq(trigger=mode, handler=callback) 

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def __init__(self, port):
        self.tx = PWM(port[0], freq=38000, duty=0, timer=1)
        self.rx = Pin(port[1], Pin.IN)
        self.rx.init(Pin.IN)
        self.rx.irq(handler=self._irq_cb, trigger=Pin.IRQ_FALLING)
        self.rx_value = 0
        self.times = 0
        self.status = 0
        self.tx_en = 0
        self.duty = 0
        self.time_num = peripheral.get_timer()
        if self.time_num == None:
            raise unit.Unit('ir application time fail')
        self.timer = Timer(self.time_num)
        self.timer.init(period=50, mode=self.timer.PERIODIC, callback=self._update) 

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def set_mode_digital_input(self, payload):
        """
        Set a pin as a digital input with pull_up and
        enable interrupts for a change on either edge.
        :param payload:
        :return:
        """
        pin = payload['pin']
        pin_in = Pin(pin, Pin.IN, Pin.PULL_UP)
        pin_in.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler=self.digital_input_callback)
        self.input_pin_objects[pin] = pin_in 

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def __init__(self, pin_x, pin_y, reverse, scale):
        self.reverse = reverse
        self.scale = scale
        self.forward = True
        self.pin_x = pin_x
        self.pin_y = pin_y
        self._pos = 0
        self.x_interrupt = pin_x.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler=self.x_callback)
        self.y_interrupt = pin_y.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler=self.y_callback) 

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def __init__(self, gpio_id, callback=None):
        # 按键
        self.pin = Pin(gpio_id, Pin.IN)
        # 回调函数
        self.callback = callback
        # 设置外部中断
        self.pin.irq(trigger=Pin.IRQ_FALLING, handler=self.irq_handler)
        # 标志位 是否处理完成中断
        self.flag = False 

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def __init__(self, pin, callback=None, trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING):
        self._register = bytearray([0b11111111])
        self._user_callback = callback
        self._current_state = False
        self._previous_state = False
        self._pin = pin
        self._pin.init(self._pin.IN, trigger=trigger, handler=self._callback) 

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def __init__(self, callback=None, trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING):
        pin = Pin(BUTTON_A_PIN, Pin.IN)
        DigitalInput.__init__(self, pin, callback=callback, trigger=trigger) 

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def init_pins(self):
        self.pin_irq = Pin(self.irq_pin, Pin.IN, Pin.PULL_UP)
        self.pin_irq.irq(handler=self.isr, trigger=Pin.IRQ_FALLING) 

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def __init__(self, uart, rx_pin, rx_irq=None, frame_irq=None, CHR_TMO=3, FRAME_TMO=100):
        self._rxpin = rx_pin
        self._rxirq = rx_irq
        self._frameirq = frame_irq
        self._CHR_TMO = CHR_TMO
        self._FRAME_TMO = FRAME_TMO
        self._rxpin.init(Pin.IN)
        self._rxpin.irq(trigger = Pin.IRQ_FALLING, handler = self._RXPIN_IRQ)
        self._TMRX = Timer(-1)
        self._TMRX_sta = 0
        self._mode = Timer.ONE_SHOT if sys.platform == 'pyboard' else Timer.PERIODIC
        self.uart = uart 

# 需要导入模块: from machine import Pin [as 别名]
# 或者: from machine.Pin import IRQ_FALLING [as 别名]
def __init__(self, pin, callback, extended, *args):  # Optional args for callback
        self._ev_start = Message()
        self._callback = callback
        self._extended = extended
        self._addr = 0
        self.block_time = 80 if extended else 73  # Allow for some tx tolerance (?)
        self._args = args
        self._times = array('i',  (0 for _ in range(_EDGECOUNT + 1)))  # +1 for overrun
        if platform == 'pyboard':
            ExtInt(pin, ExtInt.IRQ_RISING_FALLING, Pin.PULL_NONE, self._cb_pin)
        else:  # PR5962 ESP8266 hard IRQ's not supported
            pin.irq(handler = self._cb_pin, trigger = (Pin.IRQ_FALLING | Pin.IRQ_RISING))
        self._edge = 0
        self._ev_start.clear()
        asyncio.create_task(self._run())