Python machine.Pin类代码示例

    def __init__(self, debug=False, baud=100000):
        # From datasheet
        # Bit rate – up to 12 MHz1
        # ▪ Polarity – CPOL = 1; clock transition high-to-low on the leading edge and low-to-high on the
        #   trailing edge
        # ▪ Phase – CPHA = 1; setup on the leading edge and sample on the trailing edge
        # ▪ Bit order – MSB first
        # ▪ Chip select polarity – active low
        self.spi = SPI(0)
        try:
            self.spi.init(mode=SPI.MASTER, baudrate=baud, bits=8,
                          polarity=1, phase=1, firstbit=SPI.MSB,
                          pins=('GP31', 'GP16', 'GP30')) # CLK, MOSI, MISO
        except AttributeError:
            self.spi.init(baudrate=baud, bits=8,
                          polarity=1, phase=1, firstbit=SPI.MSB,
                          pins=('GP31', 'GP16', 'GP30')) # CLK, MOSI, MISO

        # These are all active low!
        self.tc_en_bar = Pin('GP4', mode=Pin.OUT)

        self.disable()

        self.tc_busy_bar = Pin('GP5', mode=Pin.IN)
        self.tc_busy_bar.irq(trigger=Pin.IRQ_RISING) # Wake up when it changes
        self.tc_cs_bar = Pin('GP17', mode=Pin.ALT, alt=7)

        self.debug = debug

  def __init__(self, pinNr, activeLow, externalResistor=False):
    if externalResistor:
      self._pin = Pin(pinNr, Pin.IN) 
    else:
      self._pin = Pin(pinNr, Pin.IN, Pin.PULL_UP if activeLow else Pin.PULL_DOWN) 

    # number of millisec that have to pass by before a click is detected.
    self._clickTicks = 200

    # number of millisec that have to pass by before a long button press is detected.
    self._pressTicks = 1000

    self._debounceTicks = 50 # number of ticks for debounce times.
 
    # starting with state 0: waiting for button to be pressed
    self._state = 0
    self._isLongPressed = False # Keep track of long press state

    if (activeLow):
      # button connects ground to the pin when pressed.
      self._buttonReleased = 1  # notPressed
      self._buttonPressed = 0
    else:
      # button connects VCC to the pin when pressed.
      self._buttonReleased = 0
      self._buttonPressed = 1


    self._clickFunc = None
    self._doubleClickFunc = None
    self._longPressStartFunc = None
    self._longPressStopFunc = None
    self._duringLongPressFunc = None

    self._startTime = None

def activate(state):
    global inPin
    if(state):
        inPin = Pin(12, Pin.IN, Pin.PULL_UP)
        inPin.irq(trigger=Pin.IRQ_RISING, handler=timeUS)
    # Disables the internal pull-up, therefore preventing any further RISING_EDGE case.
    else:
        inPin = Pin(12, Pin.IN)

def isLight(dataPin):
    """ Check if it's light or dark, using a CEG013600 ambient light sensor connected to the GPIO pin named by dataPin """
    light_in = Pin(dataPin, mode=Pin.IN)
    if light_in.value() == 1:
        """ 1 means dark """
        return False
    else:
        return True

    def __init__(self, pin_1, pin_2, pwm_pin):
        self.pin_1 = Pin(pin_1, mode=Pin.OUT, pull=None)
        self.pin_1.value(0)

        self.pin_2 = Pin(pin_2, mode=Pin.OUT, pull=None)
        self.pin_1.value(0)

        self.pwm = TB6612FNG_channel._pwm.channel(self.id(), pin=pwm_pin, duty_cycle=1)
        self.pwm.duty_cycle(0)

 def near(self): 
     id = int(str(self)[4:-1]) #unsafe!
     pin15=Pin(15,Pin.OUT)
     pin15.value(1)
     adc=ADC(Pin(id))
     adc.atten(ADC.ATTN_11DB)
     approximate =adc.read()
     pin15.value(0)
     return approximate

	def __init__(self, latch, clock, data):
		self._latch = latch
		self._clock = clock
		self._data = data
		self._latchPin = Pin(latch, mode=Pin.OUT)
		self._latchPin.value(0)
		self._clockPin = Pin(clock, mode=Pin.OUT)
		self._clockPin.value(1)
		self._dataPin = Pin(data, mode=Pin.OUT)
		self._dataPin.value(0)

class TB6612FNG(object):

    def __init__(self, a_1, a_2, a_pwm, b_1, b_2, b_pwm, standby_pin):
        self._standby = Pin(standby_pin, mode=Pin.OUT, pull=None)
        self._standby.value(1)
        self.channelA = _TB6612FNG_channel(a_1, a_2, a_pwm)
        self.channelB = _TB6612FNG_channel(b_1, b_2, b_pwm)

    def standby(self, *args):
        return self._standby.value(*args)

    def __init__(self):
        #        OUTPUT/INPUT
        self.pins = ['GP16', 'GP13']
        self.outputPin = Pin(self.pins[0], mode=Pin.OUT, value=1)
        self.inputPin = Pin(self.pins[1], mode=Pin.IN, pull=Pin.PULL_UP)

        self.triggerCount = 0
        self._triggerType_ = Pin.IRQ_RISING
        self.inputIRQ = self.inputPin.irq(trigger=self._triggerType_, handler=self.pinHandler)
        self.irqState = True

def test():
    stx = Pin(Pin.board.Y5, Pin.OUT_PP)         # Define pins
    sckout = Pin(Pin.board.Y6, Pin.OUT_PP)
    sckout.value(0) # Don't assert clock until data is set
    srx = Pin(Pin.board.Y7, Pin.IN)
    sckin = Pin(Pin.board.Y8, Pin.IN)

    objsched = Sched(heartbeat = 1)
    with SynCom(objsched, False, sckin, sckout, srx, stx) as channel:
        objsched.add_thread(initiator_thread(channel))
        objsched.run()

class Relay:

    def __init__(self, pin, initialValue=0):
        self.controlPin = Pin(pin, Pin.OUT)
        self.Open()
        pass
    
    def Open(self):
        self.controlPin.value(0)
        
    def Close(self):
        self.controlPin.value(1)

    def __init__(self):
        self.x_adc = ADC(1)

        self.btn_speed_up = Pin("P13", mode=Pin.IN, pull=Pin.PULL_UP)
        self.btn_speed_down = Pin("P15", mode=Pin.IN, pull=Pin.PULL_UP)
        self.btn_speed_full = Pin("P14", mode=Pin.IN, pull=Pin.PULL_UP)
        self.btn_speed_off = Pin("P16", mode=Pin.IN, pull=Pin.PULL_UP)

        self.x_mid = 0
        
        self.calibrate()
        self.connect()
        self.loop()

def main(use_stream=False):
	s = socket.socket()

	# Binding to all interfaces - server will be accessible to other hosts!
	ai = socket.getaddrinfo("0.0.0.0", 8080)
	print("Bind address info:", ai)
	addr = ai[0][-1]

	#prepping LED pin
	p = Pin(2,Pin.OUT)
#	p.high()
#	time.sleep(1)
#	p.low()


	s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
	s.bind(addr)
	s.listen(5)
	print("Listening, connect your browser to http://<this_host>:8080/")

	counter = 0
	while True:
		res = s.accept()
		client_s = res[0]
		client_addr = res[1]
		print("Client address:", client_addr)
		print("Client socket:", client_s)
		print("Request:")
		if use_stream:
			# MicroPython socket objects support stream (aka file) interface
			# directly.
			#print(client_s.read(4096))
			val = client_s.read(4096)
			print(val)
			client_s.write(CONTENT % counter)
		else:
			#print(client_s.recv(4096))
			val = client_s.recv(4096)
			print(val)
			client_s.send(CONTENT % counter)
		if "GET /toggle" in val:
			print("Toggling!")
			p.high()
			time.sleep(1)
			p.low()
			machine.reset()
		client_s.close()
		counter += 1
		print()

class LaserBeam:
    def __init__(self, laser_pinname, photodiode_pinname):
        self.laser = Pin(laser_pinname, Pin.OUT_OD)
        self.photodiode = ADC(photodiode_pinname)
        self.threshold = 100

    def ping(self):
        dark = self.photodiode.read()
        self.laser.value(0)          # pull down to on
        light = self.photodiode.read()
        self.laser.value(1)          # float to off
        return light-dark

    def interrupted(self):
        return self.ping() < self.threshold \
            and sum(self.ping() for i in range(10)) < 10 * self.threshold

	def __init__(self, triggerGPIO, echoGPIO):
		self.triggerPin = Pin(triggerGPIO, mode = Pin.OUT)
		self.echoPin = Pin(echoGPIO, mode = Pin.IN)
		# The var to know if we have 28 or 028 in the decimal part
		self.mm_decimal = ""
		# Distance initated to -1 while nothing
		self.mm = -1
		self.cm = -1