first add

Digital/dht11.py

+import time
+from machine import Pin
+
+MAXTIMINGS  = 85
+
+DHT11 = 11
+DHT22 = 22
+DHT21 = 21
+AM2301 = 21
+
+class DHT(object):
+    def __init__(self, data_pin,Type=DHT11):
+        self.Data_pin = data_pin
+        self.__pinData = Pin(data_pin, Pin.OUT)
+        self.firstreading = True
+        self.__pinData.value(1)
+        self._lastreadtime = 0
+        self.data=[0]*5
+        self.temp = 0
+        self.humid = 0
+
+    def read(self):
+        i=0
+        j=0
+        self.__pinData.value(1) 
+        #time.sleep(0.25) 
+
+        self.data[0] =  self.data[1] =  self.data[2] =  self.data[3] =  self.data[4] = 0 
+        
+        # now pull it low for ~20 milliseconds
+        pinData = Pin(self.Data_pin, Pin.OUT, None)
+        pinData.value(0) 
+        time.sleep_ms(20)
+        pinData.value(1)
+        time.sleep_us(41)
+        pinData = Pin(self.Data_pin, Pin.IN)
+        DHT11_TIMEOUT = -1
+        time_cnt=0
+        while(0 ==pinData.value()):
+            time.sleep_us(5)  
+            time_cnt = time_cnt+1
+            if(time_cnt > 16): 
+                return
+        
+        #DHT11将总线拉高至少80us，为发送传感器数据做准备。
+        time_cnt=0
+        while(1 == pinData.value()):
+            time.sleep_us(5)   
+            time_cnt = time_cnt+1
+            if(time_cnt > 16): 
+                return  
+        
+        
+        for j in range(5):
+            i = 0
+            result=0
+            PINC = 1
+            for i in range(8):
+
+                while(not (PINC & pinData.value())):  # wait for 50us
+                    pass
+                    #print('wait 50us')
+                time.sleep_us(25)
+
+                if(PINC & pinData.value()):
+                    result |=(1<<(7-i))
+                while(PINC & pinData.value()):  # wait '0' finish
+                    time.sleep_us(5)   
+                    time_cnt = time_cnt+1
+                    if(time_cnt > 20): 
+                        return  
+                    #print('wait 1')
+            self.data[j] = result
+
+        pinData = Pin(self.Data_pin, Pin.OUT, None)
+        pinData.value(1)   
+
+        dht11_check_sum = (self.data[0]+self.data[1]+self.data[2]+self.data[3]&0xff)
+        # check check_sum
+        if(self.data[4] is not dht11_check_sum):
+            print("DHT11 checksum error")
+        #print(self.data) 
+        if ((j >= 4) and ( self.data[4] == dht11_check_sum)):
+            return True 
+        return False
+        
+    def readHumidity(self):
+        if (self.read()):
+            self.humid = float(self.data[0])
+            self.humid = self.humid + float(self.data[1]/10)
+        return self.humid
+
+    def readTemperature(self):
+        if (self.read()):
+            self.temp = float(self.data[2])
+            self.temp = self.temp + float(self.data[3]/10)
+        return self.temp
+    
+    def readTempHumid(self):
+        if (self.read()):        
+            self.temp = float(self.data[2])
+            self.temp = self.temp + float(self.data[3]/10)
+            self.humid = float(self.data[0])
+            self.humid = self.humid + float(self.data[1]/10)
+        return self.temp , self.humid
+'''           
+dht = DHT(6)
+for i in range(100):
+    #dht.read()
+    dht.readHumidity()
+    dht.readTemperature()
+'''

Digital/ws2812.py

+import array, time
+from machine import Pin
+import rp2
+
+# Configure the number of WS2812 LEDs.
+#brightness = 0.2
+@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT, autopull=True,pull_thresh=24)
+def ws2812():
+    T1 = 2
+    T2 = 5
+    T3 = 3
+    wrap_target()
+    label("bitloop")
+    out(x, 1) .side(0) [T3 - 1]
+    jmp(not_x, "do_zero") .side(1) [T1 - 1]
+    jmp("bitloop") .side(1) [T2 - 1]
+    label("do_zero")
+    nop() .side(0) [T2 - 1]
+    wrap()
+class WS2812():        
+    def __init__(self, pin_num, led_count, brightness = 0.5):
+        self.Pin = Pin
+        self.led_count = led_count
+        self.brightness = brightness
+        self.sm = rp2.StateMachine(0, ws2812, freq=8_000_000, sideset_base=Pin(pin_num))
+        self.sm.active(1)
+        self.ar = array.array("I", [0 for _ in range(led_count)])
+        
+    def pixels_show(self):
+        dimmer_ar = array.array("I", [0 for _ in range(self.led_count)])
+        for i,c in enumerate(self.ar):
+            r = int(((c >> 8) & 0xFF) * self.brightness)
+            g = int(((c >> 16) & 0xFF) * self.brightness)
+            b = int((c & 0xFF) * self.brightness)
+            dimmer_ar[i] = (g<<16) + (r<<8) + b
+        self.sm.put(dimmer_ar, 8)
+        time.sleep_ms(10)
+
+    def pixels_set(self, i, color):
+        self.ar[i] = (color[1]<<16) + (color[0]<<8) + color[2]
+
+    def pixels_fill(self, color):
+        for i in range(len(self.ar)):
+            self.pixels_set(i, color)
+
+    def color_chase(self,color, wait):
+        for i in range(self.led_count):
+            self.pixels_set(i, color)
+            time.sleep(wait)
+            self.pixels_show()
+        time.sleep(0.2)
+    def wheel(self, pos):
+    # Input a value 0 to 255 to get a color value.
+    # The colours are a transition r - g - b - back to r.
+        if pos < 0 or pos > 255:
+            return (0, 0, 0)
+        if pos < 85:
+            return (255 - pos * 3, pos * 3, 0)
+        if pos < 170:
+            pos -= 85
+            return (0, 255 - pos * 3, pos * 3)
+        pos -= 170
+        return (pos * 3, 0, 255 - pos * 3)
+
+
+    def rainbow_cycle(self, wait):
+        for j in range(255):
+            for i in range(self.led_count):
+                rc_index = (i * 256 // self.led_count) + j
+                self.pixels_set(i, self.wheel(rc_index & 255))
+            self.pixels_show()
+            time.sleep(wait)
+

I2C/Acc_Adxl345.py

+from machine import I2C
+import time
+
+ADXL345_DEVICE = (0x53)
+
+""" ------- Register names ------- """
+ADXL345_DEVID           =0x00
+ADXL345_RESERVED1       =0x01
+ADXL345_THRESH_TAP      =0x1d
+ADXL345_OFSX            =0x1e
+ADXL345_OFSY            =0x1f
+ADXL345_OFSZ            =0x20
+ADXL345_DUR             =0x21
+ADXL345_LATENT          =0x22
+ADXL345_WINDOW          =0x23
+ADXL345_THRESH_ACT      =0x24
+ADXL345_THRESH_INACT    =0x25
+ADXL345_TIME_INACT      =0x26
+ADXL345_ACT_INACT_CTL   =0x27
+ADXL345_THRESH_FF       =0x28
+ADXL345_TIME_FF         =0x29
+ADXL345_TAP_AXES        =0x2a
+ADXL345_ACT_TAP_STATUS  =0x2b
+ADXL345_BW_RATE         =0x2c
+ADXL345_POWER_CTL       =0x2d
+ADXL345_INT_ENABLE      =0x2e
+ADXL345_INT_MAP         =0x2f
+ADXL345_INT_SOURCE      =0x30
+ADXL345_DATA_FORMAT     =0x31
+ADXL345_DATAX0          =0x32
+ADXL345_DATAX1          =0x33
+ADXL345_DATAY0          =0x34
+ADXL345_DATAY1          =0x35
+ADXL345_DATAZ0          =0x36
+ADXL345_DATAZ1          =0x37
+ADXL345_FIFO_CTL        =0x38
+ADXL345_FIFO_STATUS     =0x39
+
+ADXL345_BW_1600         =0xF                 #  1111
+ADXL345_BW_800          =0xE                 #  1110
+ADXL345_BW_400          =0xD                 #  1101
+ADXL345_BW_200          =0xC                 #  1100
+ADXL345_BW_100          =0xB                 #  1011
+ADXL345_BW_50           =0xA                 #  1010
+ADXL345_BW_25           =0x9                 #  1001
+ADXL345_BW_12           =0x8                 #  1000
+ADXL345_BW_6            =0x7                 #  0111
+ADXL345_BW_3            =0x6                 #  0110
+
+"""
+Interrupt PINs
+INT1: 0
+INT2: 1
+"""
+ADXL345_INT1_PIN            =0x00
+ADXL345_INT2_PIN            =0x01
+
+"""Interrupt bit position"""
+ADXL345_INT_DATA_READY_BIT  =0x07
+ADXL345_INT_SINGLE_TAP_BIT  =0x06
+ADXL345_INT_DOUBLE_TAP_BIT  =0x05
+ADXL345_INT_ACTIVITY_BIT    =0x04
+ADXL345_INT_INACTIVITY_BIT  =0x03
+ADXL345_INT_FREE_FALL_BIT   =0x02
+ADXL345_INT_WATERMARK_BIT   =0x01
+ADXL345_INT_OVERRUNY_BIT    =0x00
+
+ADXL345_DATA_READY          =0x07
+ADXL345_SINGLE_TAP          =0x06
+ADXL345_DOUBLE_TAP          =0x05
+ADXL345_ACTIVITY            =0x04
+ADXL345_INACTIVITY          =0x03
+ADXL345_FREE_FALL           =0x02
+ADXL345_WATERMARK           =0x01
+ADXL345_OVERRUNY            =0x00
+
+ADXL345_OK                  =1                   #  no error
+ADXL345_ERROR               =0                   #  indicates error is predent
+
+ADXL345_NO_ERROR            =0                   #  initial state
+ADXL345_READ_ERROR          =1                   #  problem reading accel
+ADXL345_BAD_ARG             =2                   #  bad method argument
+
+
+class AccelerationAdxl345(object):
+
+    def __init__(self, i2c, addr=ADXL345_DEVICE, drdy=None):
+        self.i2c_device = i2c
+        time.sleep(0.1)
+        #self.rgbMatrixData = [0xFF]*64
+
+    def read(self, reg_base, reg, buf):
+        self.write(reg)
+        time.sleep(.001)
+        self.i2c_device.readfrom_into(59,buf)
+
+    def write(self, buf=None):
+        if buf is not None:
+            self.i2c_device.writeto(ADXL345_DEVICE, buf)
+        # i2c_device.writeto(0x58, bytearray([3,100,100,16,39]))
+
+    def writeTo(self,address, val):
+        dta_send = bytearray([address, val])
+        self.write(dta_send)
+    
+    def readFrom(self, address, num):
+        data_0 = address & 0xff
+        dta_send = bytearray([data_0])
+        self.write(dta_send)
+        time.sleep(.001)
+        result=self.i2c_device.readfrom(ADXL345_DEVICE, num)
+        return result
+
+    def setRegisterBit(self, regAdress,  bitPos,  state):  
+        bytes=self.readFrom(regAdress, 1)
+        for _b in bytes:
+            value = int(_b)
+        if (state):
+            value |= (1 << bitPos)                 
+        else:
+            value &= ~(1 << bitPos)                   
+        self.writeTo(regAdress, value)
+
+    def acc_adxl345_init(self):
+        #Turning on the ADXL345
+        self.writeTo(ADXL345_POWER_CTL, 0)
+        self.writeTo(ADXL345_POWER_CTL, 16)
+        self.writeTo(ADXL345_POWER_CTL, 8)
+
+        self.writeTo(ADXL345_THRESH_ACT, 75)
+        self.writeTo(ADXL345_THRESH_INACT, 75)
+        self.writeTo(ADXL345_TIME_INACT, 10)
+
+        #look of activity movement on this axes - 1 == on; 0 == off
+        self.setRegisterBit(ADXL345_ACT_INACT_CTL, 6, 1)
+        self.setRegisterBit(ADXL345_ACT_INACT_CTL, 5, 1)
+        self.setRegisterBit(ADXL345_ACT_INACT_CTL, 4, 1)
+
+        #look of inactivity movement on this axes - 1 == on; 0 == off
+        self.setRegisterBit(ADXL345_ACT_INACT_CTL, 2, 1)
+        self.setRegisterBit(ADXL345_ACT_INACT_CTL, 1, 1)
+        self.setRegisterBit(ADXL345_ACT_INACT_CTL, 0, 1)
+
+        self.setRegisterBit(ADXL345_TAP_AXES, 2, 0)
+        self.setRegisterBit(ADXL345_TAP_AXES, 1, 0)
+        self.setRegisterBit(ADXL345_TAP_AXES, 0, 0)
+
+        #set values for what is a tap, and what is a double tap (0-255)
+        #setTapThreshold(50); # 62.5mg per increment
+        self.writeTo(ADXL345_THRESH_TAP, 50)
+
+        self.writeTo(ADXL345_DUR, 15)
+
+        self.writeTo(ADXL345_LATENT, 80)
+
+        #setDoubleTapWindow(200); # 1.25ms per increment
+        self.writeTo(ADXL345_WINDOW, 200)
+
+        #set values for what is considered freefall (0-255)
+
+        self.writeTo(ADXL345_THRESH_FF, 7)
+
+        self.writeTo(ADXL345_TIME_FF, 45)
+        #setting all interrupts to take place on int pin 1
+        #I had issues with int pin 2, was unable to reset it
+
+        self.setRegisterBit(ADXL345_INT_MAP, ADXL345_INT_SINGLE_TAP_BIT,   ADXL345_INT1_PIN)
+        self.setRegisterBit(ADXL345_INT_MAP, ADXL345_INT_DOUBLE_TAP_BIT,   ADXL345_INT1_PIN)
+        self.setRegisterBit(ADXL345_INT_MAP, ADXL345_INT_FREE_FALL_BIT,    ADXL345_INT1_PIN)
+        self.setRegisterBit(ADXL345_INT_MAP, ADXL345_INT_ACTIVITY_BIT,     ADXL345_INT1_PIN)
+        self.setRegisterBit(ADXL345_INT_MAP, ADXL345_INT_INACTIVITY_BIT,   ADXL345_INT1_PIN)
+
+        #register interrupt actions - 1 == on; 0 == off
+        self.setRegisterBit(ADXL345_INT_ENABLE, ADXL345_INT_SINGLE_TAP_BIT, 1)
+        self.setRegisterBit(ADXL345_INT_ENABLE, ADXL345_INT_DOUBLE_TAP_BIT, 1)
+        self.setRegisterBit(ADXL345_INT_ENABLE, ADXL345_INT_FREE_FALL_BIT,  1)
+        self.setRegisterBit(ADXL345_INT_ENABLE, ADXL345_INT_ACTIVITY_BIT,   1)
+        self.setRegisterBit(ADXL345_INT_ENABLE, ADXL345_INT_INACTIVITY_BIT, 1)
+
+    def acc_adxl345_read_xyz(self):
+        ADXL345_TO_READ = (6)
+        _buff = self.readFrom(ADXL345_DATAX0, ADXL345_TO_READ) #read the acceleration data from the ADXL345
+        if _buff[1] <= 0:
+            x=_buff[0]
+        else:
+            x=(_buff[0]-255)
+
+        if _buff[3] <= 0:
+            y=_buff[2]
+        else:
+            y=(_buff[2]-255)
+
+        if _buff[5] <= 0:
+            z=_buff[4]
+        else:
+            z=(_buff[4]-255)
+
+        #x = int(((_buff[1]) << 8) | _buff[0]) 
+        #y = int(((_buff[3]) << 8) | _buff[2]) 
+        #z = int(((_buff[5]) << 8) | _buff[4]) 
+
+        #print("%d, %d, %d\r\n", x, y, z) 
+        return [x,y,z]
+
+    def acc_adxl345_read_acc(self):
+        __Gains = [0.00376390, 0.00376009, 0.00389265]
+        xyz=self.acc_adxl345_read_xyz()
+
+        ax = xyz[0] * __Gains[0]
+        ay = xyz[1] * __Gains[1]
+        az = xyz[2] * __Gains[2]
+        return [ax,ay,az]
+
+    def get_acc_adxl345_property(self,xyz):
+        axyz=self.acc_adxl345_read_acc()
+        if(xyz == 0):
+            return axyz[0]
+        if(xyz == 1):
+            return axyz[1]
+        if(xyz == 2):
+            return axyz[2]
+
+"""
+acceleration = AccelerationAdxl345()
+acceleration.acc_adxl345_init()
+acceleration.get_acc_adxl345_property(0)
+acceleration.get_acc_adxl345_property(1)
+acceleration.get_acc_adxl345_property(2)
+"""

I2C/ssd1306.py

+# MicroPython SSD1306 OLED driver, I2C and SPI interfaces
+
+from micropython import const
+import framebuf
+
+
+# register definitions
+SET_CONTRAST = const(0x81)
+SET_ENTIRE_ON = const(0xA4)
+SET_NORM_INV = const(0xA6)
+SET_DISP = const(0xAE)
+SET_MEM_ADDR = const(0x20)
+SET_COL_ADDR = const(0x21)
+SET_PAGE_ADDR = const(0x22)
+SET_DISP_START_LINE = const(0x40)
+SET_SEG_REMAP = const(0xA0)
+SET_MUX_RATIO = const(0xA8)
+SET_COM_OUT_DIR = const(0xC0)
+SET_DISP_OFFSET = const(0xD3)
+SET_COM_PIN_CFG = const(0xDA)
+SET_DISP_CLK_DIV = const(0xD5)
+SET_PRECHARGE = const(0xD9)
+SET_VCOM_DESEL = const(0xDB)
+SET_CHARGE_PUMP = const(0x8D)
+
+# Subclassing FrameBuffer provides support for graphics primitives
+# http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
+class SSD1306(framebuf.FrameBuffer):
+    def __init__(self, width, height, external_vcc):
+        self.width = width
+        self.height = height
+        self.external_vcc = external_vcc
+        self.pages = self.height // 8
+        self.buffer = bytearray(self.pages * self.width)
+        super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB)
+        self.init_display()
+
+    def init_display(self):
+        for cmd in (
+            SET_DISP | 0x00,  # off
+            # address setting
+            SET_MEM_ADDR,
+            0x00,  # horizontal
+            # resolution and layout
+            SET_DISP_START_LINE | 0x00,
+            SET_SEG_REMAP | 0x01,  # column addr 127 mapped to SEG0
+            SET_MUX_RATIO,
+            self.height - 1,
+            SET_COM_OUT_DIR | 0x08,  # scan from COM[N] to COM0
+            SET_DISP_OFFSET,
+            0x00,
+            SET_COM_PIN_CFG,
+            0x02 if self.width > 2 * self.height else 0x12,
+            # timing and driving scheme
+            SET_DISP_CLK_DIV,
+            0x80,
+            SET_PRECHARGE,
+            0x22 if self.external_vcc else 0xF1,
+            SET_VCOM_DESEL,
+            0x30,  # 0.83*Vcc
+            # display
+            SET_CONTRAST,
+            0xFF,  # maximum
+            SET_ENTIRE_ON,  # output follows RAM contents
+            SET_NORM_INV,  # not inverted
+            # charge pump
+            SET_CHARGE_PUMP,
+            0x10 if self.external_vcc else 0x14,
+            SET_DISP | 0x01,
+        ):  # on
+            self.write_cmd(cmd)
+        self.fill(0)
+        self.show()
+
+    def poweroff(self):
+        self.write_cmd(SET_DISP | 0x00)
+
+    def poweron(self):
+        self.write_cmd(SET_DISP | 0x01)
+
+    def contrast(self, contrast):
+        self.write_cmd(SET_CONTRAST)
+        self.write_cmd(contrast)
+
+    def invert(self, invert):
+        self.write_cmd(SET_NORM_INV | (invert & 1))
+
+    def show(self):
+        x0 = 0
+        x1 = self.width - 1
+        if self.width == 64:
+            # displays with width of 64 pixels are shifted by 32
+            x0 += 32
+            x1 += 32
+        self.write_cmd(SET_COL_ADDR)
+        self.write_cmd(x0)
+        self.write_cmd(x1)
+        self.write_cmd(SET_PAGE_ADDR)
+        self.write_cmd(0)
+        self.write_cmd(self.pages - 1)
+        self.write_data(self.buffer)
+
+
+class SSD1306_I2C(SSD1306):
+    def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):
+        self.i2c = i2c
+        self.addr = addr
+        self.temp = bytearray(2)
+        self.write_list = [b"\x40", None]  # Co=0, D/C#=1
+        super().__init__(width, height, external_vcc)
+
+    def write_cmd(self, cmd):
+        self.temp[0] = 0x80  # Co=1, D/C#=0
+        self.temp[1] = cmd
+        self.i2c.writeto(self.addr, self.temp)
+
+    def write_data(self, buf):
+        self.write_list[1] = buf
+        self.i2c.writevto(self.addr, self.write_list)
+
+
+class SSD1306_SPI(SSD1306):
+    def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
+        self.rate = 10 * 1024 * 1024
+        dc.init(dc.OUT, value=0)
+        res.init(res.OUT, value=0)
+        cs.init(cs.OUT, value=1)
+        self.spi = spi
+        self.dc = dc
+        self.res = res
+        self.cs = cs
+        import time
+
+        self.res(1)
+        time.sleep_ms(1)
+        self.res(0)
+        time.sleep_ms(10)
+        self.res(1)
+        super().__init__(width, height, external_vcc)
+
+    def write_cmd(self, cmd):
+        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
+        self.cs(1)
+        self.dc(0)
+        self.cs(0)
+        self.spi.write(bytearray([cmd]))
+        self.cs(1)
+
+    def write_data(self, buf):
+        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
+        self.cs(1)
+        self.dc(1)
+        self.cs(0)
+        self.spi.write(buf)
+        self.cs(1)
\ No newline at end of file

example/Demo.py

+from machine import Pin, I2C, ADC, UART, SPI, PWM
+from time import sleep
+from ssd1306 import SSD1306_I2C
+from dht11 import *
+
+i2c = I2C(1, scl=Pin(7), sda=Pin(6), freq=200000)#oled 接i2c1口
+oled = SSD1306_I2C(128, 64, i2c)
+dht2 = DHT(20) #温湿度传感器接D20口
+adc = ADC(2) #ADC输入（旋钮电位器）接A0
+pwm = PWM(Pin(27))#DAC输出（蜂鸣器）接A1
+button = Pin(18, Pin.IN, Pin.PULL_UP)#按键接p18
+button.irq(lambda pin: InterruptsButton(),Pin.IRQ_FALLING)#设置按键中断
+led = Pin(16, Pin.OUT)#led灯接p16
+uart = UART(0, baudrate=115200)
+
+tmp = 0
+
+'''按键中断函数，按下按键时改变灯的状态'''
+def InterruptsButton(): #按键输入
+    global tmp
+    tmp = ~tmp
+    led.value(tmp)
+    
+#进入循环
+while True:  
+    '''串口测试'''
+    #通过uart发送“hello”
+    uart.write("hello\n")
+    sleep(0.01)
+    if uart.any():
+        # 如果有数据 读入一行数据返回数据为字节类型
+        # 例如  b'hello\n'
+        buff = uart.readline()
+        # 将收到的信息打印在终端
+        print('Echo Byte: {}'.format(buff))
+        
+    '''SPI口测试'''
+    #spi = SPI(0)
+    #spi.init(115200)
+    #spi.write('0xFC')
+    #buf = spi.read(5)
+    #buf = bytearray(16)
+    #spi.write_readinto('out', buf)
+    #print(buf)
+    
+    '''模拟口测试'''
+    val = adc.read_u16()#读取A2口adc值（65535~0）
+    #驱动蜂鸣器，adc值小于300时关闭蜂鸣器
+    if val > 300:
+        pwm.freq(int(val/30))
+        pwm.duty_u16(1000)
+    else:
+        pwm.duty_u16(0)
+    
+    
+    '''GPIO口测试'''
+    #温湿度传感器DHT11测试
+    temp,humid = dht2.readTempHumid()#temp:温度 humid:湿度
+
+    
+    '''I2C口测试'''    
+    ''' oled显示器测试'''
+    oled.fill(0)#清屏
+    oled.text("Temp:  " + str(temp),0,0)#第一行显示温度
+    oled.text("Humid: " + str(humid),0,8)
+    oled.text("Val:   " + str(val),0,16)
+    oled.text("Buff:  " + str(buff),0,24)
+    oled.text("led:   "+ str(tmp and "on" or "off") ,0,32)
+    oled.show()
+    
+    '''文件管理测试'''
+    file = open("test.txt", "w")#打开test.txt文件，写入以下信息
+    file.write("Temp:  " + str(temp) + "\n")
+    file.write("Humid: " + str(humid) + "\n")
+    file.write("Val:   " + str(val) + "\n")
+    file.write("Buff:  " + str(buff)+ "\n")
+    file.close()
\ No newline at end of file

example/buzze.py

+from machine import Pin, I2C, ADC, PWM
+from time import sleep
+
+adc = ADC(2) #ADC输入（旋钮电位器）接A0
+pwm = PWM(Pin(27))#DAC输出（蜂鸣器）接A1
+
+while True: 
+    '''模拟口测试'''
+    val = adc.read_u16()#读取A2口adc值（65535~0）
+    #驱动蜂鸣器，adc值小于300时关闭蜂鸣器
+    if val > 300:
+        pwm.freq(int(val/30))
+        pwm.duty_u16(1000)
+    else:
+        pwm.duty_u16(0)
+    

example/led.py

+from machine import Pin
+
+button = Pin(18, Pin.IN, Pin.PULL_UP)#按键接p18
+button.irq(lambda pin: InterruptsButton(),Pin.IRQ_FALLING)#设置按键中断
+led = Pin(16, Pin.OUT)#led灯接p16
+tmp = 0
+'''按键中断函数，按下按键时改变灯的状态'''
+def InterruptsButton(): #按键输入
+    global tmp
+    tmp = ~tmp
+    led.value(tmp)
+while True:  
+    pass
\ No newline at end of file

example/oled.py

+from ssd1306 import SSD1306_I2C
+from dht11 import *
+from machine import Pin, I2C
+from time import sleep
+
+i2c = I2C(1, scl=Pin(7), sda=Pin(6), freq=200000)#oled 接i2c1口
+oled = SSD1306_I2C(128, 64, i2c)
+dht2 = DHT(18) #温湿度传感器接D18口
+
+
+while True:  
+
+    temp,humid = dht2.readTempHumid()#temp:温度 humid:湿度
+    '''I2C口测试'''    
+    ''' oled显示器测试'''
+    oled.fill(0)#清屏
+    oled.text("Temp:  " + str(temp),0,0)#第一行显示温度
+    oled.text("Humid: " + str(humid),0,8)
+    oled.show()
+    #sleep(0.5)
\ No newline at end of file

example/ws2812.py

+from ws2812 import WS2812
+import time
+
+BLACK = (0, 0, 0)
+RED = (255, 0, 0)
+YELLOW = (255, 150, 0)
+GREEN = (0, 255, 0)
+CYAN = (0, 255, 255)
+BLUE = (0, 0, 255)
+PURPLE = (180, 0, 255)
+WHITE = (255, 255, 255)
+COLORS = (BLACK, RED, YELLOW, GREEN, CYAN, BLUE, PURPLE, WHITE)
+
+#WS2812(pin_num,led_count)
+led = WS2812(18,30)
+
+print("fills")
+for color in COLORS:
+    led.pixels_fill(color)
+    led.pixels_show()
+    time.sleep(0.2)
+
+print("chases")
+for color in COLORS:
+    led.color_chase(color, 0.01)
+
+print("rainbow")
+led.rainbow_cycle(0)
\ No newline at end of file