class Button: def __init__(self, pin): from machine import Pin self.pin = Pin(pin, Pin.IN) def get_presses(self, delay = 1): last_time, last_state, presses = time.time(), 0, 0 while time.time() < last_time + delay: time.sleep_ms(50) if last_state == 0 and self.pin.value() == 1: last_state = 1 if last_state == 1 and self.pin.value() == 0: last_state, presses = 0, presses + 1 return presses def is_pressed(self): return self.pin.value() == 0 def was_pressed(self): last_state = self.pin.value() time.sleep_ms(15) if last_state == 1 and self.pin.value() == 0: return True return False def irq(self, handler, trigger): self.pin.irq(handler = handler, trigger = trigger)
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
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 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 main(): # set internal clock rtc = settime(timezone_offset=TIMEZONE_OFFSET) year, month, day, hour, minute, second, *_ = rtc.now() trigger = Pin('GP5', mode=Pin.OUT) trigger.value(0) # initial trigger timer timer = Timer(3, mode=Timer.PERIODIC, width=32) timer_channel = timer.channel(Timer.A | Timer.B, period=30000000) timer_channel.irq(handler=lambda t: trigger.toggle(), trigger=Timer.TIMEOUT) try: while True: leds = clock2matrix(hour=hour, minute=minute).columns # led matrix multiplexing current_trigger = trigger.value() while trigger.value() == current_trigger: for col in leds: latch.value(0) # write current time spi.write(col) # update LEDs latch.value(1) sleep_ms(1) latch.value(0) spi.write(OFF) latch.value(1) sleep_us(50) latch.value(0) spi.write(OFF) latch.value(1) year, month, day, hour, minute, second, *_ = rtc.now() # update rtc at 04:00 if hour == 4 and minute == 0: rtc = settime(timezone_offset=TIMEZONE_OFFSET) except Exception as e: matrix_off() while True: print(e) sleep_ms(2000)
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 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
class Sonar: def __init__(self,trig,echo): self.trig=Pin(trig,Pin.OUT) self.echo=Pin(echo,Pin.IN) def checkdist(self): self.trig.value(0) self.echo.value(0) self.trig.value(1) time.sleep_us(10) self.trig.value(0) while(self.echo.value()==0): pass t1=time.ticks_us() while(self.echo.value()==1): pass t2=time.ticks_us() return round(time.ticks_diff(t2,t1)/10000*340/2,2)
class Buzz(object): def __init__(self,pin=6): self.id=pins_remap_esp32[pin] self.io=Pin(self.id) self.io.value(1) self.isOn=False def on(self,freq=500): if self.isOn is False: self.pwm=PWM(self.io,freq,512) self.isOn=True def off(self): if self.isOn: self.pwm.deinit() self.io.init(self.id,Pin.OUT) self.io.value(1) self.isOn=False def freq(self,freq): self.pwm.freq(freq)
class DistanceSensor: 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 def isDistanceCalculated(self): return self.mm != -1 & self.cm != -1 def setTriggerPinValue(self, value): self.triggerPin.value(value) def getDistanceString(self): return str(self.cm) + "," + self.mm_decimal + str(self.mm) + "cm" def changingEdge(self, pin): global callback # Get the flag which enabled to IRQ flags = callback.flags() # If rising, start count the time if flags & Pin.IRQ_RISING: self.raising_time = time.ticks_us() # If falling edge, then stop counting the time and calculate the distance elif flags & Pin.IRQ_FALLING: self.falling_time = time.ticks_us() # Get the ellapsed time between RISING and FALLING delay = time.ticks_diff(self.raising_time, self.falling_time) # We use 17 instead of 0,017 distance = delay * 17 # We rescale the distance in cm by separating cm and mm self.cm = distance // 1000 self.mm = distance % 1000 #in case we have a distance like 49028 # cm = 49 # mm = 028 but the 0 would be discared so we check it if distance % 100 == distance % 1000: self.mm_decimal = "0"
class output(object): def __init__(self,name,config,callback): # mode = config.get('MODE', 'OUTPUT') port = config.get('PORT', 1) self._name = name self._callback = callback print('GPIO-output',port,config,name,callback) self._gpio = Pin(port, Pin.OUT) def run(self): while True: yield def SET(self,value): if 'ON' in value: self._gpio.value(1) else: self._gpio.value(0) #self._gpio.off() # print('GET METHode VALUE',value) return True
# PIR PIR_PIN = 13 # Signal du senseur PIR. PIR_RETRIGGER_TIME = 15 * 60 # 15 min # temps (sec) dernière activation PIR last_pir_time = 0 last_pir_msg = "NONE" # temps (sec) dernier envoi MSG last_pir_msg_time = 0 # Programme principal doit-il envoyer # une notification "MOUV" rapidement? fire_pir_alert = False # --- Demarrage conditionnel --- runapp = Pin( 12, Pin.IN, Pin.PULL_UP ) led = Pin( 0, Pin.OUT ) led.value( 1 ) # eteindre def led_error( step ): global led t = time.time() while ( time.time()-t ) < ERROR_REBOOT_TIME: for i in range( 20 ): led.value(not(led.value())) time.sleep(0.100) led.value( 1 ) # eteindre time.sleep( 1 ) # clignote nbr fois for i in range( step ): led.value( 0 ) time.sleep( 0.5 ) led.value( 1 )
############################################################# # LED blink Demo 5 # Date: 2020-04-18 ############################################################# from machine import Pin, PWM import utime as time LED_OFF = 1 # 1=OFF, 0=ON LED_GPIO = 5 # use GPIO5 for LED output def main_loop(): while True: time.sleep(-1) try: led = Pin(LED_GPIO, Pin.OUT) # create a PWM object for the specified pin pwm = PWM(led) pwm.freq(5) # note: 1Hz is the lowest frequency main_loop() except KeyboardInterrupt: pass finally: led.value(LED_OFF) # turn off LED pwm.deinit() # turn off PWM #############################################################
class HCSR04: """ Driver to use the untrasonic sensor HC-SR04. The sensor range is between 2cm and 4m. The timeouts received listening to echo pin are converted to OSError('Out of range') """ # echo_timeout_us is based in chip range limit (400cm) def __init__(self, trigger_pin, echo_pin, echo_timeout_us=500*2*30): """ trigger_pin: Output pin to send pulses echo_pin: Readonly pin to measure the distance. The pin should be protected with 1k resistor echo_timeout_us: Timeout in microseconds to listen to echo pin. By default is based in sensor limit range (4m) """ self.echo_timeout_us = echo_timeout_us # Init trigger pin (out) self.trigger = Pin(trigger_pin, mode=Pin.OUT, pull=None) self.trigger.value(0) # Init echo pin (in) self.echo = Pin(echo_pin, mode=Pin.IN, pull=None) def _send_pulse_and_wait(self): """ Send the pulse to trigger and listen on echo pin. We use the method `machine.time_pulse_us()` to get the microseconds until the echo is received. """ self.trigger.value(0) # Stabilize the sensor time.sleep_us(5) self.trigger.value(1) # Send a 10us pulse. time.sleep_us(10) self.trigger.value(0) try: pulse_time = machine.time_pulse_us(self.echo, 1, self.echo_timeout_us) return pulse_time except OSError as ex: if ex.args[0] == 110: # 110 = ETIMEDOUT raise OSError('Out of range') raise ex def distance_mm(self): """ Get the distance in milimeters without floating point operations. """ pulse_time = self._send_pulse_and_wait() # To calculate the distance we get the pulse_time and divide it by 2 # (the pulse walk the distance twice) and by 29.1 becasue # the sound speed on air (343.2 m/s), that It's equivalent to # 0.34320 mm/us that is 1mm each 2.91us # pulse_time // 2 // 2.91 -> pulse_time // 5.82 -> pulse_time * 100 // 582 mm = pulse_time * 100 // 582 return mm def distance_cm(self): """ Get the distance in centimeters with floating point operations. It returns a float """ pulse_time = self._send_pulse_and_wait() # To calculate the distance we get the pulse_time and divide it by 2 # (the pulse walk the distance twice) and by 29.1 becasue # the sound speed on air (343.2 m/s), that It's equivalent to # 0.034320 cm/us that is 1cm each 29.1us cms = (pulse_time / 2) / 29.1 return cms
from machine import Pin import time, network, urequests sta_if = network.WLAN(network.STA_IF) sta_if.active(True) sta_if.connect("Wifi 基地台", "Wifi 密碼") while not sta_if.isconnected(): pass print('wifi connect') # window D0 window = Pin(16, Pin.IN) while True: print(window.value()) if window.value() == 1: print('家裡遭小偷,請盡速查看') urequests.get("IFTTT 的 HTTP 請求網址") time.sleep(10) time.sleep(1)
class EPD(object): MAX_READ = 45 SW_NORMAL_PROCESSING = 0x9000 EP_FRAMEBUFFER_SLOT_OVERRUN = 0x6a84 # too much data fed in EP_SW_INVALID_LE = 0x6c00 # Wrong expected length EP_SW_INSTRUCTION_NOT_SUPPORTED = 0x6d00 # bad instr EP_SW_WRONG_PARAMETERS_P1P2 = 0x6a00 EP_SW_WRONG_LENGTH = 0x6700 DEFAULT_SLOT=0 # always the *oldest*, should wear-level then I think 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 enable(self): self.tc_en_bar.value(0) # Power up time.sleep_ms(5) while self.tc_busy_bar() == 0: machine.idle() # will it wake up here? # /tc_busy goes high during startup, low during init, then high when not busy def disable(self): self.tc_en_bar.value(1) # Off def send_command(self, ins, p1, p2, data=None, expected=None): # These command variables are always sent cmd = struct.pack('3B', ins, p1, p2) # Looks like data is only sent with the length (Lc) if data: assert len(data) <= 251 # Thus speaks the datasheet cmd += struct.pack('B', len(data)) cmd += data # Expected data is either not present at all, 0 for null-terminated, or a number for fixed if expected is not None: cmd += struct.pack('B', expected) if self.debug: print("Sending: " + hexlify(cmd).decode()) self.spi.write(cmd) # Wait for a little while time.sleep_us(15) # This should take at most 14.5us while self.tc_busy_bar() == 0: machine.idle() # Request a response if expected is not None: if expected > 0: result_bytes = self.spi.read(2 + expected) else: result_bytes = self.spi.read(EPD.MAX_READ) strlen = result_bytes.find(b'\x00') result_bytes = result_bytes[:strlen] + result_bytes[strlen+1:strlen+3] else: result_bytes = self.spi.read(2) if self.debug: print("Received: " + hexlify(result_bytes).decode()) (result,) = struct.unpack_from('>H', result_bytes[-2:]) if result != EPD.SW_NORMAL_PROCESSING: raise ValueError("Bad result code: 0x%x" % result) return result_bytes[:-2] @staticmethod def calculate_checksum(data, skip=16): """ Initial checksum value is 0x6363 :param data: :param skip: Skip some data as slices are expensive :return: """ acc = 0x6363 for byte in data: if skip > 0: skip -= 1 else: acc ^= byte acc = ((acc >> 8) | (acc << 8)) & 0xffff acc ^= ((acc & 0xff00) << 4) & 0xffff acc ^= (acc >> 8) >> 4 acc ^= (acc & 0xff00) >> 5 return acc def get_sensor_data(self): # GetSensorData val = self.send_command(0xe5, 1, 0, expected=2) (temp,) = struct.unpack(">H", val) return temp def get_device_id(self): return self.send_command(0x30, 2, 1, expected=0x14) def get_system_info(self): return self.send_command(0x31, 1, 1, expected=0) def get_system_version_code(self): return self.send_command(0x31, 2, 1, expected=0x10) def display_update(self, slot=0, flash=True): cmd = 0x86 if flash: cmd = 0x24 self.send_command(cmd, 1, slot) def reset_data_pointer(self): self.send_command(0x20, 0xd, 0) def image_erase_frame_buffer(self, slot=0): self.send_command(0x20, 0xe, slot) def get_checksum(self, slot): cksum_val = self.send_command(0x2e, 1, slot, expected=2) (cksum,) = struct.unpack(">H", cksum_val) return cksum def upload_image_data(self, data, slot=0, delay_us=1000): self.send_command(0x20, 1, slot, data) time.sleep_us(delay_us) def upload_whole_image(self, img, slot=0): """ Chop up chunks and send it :param img: Image to send in EPD format :param slot: Slot framebuffer number to use :param delay_us: Delay between packets? 450us and the Tbusy line never comes back :return: """ total = len(img) idx = 0 try: while idx < total - 250: chunk = img[idx:idx+250] self.upload_image_data(chunk, slot) del chunk idx += 250 self.upload_image_data(img[idx:], slot) except KeyboardInterrupt: print("Stopped at user request at position: %d (%d)" % (idx, (idx // 250))) except ValueError as e: print("Stopped at position: %d (%d) - %s" % (idx, (idx // 250), e))
def __init__(self, spd=115200): RST = Pin(RST_PIN, mode=Pin.OUT) RST.value(0) uart = UART(1, baudrate=spd, pins=(TXD_PIN, RXD_PIN)) RST.value(1)
from machine import Pin, SPI from .ili934xnew import ILI9341, color565 from . import m5stack as board from . import glcdfont from . import tt14 from . import tt24 from . import tt32 fonts = [glcdfont, tt14, tt24, tt32] text = 'Now is the time for all good men to come to the aid of the party.' power = Pin(m5stack.TFT_LED_PIN, Pin.OUT) power.value(1) spi = SPI(2, baudrate=40000000, miso=Pin(m5stack.TFT_MISO_PIN), mosi=Pin(m5stack.TFT_MOSI_PIN), sck=Pin(m5stack.TFT_CLK_PIN)) display = ILI9341(spi, cs=Pin(m5stack.TFT_CS_PIN), dc=Pin(m5stack.TFT_DC_PIN), rst=Pin(m5stack.TFT_RST_PIN), w=320, h=240, r=3)
class Button(): ''' class Button ''' flags_btn_deb = False flags_btn_flag = True flags_btn_state = False flags_isPress_f = False flags_oneClick_f = True flags_hold_flag = False btn_counter = 0 flags_isRelease_f = False flags_step_flag = True flags_isOne_f = False btn_timer = time.ticks_ms() flags_tickMode = False counter_flag = True last_counter = 0 flags_counter_flag = True timeout = 500 flags_isHolded_f = False flags_hold_flag = True def __init__(self, pin=5, click_timeout=300, debounce=60, step_timeout=400): self.pin = pin self.debounce = debounce self.click_timeout = click_timeout self.step_timeout = step_timeout self.btn = Pin(pin, Pin.IN) def tick(self): # read pin self.flags_btn_state = self.btn.value() # нажатие if self.flags_btn_state and not self.flags_btn_flag: if not self.flags_btn_deb: self.flags_btn_deb = True self.btn_timer = time.ticks_ms() else: if time.ticks_ms() - self.btn_timer >= self.debounce: self.flags_btn_flag = True self.flags_isPress_f = True self.flags_oneClick_f = True else: self.flags_btn_deb = False # otpuskaem if not self.flags_btn_state and self.flags_btn_flag: self.flags_btn_flag = False if not self.flags_hold_flag: self.btn_counter = self.btn_counter + 1 self.flags_hold_flag = False self.flags_isRelease_f = True self.btn_timer = time.ticks_ms() self.flags_step_flag = False if self.flags_oneClick_f: self.flags_oneClick_f = False self.flags_isOne_f = True # hold if self.flags_btn_flag and self.flags_btn_state and time.ticks_ms( ) - self.btn_timer >= self.timeout and not self.flags_hold_flag: self.flags_hold_flag = True self.btn_counter = 0 self.last_counter = 0 self.flags_isHolded_f = True self.flags_step_flag = True self.flags_oneClick_f = False self.btn_timer = time.ticks_ms() if time.ticks_ms( ) - self.btn_timer >= self.click_timeout and self.btn_counter > 0: self.last_counter = self.btn_counter self.btn_counter = 0 self.flags_counter_flag = True def setTickMode(self, tickMode): self.flags_tickMode = tickMode def isSingle(self): if self.flags_tickMode: self.tick() if self.flags_counter_flag and self.last_counter == 1: self.flags_counter_flag = False return True else: return False def isDouble(self): if self.flags_tickMode: self.tick() if self.flags_counter_flag and self.last_counter == 2: self.flags_counter_flag = False return True else: return False def isTriple(self): if self.flags_tickMode: self.tick() if self.flags_counter_flag and self.last_counter == 3: self.flags_counter_flag = False return True else: return False def isPress(self): if self.flags_isPress_f: self.flags_isPress_f = False return True else: return False def state(self): if self.flags_tickMode: self.tick() return self.flags_btn_state def main(self): while True: self.tick() if self.isPress(): print("Is pressed") if self.isDouble(): print("is Double") if self.isSingle(): print("is Single") if self.state(): print("state True")
import time from machine import ADC, Pin engine = Pin(16, Pin.OUT) engine.value(0) while True: engine.value(0) time.sleep(.1) engine.value(1) time.sleep(.1)
class MFRC522: OK = 0 NOTAGERR = 1 ERR = 2 REQIDL = 0x26 REQALL = 0x52 AUTHENT1A = 0x60 AUTHENT1B = 0x61 def __init__(self, sck, mosi, miso, rst, cs): self.sck = Pin(sck, Pin.OUT) self.mosi = Pin(mosi, Pin.OUT) self.miso = Pin(miso) self.rst = Pin(rst, Pin.OUT) self.cs = Pin(cs, Pin.OUT) self.rst.value(0) self.cs.value(1) if uname()[0] == 'WiPy': self.spi = SPI(0) self.spi.init(SPI.MASTER, baudrate=1000000, pins=(self.sck, self.mosi, self.miso)) elif uname()[0] == 'esp8266': self.spi = SPI(baudrate=100000, polarity=0, phase=0, sck=self.sck, mosi=self.mosi, miso=self.miso) self.spi.init() else: raise RuntimeError("Unsupported platform") self.rst.value(1) self.init() def _wreg(self, reg, val): self.cs.value(0) self.spi.write(b'%c' % int(0xff & ((reg << 1) & 0x7e))) self.spi.write(b'%c' % int(0xff & val)) self.cs.value(1) def _rreg(self, reg): self.cs.value(0) self.spi.write(b'%c' % int(0xff & (((reg << 1) & 0x7e) | 0x80))) val = self.spi.read(1) self.cs.value(1) return val[0] def _sflags(self, reg, mask): self._wreg(reg, self._rreg(reg) | mask) def _cflags(self, reg, mask): self._wreg(reg, self._rreg(reg) & (~mask)) def _tocard(self, cmd, send): recv = [] bits = irq_en = wait_irq = n = 0 stat = self.ERR if cmd == 0x0E: irq_en = 0x12 wait_irq = 0x10 elif cmd == 0x0C: irq_en = 0x77 wait_irq = 0x30 self._wreg(0x02, irq_en | 0x80) self._cflags(0x04, 0x80) self._sflags(0x0A, 0x80) self._wreg(0x01, 0x00) for c in send: self._wreg(0x09, c) self._wreg(0x01, cmd) if cmd == 0x0C: self._sflags(0x0D, 0x80) i = 2000 while True: n = self._rreg(0x04) i -= 1 if ~((i != 0) and ~(n & 0x01) and ~(n & wait_irq)): break self._cflags(0x0D, 0x80) if i: if (self._rreg(0x06) & 0x1B) == 0x00: stat = self.OK if n & irq_en & 0x01: stat = self.NOTAGERR elif cmd == 0x0C: n = self._rreg(0x0A) lbits = self._rreg(0x0C) & 0x07 if lbits != 0: bits = (n - 1) * 8 + lbits else: bits = n * 8 if n == 0: n = 1 elif n > 16: n = 16 for _ in range(n): recv.append(self._rreg(0x09)) else: stat = self.ERR return stat, recv, bits def _crc(self, data): self._cflags(0x05, 0x04) self._sflags(0x0A, 0x80) for c in data: self._wreg(0x09, c) self._wreg(0x01, 0x03) i = 0xFF while True: n = self._rreg(0x05) i -= 1 if not ((i != 0) and not (n & 0x04)): break return [self._rreg(0x22), self._rreg(0x21)] def init(self): self.reset() self._wreg(0x2A, 0x8D) self._wreg(0x2B, 0x3E) self._wreg(0x2D, 30) self._wreg(0x2C, 0) self._wreg(0x15, 0x40) self._wreg(0x11, 0x3D) self.antenna_on() def reset(self): self._wreg(0x01, 0x0F) def antenna_on(self, on=True): if on and ~(self._rreg(0x14) & 0x03): self._sflags(0x14, 0x03) else: self._cflags(0x14, 0x03) def request(self, mode): self._wreg(0x0D, 0x07) (stat, recv, bits) = self._tocard(0x0C, [mode]) if (stat != self.OK) | (bits != 0x10): stat = self.ERR return stat, bits def anticoll(self): ser_chk = 0 ser = [0x93, 0x20] self._wreg(0x0D, 0x00) (stat, recv, bits) = self._tocard(0x0C, ser) if stat == self.OK: if len(recv) == 5: for i in range(4): ser_chk = ser_chk ^ recv[i] if ser_chk != recv[4]: stat = self.ERR else: stat = self.ERR return stat, recv def select_tag(self, ser): buf = [0x93, 0x70] + ser[:5] buf += self._crc(buf) (stat, recv, bits) = self._tocard(0x0C, buf) return self.OK if (stat == self.OK) and (bits == 0x18) else self.ERR def auth(self, mode, addr, sect, ser): return self._tocard(0x0E, [mode, addr] + sect + ser[:4])[0] def stop_crypto1(self): self._cflags(0x08, 0x08) def read(self, addr): data = [0x30, addr] data += self._crc(data) (stat, recv, _) = self._tocard(0x0C, data) return recv if stat == self.OK else None def write(self, addr, data): buf = [0xA0, addr] buf += self._crc(buf) (stat, recv, bits) = self._tocard(0x0C, buf) if not (stat == self.OK) or not (bits == 4) or not ( (recv[0] & 0x0F) == 0x0A): stat = self.ERR else: buf = [] for i in range(16): buf.append(data[i]) buf += self._crc(buf) (stat, recv, bits) = self._tocard(0x0C, buf) if not (stat == self.OK) or not (bits == 4) or not ( (recv[0] & 0x0F) == 0x0A): stat = self.ERR return stat
class HX711(object): """ Micropython driver for Avia Semiconductor's HX711 24-Bit Analog-to-Digital Converter """ CHANNEL_A_128 = const(1) CHANNEL_A_64 = const(3) CHANNEL_B_32 = const(2) DATA_BITS = const(24) MAX_VALUE = const(0x7fffff) MIN_VALUE = const(0x800000) READY_TIMEOUT_SEC = const(1) SLEEP_DELAY_USEC = const(80) def __init__(self, d_out, pd_sck, channel: int = CHANNEL_A_128): self.d_out_pin = Pin(d_out, Pin.IN) self.pd_sck_pin = Pin(pd_sck, Pin.OUT, value=0) self.channel = channel def __repr__(self): return "HX711 on channel %s, gain=%s" % self.channel def _convert_from_twos_complement(self, value: int) -> int: """ Converts a given integer from the two's complement format. """ if value & (1 << (self.DATA_BITS - 1)): value -= 1 << self.DATA_BITS return value def _set_channel(self): """ Input and gain selection is controlled by the number of the input PD_SCK pulses 3 pulses for Channel A with gain 64 2 pulses for Channel B with gain 32 1 pulse for Channel A with gain 128 """ for i in range(self._channel): self.pd_sck_pin.value(1) self.pd_sck_pin.value(0) def _wait(self): """ If the HX711 is not ready within READY_TIMEOUT_SEC the DeviceIsNotReady exception will be thrown. """ t0 = time() while not self.is_ready(): if time() - t0 > self.READY_TIMEOUT_SEC: raise Exception("DeviceIsNotReady") @property def channel(self) -> tuple: """ Get current input channel in a form of a tuple (Channel, Gain) """ if self._channel == self.CHANNEL_A_128: return 'A', 128 if self._channel == self.CHANNEL_A_64: return 'A', 64 if self._channel == self.CHANNEL_B_32: return 'B', 32 @channel.setter def channel(self, value): """ Set input channel HX711.CHANNEL_A_128 - Channel A with gain 128 HX711.CHANNEL_A_64 - Channel A with gain 64 HX711.CHANNEL_B_32 - Channel B with gain 32 """ if value not in (self.CHANNEL_A_128, self.CHANNEL_A_64, self.CHANNEL_B_32): raise Exception('Gain should be one of HX711.CHANNEL_A_128, HX711.CHANNEL_A_64, HX711.CHANNEL_B_32') else: self._channel = value if not self.is_ready(): self._wait() for i in range(self.DATA_BITS): self.pd_sck_pin.value(1) self.pd_sck_pin.value(0) self._set_channel() def is_ready(self) -> bool: """ When output data is not ready for retrieval, digital output pin DOUT is high. """ return self.d_out_pin.value() == 0 def power_off(self): """ When PD_SCK pin changes from low to high and stays at high for longer than 60 us , HX711 enters power down mode. """ self.pd_sck_pin.value(0) self.pd_sck_pin.value(1) sleep_us(self.SLEEP_DELAY_USEC) def power_on(self): """ When PD_SCK returns to low, HX711 will reset and enter normal operation mode. """ self.pd_sck_pin.value(0) self.channel = self._channel def read(self, raw=False): """ Read current value for current channel with current gain. if raw is True, the HX711 output will not be converted from two's complement format. """ if not self.is_ready(): self._wait() raw_data = 0 for i in range(self.DATA_BITS): self.pd_sck_pin.value(1) self.pd_sck_pin.value(0) raw_data = raw_data << 1 | self.d_out_pin.value() self._set_channel() if raw: return raw_data else: return self._convert_from_twos_complement(raw_data)
async def killer(): #未引出的脚,测试 pin = Pin(17, Pin.IN, Pin.PULL_UP) while pin.value(): await asyncio.sleep_ms(50)
<p>GPIO state: <strong>""" + gpio_state + """</strong></p><p><a href="/?led=on"><button class="button">ON</button></a></p> <p><a href="/?led=off"><button class="button button2">OFF</button></a></p></body></html>""" return html #socket ile dinleme yapmak için s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(('', 80)) s.listen(5) while True: conn, addr = s.accept( ) #response ve request yapılan bildirim aynı zamanda yapılan ip bildirimi print('Got a connection from %s' % str(addr)) #yapılan request göster request = conn.recv(1024) # request request = str(request) print('Content = %s' % request) #request i göster led_on = request.find('/?led=on') # yapılan request i dinle led_off = request.find('/?led=off') if led_on == 6: print('LED ON') led.value(1) if led_off == 6: print('LED OFF') led.value(0) response = web_page() #wb sayfasını return et conn.send('HTTP/1.1 200 OK\n') conn.send('Content-Type: text/html\n') conn.send('Connection: close\n\n') conn.sendall(response) #burada da bir return verimizi conn.close() #burada socket bağlantısını kapatıyoruz
class Hardware(BaseHardware): def __init__(self, config) : pin_a = Pin(BUTTON_A_PIN, mode=Pin.IN, pull=None) pin_b = Pin(BUTTON_B_PIN, mode=Pin.IN, pull=None) pin_c = Pin(BUTTON_C_PIN, mode=Pin.IN, pull=None) self.buttonA = Button(pin=pin_a) self.buttonB = Button(pin=pin_b) self.buttonC = Button(pin=pin_c) self.buttonA.press_func(self.button_A_callback, (pin_a,)) # Note how function and args are passed self.buttonB.press_func(self.button_B_callback, (pin_b,)) # Note how function and args are passed self.buttonC.press_func(self.button_C_callback, (pin_c,)) # Note how function and args are passed # display self.display = None self.screen_power = None self.header_font = None self.large_label_font = None self.small_label_font = None self.setup_screen() # screen saver # 0 - disable # x - screen saver activation in second self.screensaver = 0 self.currentcount = 0 if "screensaver" in config: self.screensaver = int(config["screensaver"]) self.currentcount = int(config["screensaver"]) self.screen_timeout_lock = Lock() # wifi super().__init__(config) def get_ble_handle(self): return self.ble_handle def set_callback(self, button, cb): if button == BUTTON_A_PIN: self.buttonA = Button(pin=Pin(BUTTON_A_PIN, mode=Pin.IN, pull=None), callback=cb, trigger=Pin.IRQ_FALLING) def button_A_callback(self, pin): print("Button (%s) changed to: %r" % (pin, pin.value())) if pin.value() == 0 : #device = self.device_req_handler["studyrmfan"] # handle the request topic = self.tranport_handler.topicprefix + 'cmnd/studyrmfan/press' self.tranport_handler.publish(topic, 'on') # rest the screen saver self.tranport_handler.loop.create_task(self.reset_screen_saver()) def button_B_callback(self, pin): print("Button (%s) changed to: %r" % (pin, pin.value())) if pin.value() == 0 : # handle the request topic = self.tranport_handler.topicprefix + 'cmnd/studyrmtemp/getstatus' self.tranport_handler.publish(topic, 'on') # rest the screen saver self.tranport_handler.loop.create_task(self.reset_screen_saver()) def button_C_callback(self, pin): print("Button (%s) changed to: %r" % (pin, pin.value())) if pin.value() == 0 : #device = self.device_req_handler["waterheater"] # handle the request topic = self.tranport_handler.topicprefix + 'cmnd/waterheater/press' self.tranport_handler.publish(topic, 'on') # rest the screen saver self.tranport_handler.loop.create_task(self.reset_screen_saver()) def clear_dashboard(self): ''' Clear the dashboard area ''' self.display.fill_rectangle(70, 80, 200, 100, color565(0,0,0)) def setup_screen(self): self.screen_power = Pin(m5stack.TFT_LED_PIN, Pin.OUT) self.screen_power.value(1) spi = SPI( 2, baudrate=40000000, miso=Pin(m5stack.TFT_MISO_PIN), mosi=Pin(m5stack.TFT_MOSI_PIN), sck=Pin(m5stack.TFT_CLK_PIN)) #display = Display(spi, dc=Pin(4), cs=Pin(16), rst=Pin(17)) self.display = Display( spi, cs=Pin(m5stack.TFT_CS_PIN), dc=Pin(m5stack.TFT_DC_PIN), rst=Pin(m5stack.TFT_RST_PIN), width=320, height=240, rotation=0) self.display.clear() self.header_font = XglcdFont('/screen/m5stack/fonts/Unispace12x24.c', 12, 24) self.large_label_font = XglcdFont('/screen/m5stack/fonts/IBMPlexMono12x24.c', 12, 24) self.small_label_font = XglcdFont('/screen/m5stack/fonts/ArcadePix9x11.c', 9, 11) self.display.draw_text(0, 0, 'Loading...', self.large_label_font, color565(0, 0, 0), background=color565(255, 255, 255)) def show_setupcomplete(self): self.home_page() self.display.draw_text(70, 80, 'Waiting For', self.large_label_font, color565(255, 255, 255), background=color565(0, 0, 0)) self.display.draw_text(70, 100, 'Messages', self.large_label_font, color565(255, 255, 255), background=color565(0, 0, 0)) #activate the screen saver self.tranport_handler.loop.create_task(self.screen_saver_countdown()) def home_page(self): self.display.clear() self.display.draw_image('/images/blecanvas.raw',0,0,320,240) #self.display.draw_text(45, 203, 'Fan', self.large_label_font, color565(0, 0, 0), background=color565(255, 255, 255)) #self.display.draw_text(135, 203, 'Temp', self.large_label_font, color565(0, 0, 0), background=color565(255, 255, 255)) #self.display.draw_text(225, 203, 'Heater', self.large_label_font, color565(0, 0, 0), background=color565(255, 255, 255)) self.screen_power.value(1) def display_result(self, text): print("Display Result") self.clear_dashboard() self.display.draw_text(70, 80, text["line1"], self.large_label_font, color565(255, 255, 255)) self.display.draw_text(70, 100, text["line2"], self.large_label_font, color565(255, 255, 255)) self.display.draw_text(70, 120, text["line3"], self.large_label_font, color565(255, 255, 255)) def screen_off(self): self.screen_power.value(0) def screen_on(self): self.screen_power.value(1) async def reset_screen_saver(self): ''' Reset the screen Saver timeout to ''' await self.screen_timeout_lock.acquire() self.currentcount = self.screensaver self.screen_timeout_lock.release() self.screen_on() async def screen_saver_countdown(self): while True: await self.screen_timeout_lock.acquire() if self.currentcount > 0: self.currentcount -= 1 if self.currentcount == 0 : self.screen_off() self.screen_timeout_lock.release() await asyncio.sleep(1) #a=Hardware() #a.show_setupcomplete
# - Joshua Vaughan # - [email protected] # - http://www.ucs.louisiana.edu/~jev9637 # # Modified: # * # ############################################################################### import webrepl import time from machine import Pin # Create a pin object for the esp8266 onboard LED pin = Pin(2, Pin.OUT) pin.value(1) # Turn the LED off to start WIFI_SSID = "WIFISSID" WIFI_PASSWORD = "******" # Set to true to connect to the WIFI network identified by the parameters above # We'll leave the access point open too, for easy debugging/programming CONNECT_AS_STATION = True def do_connect(): import network sta_if = network.WLAN(network.STA_IF) if not sta_if.isconnected(): print('Connecting to network...') sta_if.active(True) sta_if.connect(WIFI_SSID, WIFI_PASSWORD)
class ShiftRegister: def __init__(self, serial, oe, register_clock, serial_clock, serial_clear): self.serial = Pin(serial, Pin.OUT, Pin.PULL_DOWN, value=0) self.oe = Pin(oe, Pin.OUT, Pin.PULL_UP, value=1) self.register_clock = Pin(register_clock, Pin.OUT, Pin.PULL_DOWN, value=0) self.serial_clock = Pin(serial_clock, Pin.OUT, Pin.PULL_DOWN, value=0) self.serial_clear = Pin(serial_clear, Pin.OUT, Pin.PULL_UP, value=1) def clear(self): self.serial_clear.value(0) self.register_clock.value(1) self.register_clock.value(0) self.serial_clear.value(1) def enable(self): self.clear() self.oe.value(0) def disable(self): self.oe.value(1) def write_bits(self, bits): self.clear() self.oe.value(1) for bit in bits: self.serial.value(bit) self.serial_clock.value(1) self.serial_clock.value(0) self.register_clock.value(1) self.register_clock.value(0) self.oe.value(0) def write_int(self, integer, le=False): bits = [int(bit) for bit in "{:08b}".format(integer)] if le: bits = bits[::-1] self.write_bits(bits)
class _TB6612FNG_channel(object): _pwm_id = 0 _pwm = PWM(0, frequency=5000) @classmethod def id(cls): if cls._pwm_id > 7: raise Exception("Cannot create more pwm channels") temp = cls._pwm_id cls._pwm_id += 1 return temp 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 clockwise(self): self.pin_1.value(1) self.pin_2.value(0) def anticlockwise(self): self.pin_1.value(0) self.pin_2.value(1) def short_break(self): self.pin_1.value(1) self.pin_2.value(1) def freewheel(self): self.pin_1.value(0) self.pin_2.value(0) def duty_cycle(self, *args, **kwargs): return self.pwm.duty_cycle(*args, **kwargs)
#hardware platform: FireBeetle-ESP32 from machine import IIS from machine import Pin import time recorder = IIS(IIS.RECORDER) #create a iis object button = Pin(16, Pin.IN) def mycb(path): print("callback : record "+path + " is done ") recorder.init() #init recorder recorder.set_nchannels(2) #set channel recorder.set_sampwidth(16) #set Sample width recorder.set_framerate(16000) #set framerate recorder.record('/sd//dir1///dir2/hidfrobot.wav') #set wav will be played recorder.set_endcallback(mycb) #set callback #Catch exceptions,stop recorder if interrupted accidentally try: while True: if button.value() == 0: recorder.stop() elif recorder.get_busy() == False: #if recorder not play,stop recorder print("record finished") break except: recorder.stop()
def mqttMsg(topic, msg): ''' ontvang de mqtt berichten en zet LED1 aan of uit ''' msg = msg.decode("UTF-8") pLed1.value(int(msg)) return # constanten #BROKER = "192.168.1.22" #IP Broker BROKER = "172.24.0.100" #IP Broker ID = "esp_frank_1604" #moet uniek zijn voor je netwerk TOPIC1 = "sched/frank1604/LED1" # led1 initialiseren pLed1 = Pin(32, Pin.OUT) pLed1.value(0) # wifi initialiseren mqttCl = None myWifi = simpleWifi.Wifi() if not (myWifi.open()): myWifi.get_status() sys.exit() myWifi.get_status() try: # mqtt client aanmaken mqttCl = MQTTClient(ID, BROKER) # callback functie instellen voor ontvangen berichten mqttCl.set_callback(mqttMsg)
#Potentiometer board v1.0p test code from machine import Pin from pyb import CAN, ADC import utime print("initializing") can = CAN(1, CAN.NORMAL) can.setfilter(0, CAN.LIST16, 0, (123, 124, 125, 126)) #Setup Pins hbt_led = Pin("D5", Pin.OUT) func_butt = Pin("E7", Pin.IN, Pin.PULL_UP) can_wakeup = Pin("D6", Pin.OUT) can_wakeup.value(0) a_button = Pin("E13", Pin.IN, Pin.PULL_UP) b_button = Pin("E12", Pin.IN, Pin.PULL_UP) a_pot = ADC("A1") b_pot = ADC("A0") column_a = Pin("E4", Pin.OUT, Pin.PULL_DOWN) column_b = Pin("E3", Pin.OUT, Pin.PULL_DOWN) column_a.value( 1 ) #When the column is HIGH the column is OFF, write them to OFF on initialization column_b.value(1) row_0 = Pin("D0", Pin.OUT) row_1 = Pin("D1", Pin.OUT) row_2 = Pin("E2", Pin.OUT)
def test_noinit(): for p in pin_map: pin = Pin(p) pin.value()
class ShiftRegister: #need to know what pins we're using #On DIP 595 - pins 12, 11 an 14 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) def shiftOut(self, data, latch=True): # print(data) for bit in range(8): print(bit) if 0 == (data & (1<<bit)): self._dataPin.value(0) print("low") else: self._dataPin.value(1) print("high") self._clockPin.value(0) time.sleep_us(1) self._clockPin.value(1) time.sleep_us(10) if(latch): self._latchPin.value(0) time.sleep_us(1) self._latchPin.value(1) time.sleep_us(1)
nvic_set_prio(-1, 1) nvic_set_prio(25, 0) # probably want to enable-preload (ARR, CCR1, etc), then load next set of values, then CEN # because after n-pulses, UEV fires... # then in a UEV interrupt (??) we can load the next set of values via DMA/memory, and re-CEN (unless there are no more data from DMA/memory) #import dump_regs #dump_regs.dump_regs() # make sure PA0 PA1, PA2 are output LO state timers_init() YEL_LED.value(1) EN_18V_ONBOARD.value(1) #EN_18V_U4.value(0) pyb.delay(900) YEL_LED.value(0) EN_18V_ONBOARD.value(0) #EN_18V_U4.value(1) pyb.delay(2000) YEL_LED.value(1) #EN_18V_U4.value(0)
class HX711: def __init__(self, dout, pd_sck, gain=128): self.pSCK = Pin(pd_sck , mode=Pin.OUT) self.pOUT = Pin(dout, mode=Pin.IN, pull=Pin.PULL_DOWN) self.pSCK.value(False) self.GAIN = 0 self.OFFSET = 0 self.SCALE = 1 self.time_constant = 0.1 self.filtered = 0 self.set_gain(gain) def set_gain(self, gain): if gain is 128: self.GAIN = 1 elif gain is 64: self.GAIN = 3 elif gain is 32: self.GAIN = 2 self.read() self.filtered = self.read() print('Gain & initial value set') def is_ready(self): return self.pOUT() == 0 def read(self): # wait for the device being ready while self.pOUT() == 1: idle() # shift in data, and gain & channel info result = 0 for j in range(24 + self.GAIN): state = disable_irq() self.pSCK(True) self.pSCK(False) enable_irq(state) result = (result << 1) | self.pOUT() # shift back the extra bits result >>= self.GAIN # check sign if result > 0x7fffff: result -= 0x1000000 return result def read_average(self, times=3): sum = 0 for i in range(times): sum += self.read() return sum / times def read_lowpass(self): self.filtered += self.time_constant * (self.read() - self.filtered) return self.filtered def get_value(self, times=3): return self.read_average(times) - self.OFFSET def get_units(self, times=3): return self.get_value(times) / self.SCALE def tare(self, times=15): sum = self.read_average(times) self.set_offset(sum) def set_scale(self, scale): self.SCALE = scale def set_offset(self, offset): self.OFFSET = offset def set_time_constant(self, time_constant = None): if time_constant is None: return self.time_constant elif 0 < time_constant < 1.0: self.time_constant = time_constant def power_down(self): self.pSCK.value(False) self.pSCK.value(True) def power_up(self): self.pSCK.value(False)
i2c.writeto(0x3c, bytes((0x80, 0x81, 0x80, contrast))) except OSError as e: print(e) def oledinvert(invert=True): if buffer is not None: try: i2c.writeto(0x3c, bytes((0x80, 0xa6 | (invert & 1)))) except OSError as e: print(e) # Initialize OLED screen if it is there rst = Pin(16, Pin.OUT) rst.value(1) if 0x3c in i2c.scan(): # There is an extra byte to the data buffer to hold an I2C data/command byte # to use hardware-compatible I2C transactions. buffer = bytearray(((64 // 8) * 128) + 1) buffer[0] = 0x40 # Set first byte of data buffer to Co=0, D/C=1 fbuff = framebuf.FrameBuffer1(memoryview(buffer)[1:], 128, 64) cmdforinit = bytes(( 0xae, # CMD_DISP=off 0x20, 0x00, # SET_MEM_ADDR horizontal 0x40, # SET_DISP_START_LINE 0xa0 | 0x01, # column addr 127 mapped to SEG0 0xa8,
def toggle(pin: Pin) -> None: pin.value(not pin.value())
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ from machine import Pin, SPI from time import sleep_ms # UEXT wiring on the Pyboard. # https://github.com/mchobby/pyboard-driver/tree/master/UEXT spi = SPI(2) # MOSI=Y8, MISO=Y7, SCK=Y6, SS=Y5 spi.init( baudrate=5000000, phase=0, polarity=0 ) # We must manage the SS signal ourself ss = Pin( Pin.board.Y5, Pin.OUT ) # Start a new SPI transaction ss.value( 1 ) sleep_ms( 10 ) ss.value( 0 ) print( "Write a A on the screen" ) spi.send( bytes([0x80,0x00,0x41]) ) sleep_ms( 500 ) # Now, read back the memory # Start a new SPI transaction ss.value( 1 ) sleep_ms( 10 ) ss.value( 0 ) spi.send( bytes([0x00,0x00]) )
button_red = Pin(25, Pin.IN, Pin.PULL_DOWN) button_green = Pin(26, Pin.IN, Pin.PULL_DOWN) #Touchpad tpin = TouchPad(Pin(27)) tpin_green = TouchPad(Pin(33)) # configure the threshold at which the pin is considered touched tpin.config(500) esp32.wake_on_touch(True) #External button wake-up esp32.wake_on_ext1(pins = (button_red, button_green), level = esp32.WAKEUP_ANY_HIGH) #Red led turns on red.value(1) #Hardware timer - 2 tim2 = Timer(2) tim2.init(period=10, mode=Timer.PERIODIC, callback=handletouch) # #Hardware timer - 3 tim3 = Timer(3) tim3.init(period=30000, mode=Timer.PERIODIC, callback=handlesleep) # check if the device woke from a deep sleep if machine.wake_reason() == 5: print('Touchpad Wake-up') elif machine.wake_reason() == 3: print('EXT1 Wake-up') elif machine.wake_reason() == 4:
class MFRC522: RESET = 'GP22' CLK = 'GP14' MISO = 'GP15' MOSI = 'GP16' CS = 'GP17' MAX_LEN = 16 PCD_IDLE = 0x00 PCD_AUTHENT = 0x0E PCD_TRANSCEIVE = 0x0C PCD_RESETPHASE = 0x0F PCD_CALCCRC = 0x03 PICC_REQIDL = 0x26 PICC_REQALL = 0x52 PICC_ANTICOLL = 0x93 PICC_SElECTTAG = 0x93 PICC_AUTHENT1A = 0x60 PICC_READ = 0x30 PICC_WRITE = 0xA0 MI_OK = 0 MI_NOTAGERR = 1 MI_ERR = 2 MI_AUTH_ERROR_STATUS2REG = 3 CommandReg = 0x01 CommIEnReg = 0x02 CommIrqReg = 0x04 DivIrqReg = 0x05 ErrorReg = 0x06 Status2Reg = 0x08 FIFODataReg = 0x09 FIFOLevelReg = 0x0A WaterLevelReg = 0x0B ControlReg = 0x0C BitFramingReg = 0x0D ModeReg = 0x11 TxControlReg = 0x14 TxAutoReg = 0x15 CRCResultRegM = 0x21 CRCResultRegL = 0x22 TModeReg = 0x2A TPrescalerReg = 0x2B TReloadRegH = 0x2C TReloadRegL = 0x2D serNum = [] def __init__(self, spd=1000000): # first assign CLK, MISO, MOSI, CS to the correct pins self.pin_clk = Pin(self.CLK, mode=Pin.OUT) # CLK self.pin_miso = Pin(self.MISO) # MISO self.pin_mosi = Pin(self.MOSI, mode=Pin.OUT) # MOSI self.pin_cs = Pin(self.CS, mode=Pin.OUT) # NSS/CS self.pin_reset = Pin(self.RESET, mode=Pin.OUT) self.pin_reset.value(0) self.pin_cs.value(1) self.spi = SPI(0) self.spi.init(mode=SPI.MASTER, baudrate=spd, pins=(self.CLK, self.MOSI, self.MISO)) self.pin_reset.value(1) self.MFRC522_Init() def MFRC522_Reset(self): self.Write_MFRC522(self.CommandReg, self.PCD_RESETPHASE) def Write_MFRC522(self, addr, val): self.pin_cs.value(0) # 0(MSB = Write) ADDR1 ADDR2 ADDR3 ADDR4 ADDR5 ADDR6 0(LSB = 0) DATA spiBytes = bytearray(2) spiBytes[0] = ((addr<<1)&0x7E) spiBytes[1] = val self.spi.write(spiBytes) self.pin_cs.value(1) def Read_MFRC522(self, addr): self.pin_cs.value(0) # 1(MSB = Read) ADDR1 ADDR2 ADDR3 ADDR4 ADDR5 ADDR6 0(LSB = 0) self.spi.write((addr<<1)&0x7E|0x80) data = self.spi.read(1) self.pin_cs.value(1) return data[0] def SetBitMask(self, reg, mask): tmp = self.Read_MFRC522(reg) self.Write_MFRC522(reg, tmp | mask) def ClearBitMask(self, reg, mask): tmp = self.Read_MFRC522(reg); self.Write_MFRC522(reg, tmp & (~mask)) def AntennaOn(self): temp = self.Read_MFRC522(self.TxControlReg) if(~(temp & 0x03)): self.SetBitMask(self.TxControlReg, 0x03) def AntennaOff(self): self.ClearBitMask(self.TxControlReg, 0x03) def MFRC522_ToCard(self,command,sendData): backData = [] backLen = 0 status = self.MI_ERR irqEn = 0x00 waitIRq = 0x00 lastBits = None n = 0 i = 0 if command == self.PCD_AUTHENT: irqEn = 0x12 waitIRq = 0x10 if command == self.PCD_TRANSCEIVE: irqEn = 0x77 waitIRq = 0x30 self.Write_MFRC522(self.CommIEnReg, irqEn|0x80) self.ClearBitMask(self.CommIrqReg, 0x80) self.SetBitMask(self.FIFOLevelReg, 0x80) self.Write_MFRC522(self.CommandReg, self.PCD_IDLE); while(i<len(sendData)): self.Write_MFRC522(self.FIFODataReg, sendData[i]) i = i+1 self.Write_MFRC522(self.CommandReg, command) if command == self.PCD_TRANSCEIVE: self.SetBitMask(self.BitFramingReg, 0x80) i = 2000 while True: n = self.Read_MFRC522(self.CommIrqReg) i = i - 1 if ~((i!=0) and ~(n&0x01) and ~(n&waitIRq)): break self.ClearBitMask(self.BitFramingReg, 0x80) if i != 0: st = self.Read_MFRC522(self.ErrorReg) if (st & 0x1B)==0x00: status = self.MI_OK if n & irqEn & 0x01: status = self.MI_NOTAGERR elif command == self.PCD_TRANSCEIVE: n = self.Read_MFRC522(self.FIFOLevelReg) lastBits = self.Read_MFRC522(self.ControlReg) & 0x07 if lastBits != 0: backLen = (n-1)*8 + lastBits else: backLen = n*8 if n == 0: n = 1 if n > self.MAX_LEN: n = self.MAX_LEN i = 0 while i<n: backData.append(self.Read_MFRC522(self.FIFODataReg)) i = i + 1; else: status = self.MI_ERR return (status,backData,backLen) def MFRC522_Request(self, reqMode): status = None backBits = None TagType = [reqMode] self.Write_MFRC522(self.BitFramingReg, 0x07) (status,backData,backBits) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, TagType) if ((status != self.MI_OK) | (backBits != 0x10)): status = self.MI_ERR return (status,backBits) def MFRC522_Anticoll(self): backData = [] serNumCheck = 0 serNum = [self.PICC_ANTICOLL, 0x20] self.Write_MFRC522(self.BitFramingReg, 0x00) (status,backData,backBits) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE,serNum) if(status == self.MI_OK): i = 0 if len(backData)==5: while i<4: serNumCheck = serNumCheck ^ backData[i] i = i + 1 if serNumCheck != backData[i]: status = self.MI_ERR else: status = self.MI_ERR return (status,backData) def CalulateCRC(self, pIndata): self.ClearBitMask(self.DivIrqReg, 0x04) self.SetBitMask(self.FIFOLevelReg, 0x80); i = 0 while i<len(pIndata): self.Write_MFRC522(self.FIFODataReg, pIndata[i]) i = i + 1 self.Write_MFRC522(self.CommandReg, self.PCD_CALCCRC) i = 0xFF while True: n = self.Read_MFRC522(self.DivIrqReg) i = i - 1 if not ((i != 0) and not (n&0x04)): break pOutData = [] pOutData.append(self.Read_MFRC522(self.CRCResultRegL)) pOutData.append(self.Read_MFRC522(self.CRCResultRegM)) return pOutData def MFRC522_SelectTag(self, serNum): backData = [] buf = [self.PICC_SElECTTAG, 0x70] + serNum[:5] buf += self.CalulateCRC(buf) (status, backData, backLen) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, buf) if (status == self.MI_OK) and (backLen == 0x18): return self.MI_OK else: return self.MI_ERR def MFRC522_Auth(self, authMode, BlockAddr, Sectorkey, serNum): #First byte should be the authMode (A or B) #Second byte is the trailerBlock (usually 7) #Now we need to append the authKey which usually is 6 bytes of 0xFF #Next we append the first 4 bytes of the UID buff = [authMode, BlockAddr] + Sectorkey + serNum[:4] # Now we start the authentication itself (status, backData, backLen) = self.MFRC522_ToCard(self.PCD_AUTHENT,buff) # Check if an error occurred # Return the status return status def MFRC522_StopCrypto1(self): self.ClearBitMask(self.Status2Reg, 0x08) def MFRC522_Read(self, blockAddr): recvData = [self.PICC_READ, blockAddr] recvData += self.CalulateCRC(recvData) (status, backData, backLen) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, recvData) return (status, backData) def MFRC522_Write(self, blockAddr, writeData): buff = [self.PICC_WRITE, blockAddr] buff += self.CalulateCRC(buff) (status, backData, backLen) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, buff) if not(status == self.MI_OK) or not(backLen == 4) or not((backData[0] & 0x0F) == 0x0A): status = self.MI_ERR if status == self.MI_OK: i = 0 buf = [] while i < 16: buf.append(writeData[i]) i = i + 1 buf += self.CalulateCRC(buf) (status, backData, backLen) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE,buf) if not(status == self.MI_OK) or not(backLen == 4) or not((backData[0] & 0x0F) == 0x0A): status = self.MI_ERR return status def MFRC522_Init(self): self.MFRC522_Reset(); self.Write_MFRC522(self.TModeReg, 0x8D) self.Write_MFRC522(self.TPrescalerReg, 0x3E) self.Write_MFRC522(self.TReloadRegL, 30) self.Write_MFRC522(self.TReloadRegH, 0) self.Write_MFRC522(self.TxAutoReg, 0x40) self.Write_MFRC522(self.ModeReg, 0x3D) self.AntennaOn()
from machine import Pin, PWM import mfrc522, time rfid = mfrc522.MFRC522(0, 2, 4, 5, 14) led = Pin(15, Pin.OUT) while True: led.value(0) #搜尋卡片之前先關閉LED stat, tag_type = rfid.request(rfid.REQIDL) #搜尋RFID卡片 if stat == rfid.OK: #找到卡片 stat, raw_uid = rfid.anticoll() #讀取RFID卡號 if stat == rfid.OK: led.value(1) #讀到卡號後點亮LED #將卡號由2進位格式轉換為16進位的字串 id = "%02x%02x%02x%02x" % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]) print("偵測到卡號:", id) time.sleep(0.5) #暫停一下,避免LED太快熄滅看不到
try: import ssd1306 except: # OLED support won't be available pass micropython.alloc_emergency_exception_buf(100) period = 265 width = 1 number_of_pulse_pairs = 5 common_prescaler = 11 # G30 TH Pin JP32 ==> g30pulser.sch J2-12 PB8 p32_pin = Pin('JP32', Pin.OUT) p32_pin.value(0) enable_gpio_and_timers() #enable_pa0_pa1_af() # Setup ADC Timer and a callback to try printing the value #adc_vals = [-1 for i in range(number_of_pulse_pairs+1 if number_of_pulse_pairs+1 > 128 else 128)] #t4 = pyb.Timer(4, prescaler=0, period=0) #stm.mem16[stm.TIM4 + stm.TIM_CR1] &= (~1) & 0xFFFF# disable CEN #adc_timer = t4.channel(4, pyb.Timer.PWM)#OC_TIMING, polarity=pyb.Timer.HIGH) #stm.mem16[stm.TIM4 + stm.TIM_CR1] &= (~1) & 0xFFFF# disable CEN #G30TH pin JP29 ==> g30pulser.sch J2-9 PA4 adc = pyb.ADC(pyb.Pin.board.JP29) #adc_vals = array.array('I',[i for i in range((number_of_pulse_pairs*4)+1)])
# Button: ESP32: # GND Add 10kOhm --> GND + GPIO4 # VCC --> 3V3 # LED: ESP32: # GND add 330 Ohm --> GND # VCC --> GPIO5 from machine import Pin from time import sleep led = Pin(5, Pin.OUT) button = Pin(4, Pin.IN) while True: led.value(button.value()) sleep(0.1)
# This is an example on how to access accelerometer on # PyBoard directly using I2C bus. As such, it's more # intended to be an I2C example, rather than accelerometer # example. For the latter, using pyb.Accel class is # much easier. from machine import Pin from machine import I2C import time # Accelerometer needs to be powered on first. Even # though signal is called "AVDD", and there's separate # "DVDD", without AVDD, it won't event talk on I2C bus. accel_pwr = Pin("MMA_AVDD") accel_pwr.value(1) i2c = I2C(1, baudrate=100000) addrs = i2c.scan() print("Scanning devices:", [hex(x) for x in addrs]) if 0x4c not in addrs: print("Accelerometer is not detected") ACCEL_ADDR = 0x4c ACCEL_AXIS_X_REG = 0 ACCEL_MODE_REG = 7 # Now activate measurements i2c.mem_write(b"\x01", ACCEL_ADDR, ACCEL_MODE_REG) print("Try to move accelerometer and watch the values") while True:
class Juego: TIEMPO_LIMITE = 3000 # milisegundos antes de que salte el timeout def __init__(self, nombre): self.nombre = nombre self.led = Pin(2, Pin.OUT) self.led.value(1) # empiezo con el led apagado self.boton = Pin(0, Pin.IN) self.mimqtt = Mimqtt(self.registro_recibido ) # le pasamos un callback para que nos avise self.sensor = None self.basedatos = Basedatos() self.mostrar_mejores_puntuaciones( ) # al iniciar mostramos las mejores puntuacinoes guardadas (Si hay) def usar_sensor(self, sensor): """ Si le pasamos la instancia de un sensor APDS9930, lo utilizamos en vez del boton """ self.sensor = sensor def comenzar(self): """ Bucle infinito que hace toda la logica de esperar, led on, esperar por boton, led off, medir tiempo """ print() while True: print("Pulsa el boton cuando se encienda el led") self.esperar_tiempo_random() if self.check_pulsado( ): # comprueba si esta pulsado antes de que se encienda el led print( "No valido. Has pulsado antes de que se encendiera el led. ", end='') continue self.led.value(0) # enciendemos led tiempo_inicio = utime.ticks_ms( ) # guardamos tiempo nada mas encender led valido = self.esperar_pulsacion( ) # espera por boton o sensor, y devuelve si fue valido o timeout self.led.value(1) # apagamos led if not valido: print("Has tardado demasiado. Intentalo otra vez. ", end='') continue tiempo_fin = utime.ticks_ms( ) # guardamos tiempo justo al presionar el boton tiempo_total = utime.ticks_diff( tiempo_fin, tiempo_inicio) # tiempo reaccion fin-inicio print("has apagado el led en {}ms".format(tiempo_total)) self.mimqtt.enviar(self.nombre, tiempo_total) utime.sleep_ms(100) def check_pulsado(self): """ Comprueba si el dispositivo de entrada (boton o sensor) esta pulsado/activado """ if self.sensor is None: return self.check_boton( ) # si sensor es None comprobamos boton de la placa else: return self.check_sensor() # sino comprobamos sensor def esperar_pulsacion(self): """ Espera que el dispositivo de entrada (boton o sensor) se active, o salte el timeout """ tiempo_inicio = utime.ticks_ms() while not self.check_pulsado( ): # bucle mientra no se pulse el boton o sensor utime.sleep_ms(1) if utime.ticks_diff(utime.ticks_ms(), tiempo_inicio) > Juego.TIEMPO_LIMITE: return False # con False indicamos que salto el timeout return True # con True indicamos que fue una pulsacion valida def check_sensor(self): """ Devuelve True si el sensor de proximidad esta activado """ return self.sensor.get_proximidad( ) > 0 # si nos devuelve un valor mayor que cero es que esta activado # y evalua como True, por lo que devuelve True. Si es cero evalua y devuelve False def check_boton(self): """ Devuelve True si el boton de la placa esta presionado """ return self.boton.value( ) == 0 # el boton funciona con logica negativa, es igual a cero cuando se pulsa def registro_recibido(self, nombre, tiempo): """ callback que salta desde mimqtt, cuando hay un nuevo registro valido """ print("registro de '{}' tiempo {}ms".format(nombre, tiempo)) # se lo pasamos a nuestra base de datos para que lo guarde si procede (nuevo o record) self.basedatos.nuevo_registro(nombre, tiempo) def mostrar_mejores_puntuaciones(self): """ Muestra por consola las 3 mejores puntuaciones guardadas en la base de datos """ mejores_puntuaciones = self.basedatos.get_mejores_puntuaciones() if not mejores_puntuaciones: # si es una lista vacia no hacemos nada return print( "\nMejores puntuaciones historicas\n===============================" ) posiciones = ("Primero", "Segundo", "Tercero") for indice, tupla_nombre_tiempo in enumerate( mejores_puntuaciones ): # es una lista de maximo 3 tuplas con (nombre, tiempo) print("{} - {} con {}ms".format(posiciones[indice], tupla_nombre_tiempo[0].decode(), int(tupla_nombre_tiempo[1]))) def finalizar(self): """ Detiene todo lo que esta en marcha """ self.mimqtt.disconnect( ) # cancela timer de comprobar mensajes y desconecta cliente self.basedatos.close() # cierra todo lo relaccionado con la db @staticmethod def esperar_tiempo_random(): tiempo_random = urandom.getrandbits( 12) # valor de 12 bits -> entre 0 y 4095 utime.sleep_ms(tiempo_random + 3000) # valor entre 3000 y 7095
class PowerUp3: 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 read_stick_x(self): return self.x_adc.value() def button_speed_up(self): return not bool(self.btn_speed_up.value()) def button_speed_down(self): return not bool(self.btn_speed_down.value()) def button_speed_full(self): return not bool(self.btn_speed_full.value()) def button_speed_off(self): return not bool(self.btn_speed_off.value()) def calibrate(self): self.x_mid = self.read_stick_x() def __str__(self): return "calibration x: %i, y: %i" % (self.x_mid) def map_chars(self): s = self.p.getServices() service_batt = s[3] service_control = s[4] self.char_batt_lvl = service_batt.getCharacteristics()[0] self.char_control_speed = service_control.getCharacteristics()[0] self.char_control_angle = service_control.getCharacteristics()[2] def battery_level(self): return int(self.char_batt_lvl.read()[0]) def speed(self, new_speed=None): if new_speed == None: return int(self.char_control_speed.read()[0]) else: self.char_control_speed.write(bytearray([new_speed])) def angle(self, new_angle=None): if new_angle == None: return int(self.char_control_angle.read()[0]) else: self.char_control_angle.write(bytearray([new_angle])) def connect(self): dev = None # connect to the airplane while not dev: dev = find_device_by_name("TailorToys PowerUp") if dev: self.p = Peripheral() self.p.connect(dev.addr()) # locate interesting characteristics self.map_chars() def rudder_center(self): if self.old_angle != 0: self.old_angle = 0 self.angle(0) def rudder_left(self, angle): steps = (angle // self.interval_size_left) new_angle = 60 - steps if self.old_angle != new_angle: self.angle(new_angle) self.old_angle = new_angle def rudder_right(self, angle): steps = (angle // self.interval_size_right) new_angle = -steps if self.old_angle != new_angle: self.angle(new_angle) self.old_angle = new_angle def throttle(self, speed): if (speed > 200): speed = 200 elif (speed < 0): speed = 0 if self.old_speed != speed: self.speed(speed) self.old_speed = speed def loop(self): adc_threshold = 10 right_threshold = self.x_mid + adc_threshold left_threshold = self.x_mid - adc_threshold self.interval_size_left = self.x_mid // 60 self.interval_size_right = (255 - self.x_mid) // 60 self.old_angle = 0 self.old_speed = 0 while True: time.sleep_ms(100) # read out new angle new_angle = self.read_stick_x() if (new_angle < 256): if (new_angle > right_threshold): self.rudder_right(new_angle - self.x_mid) elif (new_angle < left_threshold): self.rudder_left(new_angle) else: self.rudder_center() # read out new speed new_speed = self.old_speed if self.button_speed_up(): new_speed += 25 elif self.button_speed_down(): new_speed -= 25 elif self.button_speed_full(): new_speed = 200 elif self.button_speed_off(): new_speed = 0 else: pass self.throttle(new_speed)
from machine import Pin from utime import sleep_ms # assign led to Pin led = Pin(2, Pin.OUT, value=1) #{{{ 1 for i in range(10): led.value(not led.value()) # swich led value print(i) sleep_ms(500) #}}}
from nrf24l01 import NRF24L01 from machine import SPI, Pin from time import sleep import struct csn = Pin(14, mode=Pin.OUT, value=1) # Chip Select Not ce = Pin(17, mode=Pin.OUT, value=0) # Chip Enable led = Pin(25, Pin.OUT) # Onboard LED payload_size = 20 # Handle handle_forward = Pin(10, Pin.OUT) # Relay 1. handle_backward = Pin(11, Pin.OUT) # Relay 2. # Set both relays to off position handle_forward.value(1) handle_backward.value(1) # Define the channel or 'pipes' the radios use. # switch round the pipes depending if this is a sender or receiver pico #role = "send" role = "receive" if role == "send": send_pipe = b"\xe1\xf0\xf0\xf0\xf0" receive_pipe = b"\xd2\xf0\xf0\xf0\xf0" else: send_pipe = b"\xd2\xf0\xf0\xf0\xf0" receive_pipe = b"\xe1\xf0\xf0\xf0\xf0"
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=400000) ads = ads1x15.ADS1115(i2c, addr, gain) oled = ssd1306.SSD1306_I2C(128, 64, i2c) def measure(r2): vcc = ads.raw_to_v(ads.read(channel1=1)) vout = ads.raw_to_v(ads.read()) I = vout / r2 r1 = r2 * (vcc / vout - 1) print('---------') print('R1 = {:.2f} ohm'.format(r1)) print('Vcc = {:.2f} V'.format(vcc)) print('Vout = {:.2f} V'.format(vout)) print('I = {:.4f} mA'.format(I * 1000)) oled.fill(0) oled.text('ohms', 0, 0) oled.text('R1 = {:.2f}'.format(r1), 10, 30) oled.show() r2 = 9990 while True: if sw.value() == 0: time.sleep_ms(20) if sw.value() == 0: while sw.value() == 0: pass measure(r2)
fCsv.write(msg) fCsv.write('\n') fCsv.flush() print(msg) # show in repl count = count + 1 s.close() time.sleep(0.3) #<== Try a delay here... # ----------------------------- # add button manager if button() == 1: # pushbutton pressed if pressed == 1: continue # pushbutton pressed pycom.rgbled(0x7f0000) # red # switch on the user LED user_led.value(1) # print("---------------------------- button pressed !!") pressed = 1 else: # pushbutton released pycom.rgbled(0x007f00) # green # switch off the user LED user_led.value(0) pressed = 0
trigger1(0) while echo1() == 0: pass chrono.start() while echo1() == 1: pass chrono.stop() distance1 = chrono.read_us() / 58.0 if distance1 <= 7: p_green_light.value(1) count -= 1 else: p_green_light.value(0) if distance1 > 400: print("Out of range") else: print("Sensor 1 {:.0f} cm".format(distance1)) time.sleep(0.1) #-------------------- Sensor 2 ----------------------------------- chrono.reset()
import my_app from machine import Pin, reset from utime import sleep_ms sleep_ms(1000) pin = Pin(13, Pin.IN, Pin.PULL_UP) while True: if pin.value(): try: my_app.kmain() except: reset() else: sleep_ms(200)
from machine import Pin pin_button = Pin(0, Pin.IN) pin_led = Pin(14, Pin.OUT) while True: stav = pin_button.value() pin_led.value(stav)
test_pin_af() # try the entire af range on all pins # test pin init and printing pin = Pin(pin_map[0]) pin.init(mode=Pin.IN) print(pin) pin.init(Pin.IN, Pin.PULL_DOWN) print(pin) pin.init(mode=Pin.OUT, pull=Pin.PULL_UP, drive=pin.LOW_POWER) print(pin) pin.init(mode=Pin.OUT, pull=Pin.PULL_UP, drive=pin.HIGH_POWER) print(pin) # test value in OUT mode pin = Pin(pin_map[0], mode=Pin.OUT) pin.value(0) pin.toggle() # test toggle print(pin()) pin.toggle() # test toggle again print(pin()) # test different value settings pin(1) print(pin.value()) pin(0) print(pin.value()) pin.value(1) print(pin()) pin.value(0) print(pin()) # test all getters and setters
# ######################### # # Blink build-in Huzzah led # # ######################### # from machine import Timer, Pin p0 = Pin(0, Pin.OUT) tim = Timer(-1) tim.init(period=500, mode=Timer.PERIODIC, callback=lambda t: p0.value(not p0.value()))
class WifiClock: def __init__(self): # Initialize SPI self._spi = SPI(-1, baudrate=10000000, polarity=1, phase=0, sck=Pin(_SPI_CLK_PIN), mosi=Pin(_SPI_MOSI_PIN), miso=Pin(_SPI_MISO_PIN)) self._cs = Pin(_SPI_CS_PIN) self._cs.init(self._cs.OUT, True) # Initialize LEDs self.red_led = Pin(_RED_LED_PIN, Pin.OUT) self.green_led = Pin(_GREEN_LED_PIN, Pin.OUT) self.blue_led = Pin(_BLUE_LED_PIN, Pin.OUT) # Initialize buttons with interrupts self.mode_button = Pin(_MODE_BUTTON_PIN, Pin.IN, Pin.PULL_UP) self.mode_button.irq(trigger=Pin.IRQ_FALLING, handler=self.mode_button_callback) self.incr_button = Pin(_INCR_BUTTON_PIN, Pin.IN, Pin.PULL_UP) self.incr_button.irq(trigger=Pin.IRQ_FALLING, handler=self.incr_button_callback) self.decr_button = Pin(_DECR_BUTTON_PIN, Pin.IN, Pin.PULL_UP) self.decr_button.irq(trigger=Pin.IRQ_FALLING, handler=self.decr_button_callback) # Initialize current number and current decimal points self.current_num = None self.current_dp = 0b000000 # Initialize timer and rtc self.sta_if = network.WLAN(network.STA_IF) self.rtc = RTC() self.timer = Timer(1) for command, data in ( (_SHUTDOWN, 0), (_SCAN_LIMIT, 7), (_DECODE_MODE, 0xFF), (_INTENSITY, 0xa), (_SHUTDOWN, 1), ): self._register(command, data) self.display_clear() self.red_led.value(0) self.green_led.value(0) self.blue_led.value(0) # Connect to wifi def connect_to_wifi(self, ssid, password): if not self.sta_if.isconnected(): print('Connecting to network...') self.sta_if.active(True) self.sta_if.connect(ssid, password) while not self.sta_if.isconnected(): print('.', end='') time.sleep(1) print('Connected!') # Set time manually def set_time(self, hour, minute, second): self.rtc.datetime((2019, 1, 1, 0, hour, minute, second, 0)) # Set time using ntp server (must be connected to wifi) def set_time_ntp(self, utc_offset): ntptime.settime() d = self.rtc.datetime() hour = d[4] + utc_offset if hour < 0: hour = 24 + hour elif hour > 23: hour = hour - 24 d = (d[0], d[1], d[2], d[3], hour, d[5], d[6], d[7]) self.rtc.datetime(d) # Start a 24 hour clock (call after setting the time either with set_time or set_time_ntp) def start_clock24(self): self.timer.init(period=1000, mode=Timer.PERIODIC, callback=self.clock_timer_callback) # Set the display brightness def display_brightness(self, value): if 0 <= value <= 15: self._register(_INTENSITY, value) else: raise ValueError("Brightness out of range") # Clear the display def display_clear(self): self._register(_DECODE_MODE, 0xFF) for i in range(6): self._register(_DIGIT_DICT[i], 0x0F) self.current_num = None # Write a decimal value to the display, dp is 6 bit binary value representing where to put decimal points def write_num(self, value, dp=0b000000): self._register(_DECODE_MODE, 0xFF) if (0 <= value <= _MAX_VALUE_DEC) and (_MIN_VALUE_DP <= dp <= _MAX_VALUE_DP): self.current_num = value self.current_dp = dp for i in range(6): current_value = value % 10 if dp & 1: self._register(_DIGIT_DICT[i], current_value | _DP) else: self._register(_DIGIT_DICT[i], current_value) dp = dp >> 1 value = value // 10 elif (0 > value >= _MIN_VALUE_DEC) and (_MIN_VALUE_DP <= dp <= _MAX_VALUE_DP): self.current_num = value self.current_dp = dp value = -value self._register(_DIGIT5, 0xA) for i in range(5): current_value = value % 10 if dp & 1: self._register(_DIGIT_DICT[i], current_value | _DP) else: self._register(_DIGIT_DICT[i], current_value) dp = dp >> 1 value = value // 10 else: raise ValueError("Value out of range") # Write literal hex value to the display def write_hex(self, value): self._register(_DECODE_MODE, 0x0) if 0x0 <= value <= _MAX_VALUE_HEX: self.current_num = value for i in range(6): self._register(_DIGIT_DICT[i], _HEX_TO_SEG[value % 16]) value = value // 16 else: raise ValueError("Value out of range") # Toggle an LED @staticmethod def toggle_led(led): led.value(not (led.value())) # Increment the current number on the display def increment_num(self, hex=False): if self.current_num is None: raise ValueError("No value to increment") else: if hex: if (self.current_num + 1) > _MAX_VALUE_HEX: self.current_num = -1 self.write_hex(self.current_num + 1) else: if (self.current_num + 1) > _MAX_VALUE_DEC: self.current_num = -1 self.write_num(self.current_num + 1, self.current_dp) # Decrement the current number on the display def decrement_num(self, hex=False): if self.current_num is None: raise ValueError("No value to decrement") else: if hex: if (self.current_num - 1) < _MIN_VALUE_HEX: self.current_num = 1 self.write_hex(self.current_num - 1) else: if (self.current_num - 1) < _MIN_VALUE_DEC: self.current_num = 1 self.write_num(self.current_num - 1, self.current_dp) # Callback for Mode button def mode_button_callback(self, pin): if self._debounce(self.mode_button): self.toggle_led(self.red_led) # Callback for Incr Button def incr_button_callback(self, pin): if self._debounce(self.incr_button): self.increment_num() # Callback for Decr button def decr_button_callback(self, pin): if self._debounce(self.decr_button): self.decrement_num() # Callback for clock after calling start_clock24 def clock_timer_callback(self, tim): self._update_clock24() # Callback for other timer uses def timer_callback(self, tim): self.increment_num() # Read hours, minutes, and seconds from rtc and and write to the display def _update_clock24(self): current_time = self.rtc.datetime() hours = current_time[4] minutes = current_time[5] seconds = current_time[6] time_str = '' if hours < 10: time_str += '0' time_str += str(hours) if minutes < 10: time_str += '0' time_str += str(minutes) if seconds < 10: time_str += '0' time_str += str(seconds) self.write_num(int(time_str), 0b010100) # Send commands to MAX7219 def _register(self, command, data): self._cs.value(0) self._spi.write(bytearray([command, data])) self._cs.value(1) # Debounce function for debouncing buttons @staticmethod def _debounce(button): flag = 0 for i in range(_DEBOUNCE_SAMPLES): flag = button.value() if button.value(): return not flag return not flag
def choice(): if mode == 1: pwm1.freq(int(4 + adc.read() / 120)) if mode == 2: pwm0.duty(int(adc.read() / 10)) def display(): a = rtc.datetime() print(week[a[3]] + ", " + str(a[1]) + '/' + str(a[2]) + '/' + str(a[0]) + ', ' + str(a[4]) + ':' + ("%02d" % (a[5], )) + ':' + ("%02d" % (a[6], )) + '.' + str(a[7])) while (1): if button.value() and prev == 0: if mode != 1: mode = 1 else: mode = 2 prev = button.value() sleep(0.02) ''' while(1): if button_grn.value() == 1 and green == 0: green_total += 1 if green_total == 10: break if button_red.value() == 1 and red == 0: red_total += 1 if red_total == 10:
class MFRC522: OK = 0 NOTAGERR = 1 ERR = 2 REQIDL = 0x26 REQALL = 0x52 AUTHENT1A = 0x60 AUTHENT1B = 0x61 def __init__(self, sck, mosi, miso, rst, cs): self.sck = Pin(sck, Pin.OUT) self.mosi = Pin(mosi, Pin.OUT) self.miso = Pin(miso) self.rst = Pin(rst, Pin.OUT) self.cs = Pin(cs, Pin.OUT) self.rst.value(0) self.cs.value(1) if uname()[0] == 'WiPy': self.spi = SPI(0) self.spi.init(SPI.MASTER, baudrate=1000000, pins=(self.sck, self.mosi, self.miso)) elif uname()[0] == 'esp8266': self.spi = SPI(baudrate=100000, polarity=0, phase=0, sck=self.sck, mosi=self.mosi, miso=self.miso) self.spi.init() else: raise RuntimeError("Unsupported platform") self.rst.value(1) self.init() def _wreg(self, reg, val): self.cs.value(0) self.spi.write(b'%c' % int(0xff & ((reg << 1) & 0x7e))) self.spi.write(b'%c' % int(0xff & val)) self.cs.value(1) def _rreg(self, reg): self.cs.value(0) self.spi.write(b'%c' % int(0xff & (((reg << 1) & 0x7e) | 0x80))) val = self.spi.read(1) self.cs.value(1) return val[0] def _sflags(self, reg, mask): self._wreg(reg, self._rreg(reg) | mask) def _cflags(self, reg, mask): self._wreg(reg, self._rreg(reg) & (~mask)) def _tocard(self, cmd, send): recv = [] bits = irq_en = wait_irq = n = 0 stat = self.ERR if cmd == 0x0E: irq_en = 0x12 wait_irq = 0x10 elif cmd == 0x0C: irq_en = 0x77 wait_irq = 0x30 self._wreg(0x02, irq_en | 0x80) self._cflags(0x04, 0x80) self._sflags(0x0A, 0x80) self._wreg(0x01, 0x00) for c in send: self._wreg(0x09, c) self._wreg(0x01, cmd) if cmd == 0x0C: self._sflags(0x0D, 0x80) i = 2000 while True: n = self._rreg(0x04) i -= 1 if ~((i != 0) and ~(n & 0x01) and ~(n & wait_irq)): break self._cflags(0x0D, 0x80) if i: if (self._rreg(0x06) & 0x1B) == 0x00: stat = self.OK if n & irq_en & 0x01: stat = self.NOTAGERR elif cmd == 0x0C: n = self._rreg(0x0A) lbits = self._rreg(0x0C) & 0x07 if lbits != 0: bits = (n - 1) * 8 + lbits else: bits = n * 8 if n == 0: n = 1 elif n > 16: n = 16 for _ in range(n): recv.append(self._rreg(0x09)) else: stat = self.ERR return stat, recv, bits def _crc(self, data): self._cflags(0x05, 0x04) self._sflags(0x0A, 0x80) for c in data: self._wreg(0x09, c) self._wreg(0x01, 0x03) i = 0xFF while True: n = self._rreg(0x05) i -= 1 if not ((i != 0) and not (n & 0x04)): break return [self._rreg(0x22), self._rreg(0x21)] def init(self): self.reset() self._wreg(0x2A, 0x8D) self._wreg(0x2B, 0x3E) self._wreg(0x2D, 30) self._wreg(0x2C, 0) self._wreg(0x15, 0x40) self._wreg(0x11, 0x3D) self.antenna_on() def reset(self): self._wreg(0x01, 0x0F) def antenna_on(self, on=True): if on and ~(self._rreg(0x14) & 0x03): self._sflags(0x14, 0x03) else: self._cflags(0x14, 0x03) def request(self, mode): self._wreg(0x0D, 0x07) (stat, recv, bits) = self._tocard(0x0C, [mode]) if (stat != self.OK) | (bits != 0x10): stat = self.ERR return stat, bits def anticoll(self): ser_chk = 0 ser = [0x93, 0x20] self._wreg(0x0D, 0x00) (stat, recv, bits) = self._tocard(0x0C, ser) if stat == self.OK: if len(recv) == 5: for i in range(4): ser_chk = ser_chk ^ recv[i] if ser_chk != recv[4]: stat = self.ERR else: stat = self.ERR return stat, recv def select_tag(self, ser): buf = [0x93, 0x70] + ser[:5] buf += self._crc(buf) (stat, recv, bits) = self._tocard(0x0C, buf) return self.OK if (stat == self.OK) and (bits == 0x18) else self.ERR def auth(self, mode, addr, sect, ser): return self._tocard(0x0E, [mode, addr] + sect + ser[:4])[0] def stop_crypto1(self): self._cflags(0x08, 0x08) def read(self, addr): data = [0x30, addr] data += self._crc(data) (stat, recv, _) = self._tocard(0x0C, data) return recv if stat == self.OK else None def write(self, addr, data): buf = [0xA0, addr] buf += self._crc(buf) (stat, recv, bits) = self._tocard(0x0C, buf) if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A): stat = self.ERR else: buf = [] for i in range(16): buf.append(data[i]) buf += self._crc(buf) (stat, recv, bits) = self._tocard(0x0C, buf) if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A): stat = self.ERR return stat
# Complete project details at https://RandomNerdTutorials.com from machine import Pin, I2C import ssd1306 from time import sleep # ESP32 Pin assignment p16 = Pin(16, Pin.OUT) p16.value(1) i2c = I2C(-1, scl=Pin(15), sda=Pin(4)) # ESP8266 Pin assignment #i2c = I2C(-1, scl=Pin(5), sda=Pin(4)) oled_width = 128 oled_height = 64 oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c) oled.text('Hello, World 1!', 0, 0) oled.text('Hello, World 2!', 0, 10) oled.text('Hello, World 3!', 0, 20) oled.show()